@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/utils/interaction-utils.js

@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultInteraction = getDefaultInteraction;
+exports.findFieldsToShow = findFieldsToShow;
+exports.getTooltipDisplayDeltaValue = getTooltipDisplayDeltaValue;
+exports.getTooltipDisplayValue = getTooltipDisplayValue;
+exports.BRUSH_CONFIG = exports.TOOLTIP_MINUS_SIGN = void 0;
+
+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.
+// \u2212 is the minus sign that d3-format uses for decimal number formatting
+var TOOLTIP_MINUS_SIGN = "\u2212";
+/**
+ * @type {typeof import('./interaction-utils').getDefaultInteraction}
+ */
+
+exports.TOOLTIP_MINUS_SIGN = TOOLTIP_MINUS_SIGN;
+
+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 = {
+  range: [0, 50]
+};
+/**
+ * @type {typeof import('./interaction-utils').findFieldsToShow}
+ */
+
+exports.BRUSH_CONFIG = BRUSH_CONFIG;
+
+function findFieldsToShow(_ref) {
+  var fields = _ref.fields,
+      id = _ref.id;
+
+  // 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;
+    })) {
+      prev.push(curr);
+    }
+
+    return prev;
+  }, []);
+
+  return (0, _defineProperty2["default"])({}, id, fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields));
+}
+
+function autoFindTooltipFields(fields) {
+  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, _defaultSettings.MAX_DEFAULT_TOOLTIPS).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;
+}
+/**
+ * @type {typeof import('./interaction-utils').getTooltipDisplayValue}
+ */
+
+
+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,"sources":["../../src/utils/interaction-utils.js"],"names":["TOOLTIP_MINUS_SIGN","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","fields","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","MAX_DEFAULT_TOOLTIPS","map","format","pairs","pair","getTooltipDisplayDeltaValue","primaryData","field","data","fieldIdx","item","displayDeltaValue","integer","real","baseDp","valueAt","dp","deltaValue","RELATIVE","deltaFormat","TOOLTIP_FORMATS","DECIMAL_PERCENT_FULL_2","TOOLTIP_KEY","DECIMAL_DECIMAL_FIXED_3","deltaFirstChar","charAt","getTooltipDisplayValue","dataValue"],"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  MAX_DEFAULT_TOOLTIPS,\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\n// \\u2212 is the minus sign that d3-format uses for decimal number formatting\nexport const TOOLTIP_MINUS_SIGN = '\\u2212';\n\n/**\n * @type {typeof import('./interaction-utils').getDefaultInteraction}\n */\nexport function getDefaultInteraction() {\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: [0, 50]\n};\n\n/**\n * @type {typeof import('./interaction-utils').findFieldsToShow}\n */\nexport function findFieldsToShow({fields, id}) {\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      prev.push(curr);\n    }\n    return prev;\n  }, []);\n\n  return {\n    [id]: fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields)\n  };\n}\n\nfunction autoFindTooltipFields(fields) {\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, MAX_DEFAULT_TOOLTIPS).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  let displayDeltaValue = 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\n/**\n * @type {typeof import('./interaction-utils').getTooltipDisplayValue}\n */\nexport function getTooltipDisplayValue({item, field, data, fieldIdx}) {\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"]}

package/dist/utils/layer-utils.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findDefaultLayer = findDefaultLayer;
+exports.calculateLayerData = calculateLayerData;
+exports.getLayerHoverProp = getLayerHoverProp;
+exports.renderDeckGlLayer = renderDeckGlLayer;
+exports.isLayerRenderable = isLayerRenderable;
+exports.isLayerVisible = isLayerVisible;
+exports.prepareLayersForDeck = prepareLayersForDeck;
+exports.prepareLayersToRender = prepareLayersToRender;
+exports.getMaskExtensionProps = getMaskExtensionProps;
+exports.negateAccessor = negateAccessor;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _baseLayer = require("../layers/base-layer");
+
+var _defaultSettings = require("../constants/default-settings");
+
+var _extensions = require("@deck.gl/extensions");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * Find default layers from fields
+ * @type {typeof import('./layer-utils').findDefaultLayer}
+ */
+function findDefaultLayer(dataset, layerClasses) {
+  if (!dataset) {
+    return [];
+  }
+
+  var layerProps = Object.keys(layerClasses).reduce(function (previous, lc) {
+    var result = typeof layerClasses[lc].findDefaultLayerProps === 'function' ? layerClasses[lc].findDefaultLayerProps(dataset, previous) : {
+      props: []
+    };
+    var props = Array.isArray(result) ? result : result.props || [];
+    var foundLayers = result.foundLayers || previous;
+    return foundLayers.concat(props.map(function (p) {
+      return _objectSpread(_objectSpread({}, p), {}, {
+        type: lc,
+        dataId: dataset.id
+      });
+    }));
+  }, []); // go through all layerProps to create layer
+
+  return layerProps.map(function (props) {
+    var layer = new layerClasses[props.type](props);
+    return typeof layer.setInitialLayerConfig === 'function' && dataset.dataContainer ? layer.setInitialLayerConfig(dataset) : layer;
+  });
+}
+/**
+ * calculate layer data based on layer type, col Config,
+ * return updated layer if colorDomain, dataMap has changed
+ * @type {typeof import('./layer-utils').calculateLayerData}
+ */
+
+
+function calculateLayerData(layer, state, oldLayerData) {
+  var type = layer.type;
+
+  if (!type || !layer.hasAllColumns() || !layer.config.dataId) {
+    return {
+      layer: layer,
+      layerData: {}
+    };
+  }
+
+  var layerData = layer.formatLayerData(state.datasets, oldLayerData);
+  return {
+    layerData: layerData,
+    layer: layer
+  };
+}
+/**
+ * Calculate props passed to LayerHoverInfo
+ * @type {typeof import('./layer-utils').getLayerHoverProp}
+ */
+
+
+function getLayerHoverProp(_ref) {
+  var interactionConfig = _ref.interactionConfig,
+      hoverInfo = _ref.hoverInfo,
+      layers = _ref.layers,
+      layersToRender = _ref.layersToRender,
+      datasets = _ref.datasets;
+
+  if (interactionConfig.tooltip.enabled && hoverInfo && hoverInfo.picked) {
+    // if anything hovered
+    var object = hoverInfo.object,
+        overlay = hoverInfo.layer; // deckgl layer to kepler-gl layer
+
+    var layer = layers[overlay.props.idx];
+
+    if (object && layer && layer.getHoverData && layersToRender[layer.id]) {
+      // if layer is visible and have hovered data
+      var dataId = layer.config.dataId;
+
+      if (!dataId) {
+        return null;
+      }
+
+      var _datasets$dataId = datasets[dataId],
+          dataContainer = _datasets$dataId.dataContainer,
+          fields = _datasets$dataId.fields;
+      var data = layer.getHoverData(object, dataContainer, fields);
+      var fieldsToShow = interactionConfig.tooltip.config.fieldsToShow[dataId];
+      return {
+        data: data,
+        fields: fields,
+        fieldsToShow: fieldsToShow,
+        layer: layer
+      };
+    }
+  }
+
+  return null;
+}
+
+function renderDeckGlLayer(props, layerCallbacks, idx) {
+  var datasets = props.datasets,
+      layers = props.layers,
+      layerData = props.layerData,
+      hoverInfo = props.hoverInfo,
+      clicked = props.clicked,
+      mapState = props.mapState,
+      interactionConfig = props.interactionConfig,
+      animationConfig = props.animationConfig,
+      mapLayers = props.mapLayers,
+      maskPolygon = props.maskPolygon,
+      popupSettings = props.popupSettings;
+  var layer = layers[idx];
+  var data = layerData[idx];
+
+  var _ref2 = datasets[layer.config.dataId] || {},
+      gpuFilter = _ref2.gpuFilter;
+
+  var objectHovered = clicked || hoverInfo;
+  var visible = !mapLayers || mapLayers && mapLayers[layer.id];
+  layer.interactivitySettings = popupSettings === null || popupSettings === void 0 ? void 0 : popupSettings.layers[layer.id]; // Layer is Layer class
+
+  return layer.renderLayer({
+    data: data,
+    gpuFilter: gpuFilter,
+    idx: idx,
+    interactionConfig: interactionConfig,
+    layerCallbacks: layerCallbacks,
+    mapState: mapState,
+    animationConfig: animationConfig,
+    objectHovered: objectHovered,
+    visible: visible,
+    maskPolygon: maskPolygon,
+    popupSettings: popupSettings
+  });
+}
+
+function isLayerRenderable(layer, layerData) {
+  return layer.id !== _defaultSettings.GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData);
+}
+
+function isLayerVisible(layer, mapLayers) {
+  return layer.config.isVisible && ( // if layer.id is not in mapLayers, don't render it
+  !mapLayers || mapLayers && mapLayers[layer.id]);
+} // Prepare a dict of layers rendered by the deck.gl
+// Note, isVisible: false layer is passed to deck.gl here
+// return {[id]: true \ false}
+
+
+function prepareLayersForDeck(layers, layerData) {
+  return layers.reduce(function (accu, layer, idx) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.id, isLayerRenderable(layer, layerData[idx]) && layer.overlayType === _baseLayer.OVERLAY_TYPE.deckgl));
+  }, {});
+} // Prepare a dict of rendered layers rendered in the map
+// This includes only the visibile layers for single map view and split map view
+// return {[id]: true \ false}
+
+
+function prepareLayersToRender(layers, layerData, mapLayers) {
+  return layers.reduce(function (accu, layer, idx) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.id, isLayerRenderable(layer, layerData[idx]) && isLayerVisible(layer, mapLayers)));
+  }, {});
+}
+
+var maskExtension = new _extensions.MaskExtension();
+
+function getMaskExtensionProps(maskPolygon) {
+  return {
+    maskId: Boolean(maskPolygon && maskPolygon.length) && _defaultSettings.MASK_LAYER_ID,
+    extensions: [maskExtension]
+  };
+}
+
+function negateAccessor(accessor) {
+  return typeof accessor === 'function' ? function (d, i) {
+    return -accessor(d, i);
+  } : -accessor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/layer-utils.js"],"names":["findDefaultLayer","dataset","layerClasses","layerProps","Object","keys","reduce","previous","lc","result","findDefaultLayerProps","props","Array","isArray","foundLayers","concat","map","p","type","dataId","id","layer","setInitialLayerConfig","dataContainer","calculateLayerData","state","oldLayerData","hasAllColumns","config","layerData","formatLayerData","datasets","getLayerHoverProp","interactionConfig","hoverInfo","layers","layersToRender","tooltip","enabled","picked","object","overlay","idx","getHoverData","fields","data","fieldsToShow","renderDeckGlLayer","layerCallbacks","clicked","mapState","animationConfig","mapLayers","maskPolygon","popupSettings","gpuFilter","objectHovered","visible","interactivitySettings","renderLayer","isLayerRenderable","GEOCODER_LAYER_ID","shouldRenderLayer","isLayerVisible","isVisible","prepareLayersForDeck","accu","overlayType","OVERLAY_TYPE","deckgl","prepareLayersToRender","maskExtension","MaskExtension","getMaskExtensionProps","maskId","Boolean","length","MASK_LAYER_ID","extensions","negateAccessor","accessor","d","i"],"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 {OVERLAY_TYPE} from 'layers/base-layer';\nimport {GEOCODER_LAYER_ID, MASK_LAYER_ID} from 'constants/default-settings';\nimport {MaskExtension} from '@deck.gl/extensions';\n\n/**\n * Find default layers from fields\n * @type {typeof import('./layer-utils').findDefaultLayer}\n */\nexport function findDefaultLayer(dataset, layerClasses) {\n  if (!dataset) {\n    return [];\n  }\n  const layerProps = Object.keys(layerClasses).reduce((previous, lc) => {\n    const result =\n      typeof layerClasses[lc].findDefaultLayerProps === 'function'\n        ? layerClasses[lc].findDefaultLayerProps(dataset, previous)\n        : {props: []};\n\n    const props = Array.isArray(result) ? result : result.props || [];\n    const foundLayers = result.foundLayers || previous;\n\n    return foundLayers.concat(\n      props.map(p => ({\n        ...p,\n        type: lc,\n        dataId: dataset.id\n      }))\n    );\n  }, []);\n\n  // go through all layerProps to create layer\n  return layerProps.map(props => {\n    const layer = new layerClasses[props.type](props);\n    return typeof layer.setInitialLayerConfig === 'function' && dataset.dataContainer\n      ? layer.setInitialLayerConfig(dataset)\n      : layer;\n  });\n}\n\n/**\n * calculate layer data based on layer type, col Config,\n * return updated layer if colorDomain, dataMap has changed\n * @type {typeof import('./layer-utils').calculateLayerData}\n */\nexport function calculateLayerData(layer, state, oldLayerData) {\n  const {type} = layer;\n\n  if (!type || !layer.hasAllColumns() || !layer.config.dataId) {\n    return {layer, layerData: {}};\n  }\n\n  const layerData = layer.formatLayerData(state.datasets, oldLayerData);\n  return {layerData, layer};\n}\n\n/**\n * Calculate props passed to LayerHoverInfo\n * @type {typeof import('./layer-utils').getLayerHoverProp}\n */\nexport function getLayerHoverProp({\n  interactionConfig,\n  hoverInfo,\n  layers,\n  layersToRender,\n  datasets\n}) {\n  if (interactionConfig.tooltip.enabled && hoverInfo && hoverInfo.picked) {\n    // if anything hovered\n    const {object, layer: overlay} = hoverInfo;\n\n    // deckgl layer to kepler-gl layer\n    const layer = layers[overlay.props.idx];\n\n    if (object && layer && layer.getHoverData && layersToRender[layer.id]) {\n      // if layer is visible and have hovered data\n      const {\n        config: {dataId}\n      } = layer;\n      if (!dataId) {\n        return null;\n      }\n      const {dataContainer, fields} = datasets[dataId];\n      const data = layer.getHoverData(object, dataContainer, fields);\n      const fieldsToShow = interactionConfig.tooltip.config.fieldsToShow[dataId];\n\n      return {\n        data,\n        fields,\n        fieldsToShow,\n        layer\n      };\n    }\n  }\n\n  return null;\n}\n\nexport function renderDeckGlLayer(props, layerCallbacks, idx) {\n  const {\n    datasets,\n    layers,\n    layerData,\n    hoverInfo,\n    clicked,\n    mapState,\n    interactionConfig,\n    animationConfig,\n    mapLayers,\n    maskPolygon,\n    popupSettings\n  } = props;\n  const layer = layers[idx];\n  const data = layerData[idx];\n  const {gpuFilter} = datasets[layer.config.dataId] || {};\n  const objectHovered = clicked || hoverInfo;\n  const visible = !mapLayers || (mapLayers && mapLayers[layer.id]);\n\n  layer.interactivitySettings = popupSettings?.layers[layer.id];\n  // Layer is Layer class\n  return layer.renderLayer({\n    data,\n    gpuFilter,\n    idx,\n    interactionConfig,\n    layerCallbacks,\n    mapState,\n    animationConfig,\n    objectHovered,\n    visible,\n    maskPolygon,\n    popupSettings\n  });\n}\n\nexport function isLayerRenderable(layer, layerData) {\n  return layer.id !== GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData);\n}\n\nexport function isLayerVisible(layer, mapLayers) {\n  return (\n    layer.config.isVisible &&\n    // if layer.id is not in mapLayers, don't render it\n    (!mapLayers || (mapLayers && mapLayers[layer.id]))\n  );\n}\n\n// Prepare a dict of layers rendered by the deck.gl\n// Note, isVisible: false layer is passed to deck.gl here\n// return {[id]: true \\ false}\nexport function prepareLayersForDeck(layers, layerData) {\n  return layers.reduce(\n    (accu, layer, idx) => ({\n      ...accu,\n      [layer.id]:\n        isLayerRenderable(layer, layerData[idx]) && layer.overlayType === OVERLAY_TYPE.deckgl\n    }),\n    {}\n  );\n}\n\n// Prepare a dict of rendered layers rendered in the map\n// This includes only the visibile layers for single map view and split map view\n// return {[id]: true \\ false}\nexport function prepareLayersToRender(layers, layerData, mapLayers) {\n  return layers.reduce(\n    (accu, layer, idx) => ({\n      ...accu,\n      [layer.id]: isLayerRenderable(layer, layerData[idx]) && isLayerVisible(layer, mapLayers)\n    }),\n    {}\n  );\n}\n\nconst maskExtension = new MaskExtension();\n\nexport function getMaskExtensionProps(maskPolygon) {\n  return {\n    maskId: Boolean(maskPolygon && maskPolygon.length) && MASK_LAYER_ID,\n    extensions: [maskExtension]\n  };\n}\n\nexport function negateAccessor(accessor) {\n  return typeof accessor === 'function' ? (d, i) => -accessor(d, i) : -accessor;\n}\n"]}

package/dist/utils/locale-utils.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeMessages = exports.flattenMessages = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _utils = require("./utils");
+
+var _console = require("global/console");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+// Flat messages since react-intl does not seem to support nested structures
+// Adapted from https://medium.com/siren-apparel-press/internationalization-and-localization-of-sirenapparel-eu-sirenapparel-us-and-sirenapparel-asia-ddee266066a2
+var flattenMessages = function flattenMessages(nestedMessages) {
+  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return Object.keys(nestedMessages).reduce(function (messages, key) {
+    var value = nestedMessages[key];
+    var prefixedKey = prefix ? "".concat(prefix, ".").concat(key) : key;
+
+    if (typeof value === 'string') {
+      messages[prefixedKey] = value;
+    } else {
+      Object.assign(messages, flattenMessages(value, prefixedKey));
+    }
+
+    return messages;
+  }, {});
+};
+
+exports.flattenMessages = flattenMessages;
+
+var mergeMessages = function mergeMessages(defaultMessages, userMessages) {
+  if (!(0, _utils.isObject)(userMessages) || !(0, _utils.isObject)(userMessages.en)) {
+    _console.console.error('message should be an object and contain at least the `en` translation. Read more at https://docs.kepler.gl/docs/api-reference/localization');
+
+    return defaultMessages;
+  }
+
+  var userEnFlat = flattenMessages(userMessages.en);
+  return Object.keys(defaultMessages).reduce(function (acc, key) {
+    return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, key, key === 'en' ? _objectSpread(_objectSpread({}, defaultMessages.en), userEnFlat) : _objectSpread(_objectSpread(_objectSpread({}, defaultMessages[key]), userEnFlat), flattenMessages(userMessages[key] || {}))));
+  }, {});
+};
+
+exports.mergeMessages = mergeMessages;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/map-info-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidMapInfo = isValidMapInfo;
+
+var _defaultSettings = require("../constants/default-settings");
+
+// 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.
+function isValidMapInfo(mapInfo) {
+  return mapInfo.title.length && mapInfo.title.length <= _defaultSettings.MAP_INFO_CHARACTER.title && (!mapInfo.description.length || mapInfo.description.length <= _defaultSettings.MAP_INFO_CHARACTER.description);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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