@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/esm/map/layer-hover-info.js

@@ -0,0 +1,312 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["fieldsToShow"];
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useEffect, useRef, useMemo } from 'react';
+import styled from 'styled-components';
+import truncate from 'es-toolkit/compat/truncate';
+import { CenterFlexbox } from '../common/styled-components';
+import { Layers } from '../common/icons';
+import PropTypes from 'prop-types';
+import { notNullorUndefined } from '@kepler.gl/common-utils';
+import { DataRow } from '@kepler.gl/utils';
+import { getTooltipDisplayDeltaValue, getTooltipDisplayValue } from '@kepler.gl/reducers';
+import { useIntl } from 'react-intl';
+import { capitalizeFirstLetter } from '@kepler.gl/utils';
+export var StyledLayerName = styled(CenterFlexbox)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  color: ", ";\n  font-size: 12px;\n  letter-spacing: 0.43px;\n  text-transform: capitalize;\n\n  svg {\n    margin-right: 4px;\n  }\n"])), function (props) {
+  return props.theme.textColorHl;
+});
+var StyledTable = styled.table(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  & .row__delta-value {\n    text-align: right;\n    margin-left: 6px;\n\n    &.positive {\n      color: ", ";\n    }\n\n    &.negative {\n      color: ", ";\n    }\n  }\n  & .row__name {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n  & .row__value {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: pre-line;\n    max-width: 250px;\n  }\n"])), function (props) {
+  return props.theme.notificationColors.success;
+}, function (props) {
+  return props.theme.negativeBtnActBgd;
+});
+var StyledDivider = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  // offset divider to reach popover edge\n  margin-left: -14px;\n  margin-right: -14px;\n  border-bottom: 1px solid ", ";\n"])), function (props) {
+  return props.theme.panelBorderColor;
+});
+var TOOLTIP_VALUE_MAX_LENGTH = 256;
+
+/**
+ * Image component that cleans up resources on unmount to prevent memory leaks.
+ * Revokes blob/object URLs and clears the image src to release memory.
+ */
+var TooltipImage = function TooltipImage(_ref) {
+  var src = _ref.src;
+  var imgRef = useRef(null);
+  useEffect(function () {
+    return function () {
+      // Revoke blob URLs to free memory
+      if (src && (src.startsWith('blob:') || src.startsWith('data:'))) {
+        try {
+          URL.revokeObjectURL(src);
+        } catch (e) {
+          // ignore errors from non-object URLs
+        }
+      }
+      // Clear the image src to release the decoded image from memory
+      if (imgRef.current) {
+        imgRef.current.src = '';
+      }
+    };
+  }, [src]);
+  return /*#__PURE__*/React.createElement("img", {
+    ref: imgRef,
+    src: src
+  });
+};
+var Row = function Row(_ref2) {
+  var name = _ref2.name,
+    value = _ref2.value,
+    deltaValue = _ref2.deltaValue,
+    url = _ref2.url,
+    isComparing = _ref2.isComparing;
+  // Set 'url' to 'value' if it looks like a url
+  if (!url && value && typeof value === 'string' && value.match(/^http/)) {
+    url = value;
+  }
+  var displayValue = typeof value === 'string' && value.length > TOOLTIP_VALUE_MAX_LENGTH ? truncate(value, {
+    length: TOOLTIP_VALUE_MAX_LENGTH
+  }) : value;
+  var asImg = /<img>/.test(name);
+  return /*#__PURE__*/React.createElement("tr", {
+    className: "layer-hover-info__row",
+    key: name
+  }, /*#__PURE__*/React.createElement("td", {
+    className: "row__name"
+  }, asImg ? name.replace('<img>', '') : name), /*#__PURE__*/React.createElement("td", {
+    className: "row__value"
+  }, asImg ? /*#__PURE__*/React.createElement(TooltipImage, {
+    src: value
+  }) : url ? /*#__PURE__*/React.createElement("a", {
+    target: "_blank",
+    rel: "noopener noreferrer",
+    href: url
+  }, displayValue) : /*#__PURE__*/React.createElement("span", null, displayValue)), isComparing ? /*#__PURE__*/React.createElement("td", {
+    className: "row__delta-value ".concat(notNullorUndefined(deltaValue) ? (deltaValue === null || deltaValue === void 0 ? void 0 : deltaValue.toString().charAt(0)) === '+' ? 'positive' : 'negative' : '')
+  }, deltaValue !== null && deltaValue !== void 0 ? deltaValue : '') : null);
+};
+var EntryInfo = function EntryInfo(_ref3) {
+  var fieldsToShow = _ref3.fieldsToShow,
+    props = _objectWithoutProperties(_ref3, _excluded);
+  return /*#__PURE__*/React.createElement("tbody", null, fieldsToShow.map(function (item) {
+    return /*#__PURE__*/React.createElement(EntryInfoRow, _extends({
+      key: item.name,
+      item: item
+    }, props));
+  }));
+};
+var EntryInfoRow = function EntryInfoRow(_ref4) {
+  var layer = _ref4.layer,
+    item = _ref4.item,
+    fields = _ref4.fields,
+    data = _ref4.data,
+    primaryData = _ref4.primaryData,
+    compareType = _ref4.compareType,
+    currentTime = _ref4.currentTime;
+  var fieldIdx = fields.findIndex(function (f) {
+    return f.name === item.name;
+  });
+  if (fieldIdx < 0) {
+    return null;
+  }
+  var field = fields[fieldIdx];
+  var fieldValueAccessor = layer.accessVSFieldValue(field, currentTime);
+  var value = fieldValueAccessor(field, data instanceof DataRow ? {
+    index: data._rowIndex
+  } : data);
+  var primaryValue = null;
+  var displayDeltaValue = null;
+  if (primaryData) {
+    try {
+      if (primaryData instanceof DataRow) {
+        primaryValue = fieldValueAccessor(field, {
+          index: primaryData._rowIndex
+        });
+      } else if (Array.isArray(primaryData) || _typeof(primaryData) === 'object' && primaryData) {
+        primaryValue = fieldValueAccessor(field, primaryData);
+      }
+      displayDeltaValue = getTooltipDisplayDeltaValue({
+        field: field,
+        value: value,
+        primaryValue: primaryValue,
+        compareType: compareType
+      });
+    } catch (error) {
+      primaryValue = null;
+    }
+  }
+  var displayValue = getTooltipDisplayValue({
+    item: item,
+    field: field,
+    value: value
+  });
+  return /*#__PURE__*/React.createElement(Row, {
+    name: field.displayName || field.name,
+    value: displayValue,
+    deltaValue: displayDeltaValue,
+    isComparing: Boolean(primaryData)
+  });
+};
+var CellInfo = function CellInfo(_ref5) {
+  var fieldsToShow = _ref5.fieldsToShow,
+    data = _ref5.data,
+    layer = _ref5.layer,
+    primaryData = _ref5.primaryData,
+    compareType = _ref5.compareType;
+  var _ref6 = layer.config,
+    colorField = _ref6.colorField,
+    sizeField = _ref6.sizeField;
+  var isComparing = Boolean(primaryData);
+  var colorValue = useMemo(function () {
+    if (colorField && layer.visualChannels.color) {
+      var item = fieldsToShow.find(function (field) {
+        return field.name === colorField.name;
+      });
+      return getTooltipDisplayValue({
+        item: item,
+        field: colorField,
+        value: data.colorValue
+      });
+    }
+    return null;
+  }, [fieldsToShow, colorField, layer, data.colorValue]);
+  var elevationValue = useMemo(function () {
+    if (sizeField && layer.visualChannels.size) {
+      var item = fieldsToShow.find(function (field) {
+        return field.name === sizeField.name;
+      });
+      return getTooltipDisplayValue({
+        item: item,
+        field: sizeField,
+        value: data.elevationValue
+      });
+    }
+    return null;
+  }, [fieldsToShow, sizeField, layer, data.elevationValue]);
+  var colorDelta = useMemo(function () {
+    if (!primaryData || !colorField || !('colorValue' in primaryData)) return null;
+    return getTooltipDisplayDeltaValue({
+      field: colorField,
+      value: data.colorValue,
+      primaryValue: primaryData.colorValue,
+      compareType: compareType
+    });
+  }, [primaryData, colorField, data.colorValue, compareType]);
+  var elevationDelta = useMemo(function () {
+    if (!primaryData || !sizeField || !('elevationValue' in primaryData)) return null;
+    return getTooltipDisplayDeltaValue({
+      field: sizeField,
+      value: data.elevationValue,
+      primaryValue: primaryData.elevationValue,
+      compareType: compareType
+    });
+  }, [primaryData, sizeField, data.elevationValue, compareType]);
+  var aggregatedData = useMemo(function () {
+    if (data.aggregatedData && fieldsToShow) {
+      return fieldsToShow.reduce(function (acc, field) {
+        var _data$aggregatedData;
+        var dataForField = (_data$aggregatedData = data.aggregatedData) === null || _data$aggregatedData === void 0 ? void 0 : _data$aggregatedData[field.name];
+        if (dataForField !== null && dataForField !== void 0 && dataForField.measure && field.name !== (colorField === null || colorField === void 0 ? void 0 : colorField.name)) {
+          var _primaryData$aggregat;
+          var primaryDataForField = primaryData === null || primaryData === void 0 || (_primaryData$aggregat = primaryData.aggregatedData) === null || _primaryData$aggregat === void 0 ? void 0 : _primaryData$aggregat[field.name];
+          var deltaValue = primaryDataForField ? getTooltipDisplayDeltaValue({
+            field: {
+              type: 'real',
+              name: field.name
+            },
+            value: dataForField.value != null ? Number(dataForField.value) : null,
+            primaryValue: primaryDataForField.value != null ? Number(primaryDataForField.value) : null,
+            compareType: compareType
+          }) : null;
+          acc.push({
+            name: "".concat(capitalizeFirstLetter(dataForField.measure), " of ").concat(field.name),
+            value: dataForField.value,
+            deltaValue: deltaValue
+          });
+        }
+        return acc;
+      }, []);
+    }
+    return [];
+  }, [data.aggregatedData, fieldsToShow, colorField === null || colorField === void 0 ? void 0 : colorField.name, primaryData, compareType]);
+  var colorMeasure = layer.getVisualChannelDescription('color').measure;
+  var sizeMeasure = layer.getVisualChannelDescription('size').measure;
+  return /*#__PURE__*/React.createElement("tbody", null, /*#__PURE__*/React.createElement(Row, {
+    name: 'total points',
+    key: "count",
+    value: String(data.points && data.points.length),
+    isComparing: isComparing
+  }), colorField && layer.visualChannels.color && colorMeasure ? /*#__PURE__*/React.createElement(Row, {
+    name: colorMeasure,
+    key: "color",
+    value: colorValue || 'N/A',
+    deltaValue: colorDelta,
+    isComparing: isComparing
+  }) : null, sizeField && layer.visualChannels.size && sizeMeasure ? /*#__PURE__*/React.createElement(Row, {
+    name: sizeMeasure,
+    key: "size",
+    value: elevationValue || 'N/A',
+    deltaValue: elevationDelta,
+    isComparing: isComparing
+  }) : null, aggregatedData.map(function (dataForField, idx) {
+    return /*#__PURE__*/React.createElement(Row, {
+      name: dataForField.name,
+      key: "data_".concat(idx),
+      value: dataForField.value != null ? String(dataForField.value) : 'N/A',
+      deltaValue: dataForField.deltaValue,
+      isComparing: isComparing
+    });
+  }));
+};
+var LayerHoverInfoFactory = function LayerHoverInfoFactory() {
+  var LayerHoverInfo = function LayerHoverInfo(props) {
+    var data = props.data,
+      layer = props.layer;
+    var intl = useIntl();
+    if (!data || !layer) {
+      return null;
+    }
+    var hasFieldsToShow = data.fieldValues && Object.keys(data.fieldValues).length > 0 || data.wmsFeatureData && data.wmsFeatureData.length > 0 || props.fieldsToShow && props.fieldsToShow.length > 0;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "map-popover__layer-info"
+    }, /*#__PURE__*/React.createElement(StyledLayerName, {
+      className: "map-popover__layer-name"
+    }, /*#__PURE__*/React.createElement(Layers, {
+      height: "12px"
+    }), props.layer.config.label), hasFieldsToShow && /*#__PURE__*/React.createElement(StyledDivider, null), /*#__PURE__*/React.createElement(StyledTable, {
+      className: props.primaryData ? 'comparing' : undefined
+    }, data.wmsFeatureData ? /*#__PURE__*/React.createElement("tbody", null, data.wmsFeatureData.map(function (_ref7, i) {
+      var name = _ref7.name,
+        value = _ref7.value;
+      return /*#__PURE__*/React.createElement(Row, {
+        key: i,
+        name: name,
+        value: value
+      });
+    })) : data.fieldValues ? /*#__PURE__*/React.createElement("tbody", null, data.fieldValues.map(function (_ref8, i) {
+      var labelMessage = _ref8.labelMessage,
+        value = _ref8.value;
+      return /*#__PURE__*/React.createElement(Row, {
+        key: i,
+        name: intl.formatMessage({
+          id: labelMessage
+        }),
+        value: value
+      });
+    })) : props.layer.isAggregated ? /*#__PURE__*/React.createElement(CellInfo, props) : /*#__PURE__*/React.createElement(EntryInfo, props)), hasFieldsToShow && /*#__PURE__*/React.createElement(StyledDivider, null));
+  };
+  LayerHoverInfo.propTypes = {
+    fields: PropTypes.arrayOf(PropTypes.any),
+    fieldsToShow: PropTypes.arrayOf(PropTypes.any),
+    layer: PropTypes.object,
+    data: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.any), PropTypes.object])
+  };
+  return LayerHoverInfo;
+};
+export default LayerHoverInfoFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useMemo","styled","truncate","CenterFlexbox","Layers","PropTypes","notNullorUndefined","DataRow","getTooltipDisplayDeltaValue","getTooltipDisplayValue","useIntl","capitalizeFirstLetter","StyledLayerName","_templateObject","_taggedTemplateLiteral","props","theme","textColorHl","StyledTable","table","_templateObject2","notificationColors","success","negativeBtnActBgd","StyledDivider","div","_templateObject3","panelBorderColor","TOOLTIP_VALUE_MAX_LENGTH","TooltipImage","_ref","src","imgRef","startsWith","URL","revokeObjectURL","e","current","createElement","ref","Row","_ref2","name","value","deltaValue","url","isComparing","match","displayValue","length","asImg","test","className","key","replace","target","rel","href","concat","toString","charAt","EntryInfo","_ref3","fieldsToShow","_objectWithoutProperties","_excluded","map","item","EntryInfoRow","_extends","_ref4","layer","fields","data","primaryData","compareType","currentTime","fieldIdx","findIndex","f","field","fieldValueAccessor","accessVSFieldValue","index","_rowIndex","primaryValue","displayDeltaValue","Array","isArray","_typeof","error","displayName","Boolean","CellInfo","_ref5","_ref6","config","colorField","sizeField","colorValue","visualChannels","color","find","elevationValue","size","colorDelta","elevationDelta","aggregatedData","reduce","acc","_data$aggregatedData","dataForField","measure","_primaryData$aggregat","primaryDataForField","type","Number","push","colorMeasure","getVisualChannelDescription","sizeMeasure","String","points","idx","LayerHoverInfoFactory","LayerHoverInfo","intl","hasFieldsToShow","fieldValues","Object","keys","wmsFeatureData","height","label","undefined","_ref7","i","_ref8","labelMessage","formatMessage","id","isAggregated","propTypes","arrayOf","any","object","oneOfType"],"sources":["../../../src/map/layer-hover-info.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useEffect, useRef, useMemo} from 'react';\nimport styled from 'styled-components';\nimport truncate from 'es-toolkit/compat/truncate';\nimport {CompareType, Field, Merge, TooltipField} from '@kepler.gl/types';\nimport {CenterFlexbox} from '../common/styled-components';\nimport {Layers} from '../common/icons';\nimport PropTypes from 'prop-types';\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\nimport {DataRow} from '@kepler.gl/utils';\nimport {Layer} from '@kepler.gl/layers';\nimport {\n  AggregationLayerHoverData,\n  LayerHoverProp,\n  getTooltipDisplayDeltaValue,\n  getTooltipDisplayValue\n} from '@kepler.gl/reducers';\nimport {useIntl} from 'react-intl';\nimport {VisState} from '@kepler.gl/schemas';\nimport {capitalizeFirstLetter} from '@kepler.gl/utils';\n\nexport const StyledLayerName = styled(CenterFlexbox)`\n  color: ${props => props.theme.textColorHl};\n  font-size: 12px;\n  letter-spacing: 0.43px;\n  text-transform: capitalize;\n\n  svg {\n    margin-right: 4px;\n  }\n`;\n\nconst StyledTable = styled.table`\n  & .row__delta-value {\n    text-align: right;\n    margin-left: 6px;\n\n    &.positive {\n      color: ${props => props.theme.notificationColors.success};\n    }\n\n    &.negative {\n      color: ${props => props.theme.negativeBtnActBgd};\n    }\n  }\n  & .row__name {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n  & .row__value {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: pre-line;\n    max-width: 250px;\n  }\n`;\n\nconst StyledDivider = styled.div`\n  // offset divider to reach popover edge\n  margin-left: -14px;\n  margin-right: -14px;\n  border-bottom: 1px solid ${props => props.theme.panelBorderColor};\n`;\n\ninterface RowProps {\n  name: string;\n  value: string;\n  deltaValue?: string | null;\n  url?: string;\n  isComparing?: boolean;\n}\n\nconst TOOLTIP_VALUE_MAX_LENGTH = 256;\n\n/**\n * Image component that cleans up resources on unmount to prevent memory leaks.\n * Revokes blob/object URLs and clears the image src to release memory.\n */\nconst TooltipImage: React.FC<{src: string}> = ({src}) => {\n  const imgRef = useRef<HTMLImageElement>(null);\n\n  useEffect(() => {\n    return () => {\n      // Revoke blob URLs to free memory\n      if (src && (src.startsWith('blob:') || src.startsWith('data:'))) {\n        try {\n          URL.revokeObjectURL(src);\n        } catch (e) {\n          // ignore errors from non-object URLs\n        }\n      }\n      // Clear the image src to release the decoded image from memory\n      if (imgRef.current) {\n        imgRef.current.src = '';\n      }\n    };\n  }, [src]);\n\n  return <img ref={imgRef} src={src} />;\n};\n\nconst Row: React.FC<RowProps> = ({name, value, deltaValue, url, isComparing}) => {\n  // Set 'url' to 'value' if it looks like a url\n  if (!url && value && typeof value === 'string' && value.match(/^http/)) {\n    url = value;\n  }\n\n  const displayValue =\n    typeof value === 'string' && value.length > TOOLTIP_VALUE_MAX_LENGTH\n      ? truncate(value, {length: TOOLTIP_VALUE_MAX_LENGTH})\n      : value;\n\n  const asImg = /<img>/.test(name);\n  return (\n    <tr className=\"layer-hover-info__row\" key={name}>\n      <td className=\"row__name\">{asImg ? name.replace('<img>', '') : name}</td>\n      <td className=\"row__value\">\n        {asImg ? (\n          <TooltipImage src={value} />\n        ) : url ? (\n          <a target=\"_blank\" rel=\"noopener noreferrer\" href={url}>\n            {displayValue}\n          </a>\n        ) : (\n          <span>{displayValue}</span>\n        )}\n      </td>\n      {isComparing ? (\n        <td\n          className={`row__delta-value ${\n            notNullorUndefined(deltaValue)\n              ? deltaValue?.toString().charAt(0) === '+'\n                ? 'positive'\n                : 'negative'\n              : ''\n          }`}\n        >\n          {deltaValue ?? ''}\n        </td>\n      ) : null}\n    </tr>\n  );\n};\n\nexport type EntryInfoProps = Merge<LayerHoverProp, {fieldsToShow: TooltipField[]}>;\n\nconst EntryInfo: React.FC<EntryInfoProps> = ({fieldsToShow, ...props}) => (\n  <tbody>\n    {fieldsToShow.map(item => (\n      <EntryInfoRow key={item.name} item={item} {...props} />\n    ))}\n  </tbody>\n);\n\nexport type EntryInfoRowProps = {\n  data: LayerHoverProp['data'];\n  fields: Field[];\n  layer: Layer;\n  primaryData?: LayerHoverProp['primaryData'];\n  compareType?: CompareType;\n  currentTime?: VisState['animationConfig']['currentTime'];\n  item: TooltipField;\n};\n\nconst EntryInfoRow: React.FC<EntryInfoRowProps> = ({\n  layer,\n  item,\n  fields,\n  data,\n  primaryData,\n  compareType,\n  currentTime\n}) => {\n  const fieldIdx = fields.findIndex(f => f.name === item.name);\n  if (fieldIdx < 0) {\n    return null;\n  }\n  const field = fields[fieldIdx];\n  const fieldValueAccessor = layer.accessVSFieldValue(field, currentTime);\n  const value = fieldValueAccessor(field, data instanceof DataRow ? {index: data._rowIndex} : data);\n\n  let primaryValue = null;\n  let displayDeltaValue: string | null = null;\n\n  if (primaryData) {\n    try {\n      if (primaryData instanceof DataRow) {\n        primaryValue = fieldValueAccessor(field, {index: primaryData._rowIndex});\n      } else if (Array.isArray(primaryData) || (typeof primaryData === 'object' && primaryData)) {\n        primaryValue = fieldValueAccessor(field, primaryData);\n      }\n\n      displayDeltaValue = getTooltipDisplayDeltaValue({\n        field,\n        value,\n        primaryValue,\n        compareType\n      });\n    } catch (error) {\n      primaryValue = null;\n    }\n  }\n\n  const displayValue = getTooltipDisplayValue({item, field, value});\n\n  return (\n    <Row\n      name={field.displayName || field.name}\n      value={displayValue}\n      deltaValue={displayDeltaValue}\n      isComparing={Boolean(primaryData)}\n    />\n  );\n};\n\nconst CellInfo = ({\n  fieldsToShow,\n  data,\n  layer,\n  primaryData,\n  compareType\n}: {\n  data: AggregationLayerHoverData;\n  fieldsToShow: TooltipField[];\n  layer: Layer;\n  primaryData?: AggregationLayerHoverData | null;\n  compareType?: CompareType;\n}) => {\n  const {colorField, sizeField} = layer.config as any;\n  const isComparing = Boolean(primaryData);\n\n  const colorValue = useMemo(() => {\n    if (colorField && layer.visualChannels.color) {\n      const item = fieldsToShow.find(field => field.name === colorField.name);\n      return getTooltipDisplayValue({item, field: colorField, value: data.colorValue});\n    }\n    return null;\n  }, [fieldsToShow, colorField, layer, data.colorValue]);\n\n  const elevationValue = useMemo(() => {\n    if (sizeField && layer.visualChannels.size) {\n      const item = fieldsToShow.find(field => field.name === sizeField.name);\n      return getTooltipDisplayValue({item, field: sizeField, value: data.elevationValue});\n    }\n    return null;\n  }, [fieldsToShow, sizeField, layer, data.elevationValue]);\n\n  const colorDelta = useMemo(() => {\n    if (!primaryData || !colorField || !('colorValue' in primaryData)) return null;\n    return getTooltipDisplayDeltaValue({\n      field: colorField,\n      value: data.colorValue,\n      primaryValue: primaryData.colorValue,\n      compareType\n    });\n  }, [primaryData, colorField, data.colorValue, compareType]);\n\n  const elevationDelta = useMemo(() => {\n    if (!primaryData || !sizeField || !('elevationValue' in primaryData)) return null;\n    return getTooltipDisplayDeltaValue({\n      field: sizeField,\n      value: data.elevationValue,\n      primaryValue: primaryData.elevationValue,\n      compareType\n    });\n  }, [primaryData, sizeField, data.elevationValue, compareType]);\n\n  const aggregatedData = useMemo(() => {\n    if (data.aggregatedData && fieldsToShow) {\n      return fieldsToShow.reduce(\n        (acc, field) => {\n          const dataForField = data.aggregatedData?.[field.name];\n          if (dataForField?.measure && field.name !== colorField?.name) {\n            const primaryDataForField = primaryData?.aggregatedData?.[field.name];\n            const deltaValue = primaryDataForField\n              ? getTooltipDisplayDeltaValue({\n                  field: {type: 'real', name: field.name} as Field,\n                  value: dataForField.value != null ? Number(dataForField.value) : null,\n                  primaryValue:\n                    primaryDataForField.value != null ? Number(primaryDataForField.value) : null,\n                  compareType\n                })\n              : null;\n            acc.push({\n              name: `${capitalizeFirstLetter(dataForField.measure)} of ${field.name}`,\n              value: dataForField.value,\n              deltaValue\n            });\n          }\n          return acc;\n        },\n        [] as {name: string; value?: string; deltaValue: string | null}[]\n      );\n    }\n    return [];\n  }, [data.aggregatedData, fieldsToShow, colorField?.name, primaryData, compareType]);\n\n  const colorMeasure = layer.getVisualChannelDescription('color').measure;\n  const sizeMeasure = layer.getVisualChannelDescription('size').measure;\n  return (\n    <tbody>\n      <Row\n        name={'total points'}\n        key=\"count\"\n        value={String(data.points && data.points.length)}\n        isComparing={isComparing}\n      />\n      {colorField && layer.visualChannels.color && colorMeasure ? (\n        <Row\n          name={colorMeasure}\n          key=\"color\"\n          value={colorValue || 'N/A'}\n          deltaValue={colorDelta}\n          isComparing={isComparing}\n        />\n      ) : null}\n      {sizeField && layer.visualChannels.size && sizeMeasure ? (\n        <Row\n          name={sizeMeasure}\n          key=\"size\"\n          value={elevationValue || 'N/A'}\n          deltaValue={elevationDelta}\n          isComparing={isComparing}\n        />\n      ) : null}\n      {aggregatedData.map((dataForField, idx) => (\n        <Row\n          name={dataForField.name}\n          key={`data_${idx}`}\n          value={dataForField.value != null ? String(dataForField.value) : 'N/A'}\n          deltaValue={dataForField.deltaValue}\n          isComparing={isComparing}\n        />\n      ))}\n    </tbody>\n  );\n};\n\nconst LayerHoverInfoFactory = () => {\n  const LayerHoverInfo = props => {\n    const {data, layer} = props;\n    const intl = useIntl();\n    if (!data || !layer) {\n      return null;\n    }\n\n    const hasFieldsToShow =\n      (data.fieldValues && Object.keys(data.fieldValues).length > 0) ||\n      (data.wmsFeatureData && data.wmsFeatureData.length > 0) ||\n      (props.fieldsToShow && props.fieldsToShow.length > 0);\n\n    return (\n      <div className=\"map-popover__layer-info\">\n        <StyledLayerName className=\"map-popover__layer-name\">\n          <Layers height=\"12px\" />\n          {props.layer.config.label}\n        </StyledLayerName>\n        {hasFieldsToShow && <StyledDivider />}\n        <StyledTable className={props.primaryData ? 'comparing' : undefined}>\n          {data.wmsFeatureData ? (\n            <tbody>\n              {data.wmsFeatureData.map(({name, value}, i) => (\n                <Row key={i} name={name} value={value} />\n              ))}\n            </tbody>\n          ) : data.fieldValues ? (\n            <tbody>\n              {data.fieldValues.map(({labelMessage, value}, i) => (\n                <Row key={i} name={intl.formatMessage({id: labelMessage})} value={value} />\n              ))}\n            </tbody>\n          ) : props.layer.isAggregated ? (\n            <CellInfo {...props} />\n          ) : (\n            <EntryInfo {...props} />\n          )}\n        </StyledTable>\n        {hasFieldsToShow && <StyledDivider />}\n      </div>\n    );\n  };\n\n  LayerHoverInfo.propTypes = {\n    fields: PropTypes.arrayOf(PropTypes.any),\n    fieldsToShow: PropTypes.arrayOf(PropTypes.any),\n    layer: PropTypes.object,\n    data: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.any), PropTypes.object])\n  };\n  return LayerHoverInfo;\n};\n\nexport default LayerHoverInfoFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/map/lazy-tippy.js

@@ -0,0 +1,53 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useState, forwardRef } from 'react';
+import Tippy from '@tippyjs/react/headless';
+import { isTest } from '@kepler.gl/utils';
+var isTestEnv = isTest();
+
+/**
+ * Lazy mounting tippy content
+ * https://gist.github.com/atomiks/520f4b0c7b537202a23a3059d4eec908
+ */
+// eslint-disable-next-line react/display-name
+var LazyTippy = /*#__PURE__*/forwardRef(function (props, ref) {
+  // Mount in test env for easier testing
+  var _useState = useState(isTestEnv),
+    _useState2 = _slicedToArray(_useState, 2),
+    mounted = _useState2[0],
+    setMounted = _useState2[1];
+  var lazyPlugin = {
+    fn: function fn() {
+      return {
+        onMount: function onMount() {
+          return setMounted(true);
+        },
+        onHidden: function onHidden() {
+          return setMounted(false);
+        }
+      };
+    }
+  };
+  var computedProps = _objectSpread({}, props);
+  computedProps.plugins = [lazyPlugin].concat(_toConsumableArray(props.plugins || []));
+  if (props.render) {
+    var render = props.render;
+    computedProps.render = function () {
+      return mounted ? render.apply(void 0, arguments) : '';
+    };
+  } else {
+    computedProps.content = mounted ? props.content : '';
+  }
+  return /*#__PURE__*/React.createElement(Tippy, _extends({}, computedProps, {
+    ref: ref
+  }));
+});
+export default LazyTippy;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/map/locale-panel.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import classnames from 'classnames';
+import ToolbarItem from '../common/toolbar-item';
+import { MapControlButton } from '../common/styled-components';
+import MapControlTooltipFactory from './map-control-tooltip';
+import MapControlToolbarFactory from './map-control-toolbar';
+LocalePanelFactory.deps = [MapControlTooltipFactory, MapControlToolbarFactory];
+function LocalePanelFactory(MapControlTooltip, MapControlToolbar) {
+  var LocalePanel = /*#__PURE__*/React.memo(function (_ref) {
+    var availableLocales = _ref.availableLocales,
+      onToggleMapControl = _ref.onToggleMapControl,
+      onSetLocale = _ref.onSetLocale,
+      currentLocal = _ref.locale,
+      mapControls = _ref.mapControls;
+    var _ref2 = mapControls.mapLocale || {},
+      isActive = _ref2.active,
+      show = _ref2.show;
+    var onClickItem = useCallback(function (locale) {
+      onSetLocale(locale);
+    }, [onSetLocale]);
+    var onClickButton = useCallback(function (e) {
+      e.preventDefault();
+      onToggleMapControl('mapLocale');
+    }, [onToggleMapControl]);
+    var getLabel = useCallback(function (locale) {
+      return "toolbar.".concat(locale);
+    }, []);
+    if (!show) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement("div", {
+      className: "locale-panel-controls",
+      style: {
+        position: 'relative'
+      }
+    }, isActive ? /*#__PURE__*/React.createElement(MapControlToolbar, {
+      $show: isActive
+    }, availableLocales.map(function (locale) {
+      return /*#__PURE__*/React.createElement(ToolbarItem, {
+        key: locale,
+        onClick: function onClick() {
+          return onClickItem(locale);
+        },
+        label: getLabel(locale),
+        active: currentLocal === locale
+      });
+    })) : null, /*#__PURE__*/React.createElement(MapControlTooltip, {
+      id: "locale",
+      message: "tooltip.selectLocale"
+    }, /*#__PURE__*/React.createElement(MapControlButton, {
+      className: classnames('map-control-button', 'locale-panel', {
+        isActive: isActive
+      }),
+      onClick: onClickButton,
+      active: isActive
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "map-control-button__locale"
+    }, currentLocal.toUpperCase()))));
+  });
+  LocalePanel.displayName = 'LocalePanel';
+  return LocalePanel;
+}
+export default LocalePanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZUNhbGxiYWNrIiwiY2xhc3NuYW1lcyIsIlRvb2xiYXJJdGVtIiwiTWFwQ29udHJvbEJ1dHRvbiIsIk1hcENvbnRyb2xUb29sdGlwRmFjdG9yeSIsIk1hcENvbnRyb2xUb29sYmFyRmFjdG9yeSIsIkxvY2FsZVBhbmVsRmFjdG9yeSIsImRlcHMiLCJNYXBDb250cm9sVG9vbHRpcCIsIk1hcENvbnRyb2xUb29sYmFyIiwiTG9jYWxlUGFuZWwiLCJtZW1vIiwiX3JlZiIsImF2YWlsYWJsZUxvY2FsZXMiLCJvblRvZ2dsZU1hcENvbnRyb2wiLCJvblNldExvY2FsZSIsImN1cnJlbnRMb2NhbCIsImxvY2FsZSIsIm1hcENvbnRyb2xzIiwiX3JlZjIiLCJtYXBMb2NhbGUiLCJpc0FjdGl2ZSIsImFjdGl2ZSIsInNob3ciLCJvbkNsaWNrSXRlbSIsIm9uQ2xpY2tCdXR0b24iLCJlIiwicHJldmVudERlZmF1bHQiLCJnZXRMYWJlbCIsImNvbmNhdCIsImNyZWF0ZUVsZW1lbnQiLCJjbGFzc05hbWUiLCJzdHlsZSIsInBvc2l0aW9uIiwiJHNob3ciLCJtYXAiLCJrZXkiLCJvbkNsaWNrIiwibGFiZWwiLCJpZCIsIm1lc3NhZ2UiLCJ0b1VwcGVyQ2FzZSIsImRpc3BsYXlOYW1lIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21hcC9sb2NhbGUtcGFuZWwudHN4Il0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCBSZWFjdCwge3VzZUNhbGxiYWNrfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgY2xhc3NuYW1lcyBmcm9tICdjbGFzc25hbWVzJztcblxuaW1wb3J0IFRvb2xiYXJJdGVtIGZyb20gJy4uL2NvbW1vbi90b29sYmFyLWl0ZW0nO1xuaW1wb3J0IHtNYXBDb250cm9sQnV0dG9ufSBmcm9tICcuLi9jb21tb24vc3R5bGVkLWNvbXBvbmVudHMnO1xuaW1wb3J0IE1hcENvbnRyb2xUb29sdGlwRmFjdG9yeSBmcm9tICcuL21hcC1jb250cm9sLXRvb2x0aXAnO1xuaW1wb3J0IE1hcENvbnRyb2xUb29sYmFyRmFjdG9yeSBmcm9tICcuL21hcC1jb250cm9sLXRvb2xiYXInO1xuaW1wb3J0IHtNYXBDb250cm9sc30gZnJvbSAnQGtlcGxlci5nbC90eXBlcyc7XG5cbkxvY2FsZVBhbmVsRmFjdG9yeS5kZXBzID0gW01hcENvbnRyb2xUb29sdGlwRmFjdG9yeSwgTWFwQ29udHJvbFRvb2xiYXJGYWN0b3J5XTtcblxuZXhwb3J0IHR5cGUgTG9jYWxlUGFuZWxQcm9wcyA9IHtcbiAgYXZhaWxhYmxlTG9jYWxlczogUmVhZG9ubHlBcnJheTxzdHJpbmc+O1xuICBvblNldExvY2FsZTogKGxvY2FsZTogc3RyaW5nKSA9PiB2b2lkO1xuICBsb2NhbGU6IHN0cmluZztcbiAgb25Ub2dnbGVNYXBDb250cm9sOiAoY29udHJvbDogc3RyaW5nKSA9PiB2b2lkO1xuICBtYXBDb250cm9sczogTWFwQ29udHJvbHM7XG59O1xuXG5mdW5jdGlvbiBMb2NhbGVQYW5lbEZhY3RvcnkoXG4gIE1hcENvbnRyb2xUb29sdGlwOiBSZXR1cm5UeXBlPHR5cGVvZiBNYXBDb250cm9sVG9vbHRpcEZhY3Rvcnk+LFxuICBNYXBDb250cm9sVG9vbGJhcjogUmV0dXJuVHlwZTx0eXBlb2YgTWFwQ29udHJvbFRvb2xiYXJGYWN0b3J5PlxuKSB7XG4gIGNvbnN0IExvY2FsZVBhbmVsOiBSZWFjdC5GQzxMb2NhbGVQYW5lbFByb3BzPiA9IFJlYWN0Lm1lbW8oXG4gICAgKHthdmFpbGFibGVMb2NhbGVzLCBvblRvZ2dsZU1hcENvbnRyb2wsIG9uU2V0TG9jYWxlLCBsb2NhbGU6IGN1cnJlbnRMb2NhbCwgbWFwQ29udHJvbHN9KSA9PiB7XG4gICAgICBjb25zdCB7YWN0aXZlOiBpc0FjdGl2ZSwgc2hvd30gPSBtYXBDb250cm9scy5tYXBMb2NhbGUgfHwge307XG5cbiAgICAgIGNvbnN0IG9uQ2xpY2tJdGVtID0gdXNlQ2FsbGJhY2soXG4gICAgICAgIGxvY2FsZSA9PiB7XG4gICAgICAgICAgb25TZXRMb2NhbGUobG9jYWxlKTtcbiAgICAgICAgfSxcbiAgICAgICAgW29uU2V0TG9jYWxlXVxuICAgICAgKTtcblxuICAgICAgY29uc3Qgb25DbGlja0J1dHRvbiA9IHVzZUNhbGxiYWNrKFxuICAgICAgICBlID0+IHtcbiAgICAgICAgICBlLnByZXZlbnREZWZhdWx0KCk7XG4gICAgICAgICAgb25Ub2dnbGVNYXBDb250cm9sKCdtYXBMb2NhbGUnKTtcbiAgICAgICAgfSxcbiAgICAgICAgW29uVG9nZ2xlTWFwQ29udHJvbF1cbiAgICAgICk7XG4gICAgICBjb25zdCBnZXRMYWJlbCA9IHVzZUNhbGxiYWNrKGxvY2FsZSA9PiBgdG9vbGJhci4ke2xvY2FsZX1gLCBbXSk7XG5cbiAgICAgIGlmICghc2hvdykge1xuICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgIH1cbiAgICAgIHJldHVybiAoXG4gICAgICAgIDxkaXYgY2xhc3NOYW1lPVwibG9jYWxlLXBhbmVsLWNvbnRyb2xzXCIgc3R5bGU9e3twb3NpdGlvbjogJ3JlbGF0aXZlJ319PlxuICAgICAgICAgIHtpc0FjdGl2ZSA/IChcbiAgICAgICAgICAgIDxNYXBDb250cm9sVG9vbGJhciAkc2hvdz17aXNBY3RpdmV9PlxuICAgICAgICAgICAgICB7YXZhaWxhYmxlTG9jYWxlcy5tYXAobG9jYWxlID0+IChcbiAgICAgICAgICAgICAgICA8VG9vbGJhckl0ZW1cbiAgICAgICAgICAgICAgICAgIGtleT17bG9jYWxlfVxuICAgICAgICAgICAgICAgICAgb25DbGljaz17KCkgPT4gb25DbGlja0l0ZW0obG9jYWxlKX1cbiAgICAgICAgICAgICAgICAgIGxhYmVsPXtnZXRMYWJlbChsb2NhbGUpfVxuICAgICAgICAgICAgICAgICAgYWN0aXZlPXtjdXJyZW50TG9jYWwgPT09IGxvY2FsZX1cbiAgICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgICApKX1cbiAgICAgICAgICAgIDwvTWFwQ29udHJvbFRvb2xiYXI+XG4gICAgICAgICAgKSA6IG51bGx9XG4gICAgICAgICAgPE1hcENvbnRyb2xUb29sdGlwIGlkPVwibG9jYWxlXCIgbWVzc2FnZT1cInRvb2x0aXAuc2VsZWN0TG9jYWxlXCI+XG4gICAgICAgICAgICA8TWFwQ29udHJvbEJ1dHRvblxuICAgICAgICAgICAgICBjbGFzc05hbWU9e2NsYXNzbmFtZXMoJ21hcC1jb250cm9sLWJ1dHRvbicsICdsb2NhbGUtcGFuZWwnLCB7aXNBY3RpdmV9KX1cbiAgICAgICAgICAgICAgb25DbGljaz17b25DbGlja0J1dHRvbn1cbiAgICAgICAgICAgICAgYWN0aXZlPXtpc0FjdGl2ZX1cbiAgICAgICAgICAgID5cbiAgICAgICAgICAgICAgPHNwYW4gY2xhc3NOYW1lPVwibWFwLWNvbnRyb2wtYnV0dG9uX19sb2NhbGVcIj57Y3VycmVudExvY2FsLnRvVXBwZXJDYXNlKCl9PC9zcGFuPlxuICAgICAgICAgICAgPC9NYXBDb250cm9sQnV0dG9uPlxuICAgICAgICAgIDwvTWFwQ29udHJvbFRvb2x0aXA+XG4gICAgICAgIDwvZGl2PlxuICAgICAgKTtcbiAgICB9XG4gICk7XG5cbiAgTG9jYWxlUGFuZWwuZGlzcGxheU5hbWUgPSAnTG9jYWxlUGFuZWwnO1xuXG4gIHJldHVybiBMb2NhbGVQYW5lbDtcbn1cblxuZXhwb3J0IGRlZmF1bHQgTG9jYWxlUGFuZWxGYWN0b3J5O1xuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBOztBQUVBLE9BQU9BLEtBQUssSUFBR0MsV0FBVyxRQUFPLE9BQU87QUFDeEMsT0FBT0MsVUFBVSxNQUFNLFlBQVk7QUFFbkMsT0FBT0MsV0FBVyxNQUFNLHdCQUF3QjtBQUNoRCxTQUFRQyxnQkFBZ0IsUUFBTyw2QkFBNkI7QUFDNUQsT0FBT0Msd0JBQXdCLE1BQU0sdUJBQXVCO0FBQzVELE9BQU9DLHdCQUF3QixNQUFNLHVCQUF1QjtBQUc1REMsa0JBQWtCLENBQUNDLElBQUksR0FBRyxDQUFDSCx3QkFBd0IsRUFBRUMsd0JBQXdCLENBQUM7QUFVOUUsU0FBU0Msa0JBQWtCQSxDQUN6QkUsaUJBQThELEVBQzlEQyxpQkFBOEQsRUFDOUQ7RUFDQSxJQUFNQyxXQUF1QyxnQkFBR1gsS0FBSyxDQUFDWSxJQUFJLENBQ3hELFVBQUFDLElBQUEsRUFBNEY7SUFBQSxJQUExRkMsZ0JBQWdCLEdBQUFELElBQUEsQ0FBaEJDLGdCQUFnQjtNQUFFQyxrQkFBa0IsR0FBQUYsSUFBQSxDQUFsQkUsa0JBQWtCO01BQUVDLFdBQVcsR0FBQUgsSUFBQSxDQUFYRyxXQUFXO01BQVVDLFlBQVksR0FBQUosSUFBQSxDQUFwQkssTUFBTTtNQUFnQkMsV0FBVyxHQUFBTixJQUFBLENBQVhNLFdBQVc7SUFDcEYsSUFBQUMsS0FBQSxHQUFpQ0QsV0FBVyxDQUFDRSxTQUFTLElBQUksQ0FBQyxDQUFDO01BQTdDQyxRQUFRLEdBQUFGLEtBQUEsQ0FBaEJHLE1BQU07TUFBWUMsSUFBSSxHQUFBSixLQUFBLENBQUpJLElBQUk7SUFFN0IsSUFBTUMsV0FBVyxHQUFHeEIsV0FBVyxDQUM3QixVQUFBaUIsTUFBTSxFQUFJO01BQ1JGLFdBQVcsQ0FBQ0UsTUFBTSxDQUFDO0lBQ3JCLENBQUMsRUFDRCxDQUFDRixXQUFXLENBQ2QsQ0FBQztJQUVELElBQU1VLGFBQWEsR0FBR3pCLFdBQVcsQ0FDL0IsVUFBQTBCLENBQUMsRUFBSTtNQUNIQSxDQUFDLENBQUNDLGNBQWMsQ0FBQyxDQUFDO01BQ2xCYixrQkFBa0IsQ0FBQyxXQUFXLENBQUM7SUFDakMsQ0FBQyxFQUNELENBQUNBLGtCQUFrQixDQUNyQixDQUFDO0lBQ0QsSUFBTWMsUUFBUSxHQUFHNUIsV0FBVyxDQUFDLFVBQUFpQixNQUFNO01BQUEsa0JBQUFZLE1BQUEsQ0FBZVosTUFBTTtJQUFBLENBQUUsRUFBRSxFQUFFLENBQUM7SUFFL0QsSUFBSSxDQUFDTSxJQUFJLEVBQUU7TUFDVCxPQUFPLElBQUk7SUFDYjtJQUNBLG9CQUNFeEIsS0FBQSxDQUFBK0IsYUFBQTtNQUFLQyxTQUFTLEVBQUMsdUJBQXVCO01BQUNDLEtBQUssRUFBRTtRQUFDQyxRQUFRLEVBQUU7TUFBVTtJQUFFLEdBQ2xFWixRQUFRLGdCQUNQdEIsS0FBQSxDQUFBK0IsYUFBQSxDQUFDckIsaUJBQWlCO01BQUN5QixLQUFLLEVBQUViO0lBQVMsR0FDaENSLGdCQUFnQixDQUFDc0IsR0FBRyxDQUFDLFVBQUFsQixNQUFNO01BQUEsb0JBQzFCbEIsS0FBQSxDQUFBK0IsYUFBQSxDQUFDNUIsV0FBVztRQUNWa0MsR0FBRyxFQUFFbkIsTUFBTztRQUNab0IsT0FBTyxFQUFFLFNBQVRBLE9BQU9BLENBQUE7VUFBQSxPQUFRYixXQUFXLENBQUNQLE1BQU0sQ0FBQztRQUFBLENBQUM7UUFDbkNxQixLQUFLLEVBQUVWLFFBQVEsQ0FBQ1gsTUFBTSxDQUFFO1FBQ3hCSyxNQUFNLEVBQUVOLFlBQVksS0FBS0M7TUFBTyxDQUNqQyxDQUFDO0lBQUEsQ0FDSCxDQUNnQixDQUFDLEdBQ2xCLElBQUksZUFDUmxCLEtBQUEsQ0FBQStCLGFBQUEsQ0FBQ3RCLGlCQUFpQjtNQUFDK0IsRUFBRSxFQUFDLFFBQVE7TUFBQ0MsT0FBTyxFQUFDO0lBQXNCLGdCQUMzRHpDLEtBQUEsQ0FBQStCLGFBQUEsQ0FBQzNCLGdCQUFnQjtNQUNmNEIsU0FBUyxFQUFFOUIsVUFBVSxDQUFDLG9CQUFvQixFQUFFLGNBQWMsRUFBRTtRQUFDb0IsUUFBUSxFQUFSQTtNQUFRLENBQUMsQ0FBRTtNQUN4RWdCLE9BQU8sRUFBRVosYUFBYztNQUN2QkgsTUFBTSxFQUFFRDtJQUFTLGdCQUVqQnRCLEtBQUEsQ0FBQStCLGFBQUE7TUFBTUMsU0FBUyxFQUFDO0lBQTRCLEdBQUVmLFlBQVksQ0FBQ3lCLFdBQVcsQ0FBQyxDQUFRLENBQy9ELENBQ0QsQ0FDaEIsQ0FBQztFQUVWLENBQ0YsQ0FBQztFQUVEL0IsV0FBVyxDQUFDZ0MsV0FBVyxHQUFHLGFBQWE7RUFFdkMsT0FBT2hDLFdBQVc7QUFDcEI7QUFFQSxlQUFlSixrQkFBa0IiLCJpZ25vcmVMaXN0IjpbXX0=