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

package/dist/cjs/map/attribution.js

@@ -0,0 +1,391 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapLibLogo = exports.DatasetAttributions = exports.AttributionLogos = exports.Attribution = void 0;
+exports.dedupeBasemapAttributions = dedupeBasemapAttributions;
+exports.renderBasemapAttribution = renderBasemapAttribution;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+var _utils = require("@kepler.gl/utils");
+var _styles = require("@kepler.gl/styles");
+var _styledComponents2 = require("../common/styled-components");
+var _templateObject, _templateObject2, _templateObject3; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+var MapLibLogo = exports.MapLibLogo = function MapLibLogo(_ref) {
+  var baseMapLibraryConfig = _ref.baseMapLibraryConfig;
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: "attrition-logo"
+  }, "Basemap by:", /*#__PURE__*/_react["default"].createElement("a", {
+    style: {
+      marginLeft: '5px'
+    },
+    className: "".concat(baseMapLibraryConfig.mapLibCssClass, "-ctrl-logo"),
+    target: "_blank",
+    rel: "noopener noreferrer",
+    href: baseMapLibraryConfig.mapLibUrl,
+    "aria-label": "".concat(baseMapLibraryConfig.mapLibName, " logo")
+  }));
+};
+var StyledDatasetAttributionsContainer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  max-width: ", ";\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ", ";\n  margin-right: 2px;\n  margin-bottom: 1px;\n  line-height: ", ";\n\n  &:hover {\n    white-space: inherit;\n  }\n"])), function (props) {
+  return props.isPalm ? '200px' : '300px';
+}, function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.isPalm ? '1em' : '1.4em';
+});
+var DatasetAttributions = exports.DatasetAttributions = function DatasetAttributions(_ref2) {
+  var datasetAttributions = _ref2.datasetAttributions,
+    isPalm = _ref2.isPalm;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement(StyledDatasetAttributionsContainer, {
+    isPalm: isPalm
+  }, datasetAttributions.map(function (ds, idx) {
+    return /*#__PURE__*/_react["default"].createElement("a", (0, _extends2["default"])({}, ds.url ? {
+      href: ds.url
+    } : null, {
+      target: "_blank",
+      rel: "noopener noreferrer",
+      key: "".concat(ds.title, "_").concat(idx)
+    }), ds.title, idx !== datasetAttributions.length - 1 ? ', ' : null);
+  })) : null);
+};
+var ATTRIBUTION_SAFE_HREF_REGEX = /^(https?:|mailto:)/i;
+
+/**
+ * Decode the handful of HTML entities that commonly appear in basemap
+ * attribution strings, so they render as text rather than raw entities. Only
+ * needed on the SSR / no-DOM fallback path; in the browser DOMParser decodes
+ * entities for us.
+ */
+function decodeAttributionEntities(text) {
+  return text.replace(/&copy;/gi, '©').replace(/&nbsp;/gi, ' ').replace(/&lt;/gi, '<').replace(/&gt;/gi, '>').replace(/&quot;/gi, '"').replace(/&#0*39;/gi, "'").replace(/&amp;/gi, '&');
+}
+
+/**
+ * Strip all markup from a string as a fallback for environments without a DOM
+ * (e.g. SSR), then decode common HTML entities. Uses a non-greedy tag matcher;
+ * only used when DOMParser is unavailable, so it never has to be perfectly
+ * correct.
+ */
+function stripTags(html) {
+  return decodeAttributionEntities(html.replace(/<[^>]*>/g, '')).trim();
+}
+
+/**
+ * Recursively convert parsed DOM nodes into safe React nodes. Only anchor
+ * elements with http(s)/mailto hrefs become links; every other element is
+ * flattened to its text content. Text nodes are emitted with internal
+ * whitespace collapsed to single spaces (matching HTML rendering), so the
+ * meaningful single space between adjacent links is preserved while we avoid
+ * emitting large whitespace blobs.
+ *
+ * Anchors are collapsed to their `textContent`, so any markup nested inside an
+ * anchor (including an invalid nested `<a>`) becomes plain text — a link can
+ * never contain another link.
+ */
+function domNodesToReact(nodes, keyPrefix, counter) {
+  var result = [];
+  nodes.forEach(function (node) {
+    if (node.nodeType === 3 /* TEXT_NODE */) {
+      // collapse whitespace runs to a single space (HTML-like), keeping a
+      // meaningful separating space between adjacent inline links
+      var text = (node.textContent || '').replace(/\s+/g, ' ');
+      if (text) {
+        result.push(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+          key: "".concat(keyPrefix, "-t").concat(counter.i++)
+        }, text));
+      }
+      return;
+    }
+    if (node.nodeType !== 1 /* ELEMENT_NODE */) {
+      return;
+    }
+    var el = node;
+    var tag = el.tagName.toLowerCase();
+    // never surface the source of script/style/template elements as text
+    if (tag === 'script' || tag === 'style' || tag === 'template' || tag === 'noscript') {
+      return;
+    }
+    if (tag === 'a') {
+      var href = el.getAttribute('href') || '';
+      // textContent flattens any nested markup (incl. a nested <a>) to text, so
+      // the rendered link can never contain another link
+      var _text = el.textContent || '';
+      if (!_text.trim()) return;
+      if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {
+        result.push(/*#__PURE__*/_react["default"].createElement("a", {
+          key: "".concat(keyPrefix, "-a").concat(counter.i++),
+          href: href,
+          target: "_blank",
+          rel: "noopener noreferrer"
+        }, _text));
+      } else {
+        // drop unsafe hrefs (e.g. javascript:) but keep the link text
+        result.push(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+          key: "".concat(keyPrefix, "-a").concat(counter.i++)
+        }, _text));
+      }
+      return;
+    }
+    // any other element: keep its (recursively resolved) children
+    result.push.apply(result, (0, _toConsumableArray2["default"])(domNodesToReact(el.childNodes, keyPrefix, counter)));
+  });
+  return result;
+}
+function resolveDOMParser() {
+  return typeof window !== 'undefined' && window.DOMParser || typeof globalThis !== 'undefined' && globalThis.DOMParser || null;
+}
+
+/**
+ * Parse a basemap attribution HTML string into safe React nodes. Only anchor
+ * tags with http(s)/mailto hrefs become links; everything else is rendered as
+ * plain text. This avoids dangerouslySetInnerHTML while preserving the links
+ * custom basemap styles (e.g. OpenFreeMap) declare in their attribution.
+ *
+ * Uses the browser's DOMParser (inert: scripts don't run and no resources are
+ * fetched) so nested tags, `>` inside attributes, unusual quoting, and HTML
+ * entities are all handled correctly. Falls back to plain text where no DOM is
+ * available (e.g. SSR).
+ */
+function renderBasemapAttribution(html, keyPrefix) {
+  var DOMParserCtor = resolveDOMParser();
+  if (!DOMParserCtor) {
+    var text = stripTags(html);
+    return text ? [/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-t0")
+    }, text)] : [];
+  }
+  try {
+    var doc = new DOMParserCtor().parseFromString(html, 'text/html');
+    return domNodesToReact(doc.body.childNodes, keyPrefix, {
+      i: 0
+    }).filter(Boolean);
+  } catch (_unused) {
+    var _text2 = stripTags(html);
+    return _text2 ? [/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-t0")
+    }, _text2)] : [];
+  }
+}
+
+/**
+ * Build a set of "signature" tokens for an attribution string: the hostname of
+ * each safe link plus the normalized plain text (lowercased, punctuation and
+ * the boilerplate word "contributors" removed). Two attributions that point at
+ * the same providers therefore produce overlapping signatures even when their
+ * wording differs (e.g. "© OpenStreetMap" vs "© OpenStreetMap contributors").
+ */
+function attributionSignature(html) {
+  var tokens = new Set();
+  var DOMParserCtor = resolveDOMParser();
+  var text = html;
+  if (DOMParserCtor) {
+    try {
+      var doc = new DOMParserCtor().parseFromString(html, 'text/html');
+      doc.body.querySelectorAll('a').forEach(function (a) {
+        var href = a.getAttribute('href') || '';
+        if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {
+          try {
+            tokens.add("href:".concat(new URL(href).hostname.replace(/^www\./, '').toLowerCase()));
+          } catch (_unused2) {
+            tokens.add("href:".concat(href.toLowerCase()));
+          }
+        }
+      });
+      text = doc.body.textContent || '';
+    } catch (_unused3) {
+      text = stripTags(html);
+    }
+  } else {
+    text = stripTags(html);
+  }
+  var normalized = text.toLowerCase().replace(/©|&copy;/g, '').replace(/\bcontributors?\b/g, '').replace(/[^a-z0-9]+/g, ' ').trim();
+  if (normalized) {
+    // emit per-word tokens so a shorter attribution's words can be subsumed by
+    // a longer one that mentions the same providers (e.g. "openstreetmap" is
+    // covered by a CARTO string mentioning both "carto" and "openstreetmap")
+    normalized.split(' ').forEach(function (word) {
+      if (word) tokens.add("text:".concat(word));
+    });
+  }
+  return tokens;
+}
+
+/**
+ * Drop attributions whose providers are already fully represented by a single
+ * earlier (kept) attribution. Order is preserved, and the longer/more complete
+ * strings tend to come first from the sources so they survive. This collapses
+ * near-duplicates such as a standalone "© OpenStreetMap" when a CARTO string
+ * that already links OpenStreetMap is present.
+ *
+ * Subsumption is checked against each kept attribution *individually* (never a
+ * merged union), so an entry is only dropped when some single earlier entry
+ * fully covers it. This avoids false positives where two unrelated providers'
+ * tokens together happen to cover a distinct third provider.
+ */
+function dedupeBasemapAttributions(attributions) {
+  var kept = [];
+  var keptTokens = [];
+  attributions.forEach(function (attribution) {
+    var sig = attributionSignature(attribution);
+    if (sig.size === 0) {
+      // nothing to compare on; keep as-is (exact dedup already done upstream)
+      if (!kept.includes(attribution)) {
+        kept.push(attribution);
+        keptTokens.push(sig);
+      }
+      return;
+    }
+    // subsumed only if some single kept attribution's tokens are a superset
+    var isSubsumed = keptTokens.some(function (tokens) {
+      return tokens.size > 0 && (0, _toConsumableArray2["default"])(sig).every(function (t) {
+        return tokens.has(t);
+      });
+    });
+    if (!isSubsumed) {
+      kept.push(attribution);
+      keptTokens.push(sig);
+    }
+  });
+  return kept;
+}
+
+/**
+ * Render a list of items as `| item | item ...` fragments, each preceded by a
+ * pipe separator. Keys are index-based (safe even when item content collides,
+ * e.g. two globe attributions sharing a label). Returns null when empty so
+ * callers can `{group}` inline.
+ */
+function renderSeparatedLinks(items, keyPrefix, renderItem) {
+  if (!items.length) return null;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, items.map(function (item, idx) {
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-").concat(idx)
+    }, /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|"), renderItem(item, idx));
+  }));
+}
+var Attribution = exports.Attribution = function Attribution(_ref3) {
+  var _ref3$showBaseMapLibL = _ref3.showBaseMapLibLogo,
+    showBaseMapLibLogo = _ref3$showBaseMapLibL === void 0 ? true : _ref3$showBaseMapLibL,
+    _ref3$basemapAttribut = _ref3.basemapAttributions,
+    basemapAttributions = _ref3$basemapAttribut === void 0 ? [] : _ref3$basemapAttribut,
+    datasetAttributions = _ref3.datasetAttributions,
+    baseMapLibraryConfig = _ref3.baseMapLibraryConfig,
+    _ref3$globeAttributio = _ref3.globeAttributions,
+    globeAttributions = _ref3$globeAttributio === void 0 ? [] : _ref3$globeAttributio;
+  var isPalm = (0, _utils.hasMobileWidth)(_styles.breakPointValues);
+  var memoizedComponents = (0, _react.useMemo)(function () {
+    // collapse near-duplicate attributions (e.g. a standalone OSM link when a
+    // CARTO string already links OSM) before rendering
+    var dedupedBasemapAttributions = dedupeBasemapAttributions(basemapAttributions);
+    // attributions declared by custom basemap styles, rendered as safe links
+    var basemapAttributionNodes = renderSeparatedLinks(dedupedBasemapAttributions, 'basemap-attr', function (attribution, idx) {
+      return /*#__PURE__*/_react["default"].createElement("span", {
+        className: "basemap-attribution"
+      }, renderBasemapAttribution(attribution, "basemap-attr-".concat(idx)));
+    });
+    var globeAttributionNodes = renderSeparatedLinks(globeAttributions, 'globe-attr', function (attr) {
+      return /*#__PURE__*/_react["default"].createElement("a", {
+        href: attr.href,
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, attr.label);
+    });
+    if (!showBaseMapLibLogo) {
+      return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttribution, {
+        mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+        mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+        showLogo: globeAttributions.length > 0
+      }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+        datasetAttributions: datasetAttributions,
+        isPalm: isPalm
+      }), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "attrition-link"
+      }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null, /*#__PURE__*/_react["default"].createElement("a", {
+        href: "https://kepler.gl/policy/",
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, globeAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && !isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null)));
+    }
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttribution, {
+      mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+      mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+      showLogo: true
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+      datasetAttributions: datasetAttributions,
+      isPalm: isPalm
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "attrition-link"
+    }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|") : null, isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null, /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://kepler.gl/policy/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|"), !isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null)));
+  }, [showBaseMapLibLogo, basemapAttributions, datasetAttributions, isPalm, baseMapLibraryConfig, globeAttributions]);
+  return memoizedComponents;
+};
+var StyledAttributionLogoContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n  bottom: ", "px;\n  left: ", "px;\n  z-index: 1;\n  display: flex;\n  align-items: flex-end;\n  gap: 4px;\n  pointer-events: auto;\n  transition: left 250ms ease-in-out;\n"])), function (props) {
+  return props.theme.sidePanel.margin.left;
+}, function (props) {
+  return props.$left;
+});
+var StyledLogoLink = _styledComponents["default"].a(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: ", ";\n  display: flex;\n  align-items: flex-end;\n"])), function (props) {
+  return props.$enabled ? 'pointer' : 'default';
+});
+var LOGO_LEFT_ADJUSTMENT = 3;
+var AttributionLogos = exports.AttributionLogos = function AttributionLogos(_ref4) {
+  var logos = _ref4.logos,
+    activeSidePanel = _ref4.activeSidePanel,
+    sidePanelWidth = _ref4.sidePanelWidth;
+  var theme = (0, _styledComponents.useTheme)();
+  var left = (activeSidePanel ? (sidePanelWidth || 0) + LOGO_LEFT_ADJUSTMENT : 0) + theme.sidePanel.margin.left;
+  if (!(logos !== null && logos !== void 0 && logos.length)) return null;
+  return /*#__PURE__*/_react["default"].createElement(StyledAttributionLogoContainer, {
+    $left: left
+  }, logos.map(function (logo, idx) {
+    return /*#__PURE__*/_react["default"].createElement(StyledLogoLink, (0, _extends2["default"])({
+      key: logo.logoUrl || idx,
+      href: logo.url || undefined
+    }, logo.url ? {
+      target: '_blank',
+      rel: 'noopener noreferrer'
+    } : {}, {
+      $enabled: Boolean(logo.url),
+      style: logo.bottom ? {
+        marginBottom: logo.bottom
+      } : undefined
+    }), /*#__PURE__*/_react["default"].createElement("img", {
+      src: logo.logoUrl,
+      style: {
+        height: logo.height || 12
+      },
+      alt: logo.title
+    }));
+  }));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_utils","_styles","_styledComponents2","_templateObject","_templateObject2","_templateObject3","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","MapLibLogo","exports","_ref","baseMapLibraryConfig","createElement","className","style","marginLeft","concat","mapLibCssClass","target","rel","href","mapLibUrl","mapLibName","StyledDatasetAttributionsContainer","styled","div","_taggedTemplateLiteral2","props","isPalm","theme","labelColor","DatasetAttributions","_ref2","datasetAttributions","Fragment","length","map","ds","idx","_extends2","url","key","title","ATTRIBUTION_SAFE_HREF_REGEX","decodeAttributionEntities","text","replace","stripTags","html","trim","domNodesToReact","nodes","keyPrefix","counter","result","forEach","node","nodeType","textContent","push","el","tag","tagName","toLowerCase","getAttribute","test","apply","_toConsumableArray2","childNodes","resolveDOMParser","window","DOMParser","globalThis","renderBasemapAttribution","DOMParserCtor","doc","parseFromString","body","filter","Boolean","_unused","attributionSignature","tokens","Set","querySelectorAll","a","add","URL","hostname","_unused2","_unused3","normalized","split","word","dedupeBasemapAttributions","attributions","kept","keptTokens","attribution","sig","size","includes","isSubsumed","some","every","renderSeparatedLinks","items","renderItem","item","Attribution","_ref3","_ref3$showBaseMapLibL","showBaseMapLibLogo","_ref3$basemapAttribut","basemapAttributions","_ref3$globeAttributio","globeAttributions","hasMobileWidth","breakPointValues","memoizedComponents","useMemo","dedupedBasemapAttributions","basemapAttributionNodes","globeAttributionNodes","attr","label","StyledAttribution","mapLibAttributionCssClass","showLogo","EndHorizontalFlexbox","StyledAttributionLogoContainer","sidePanel","margin","left","$left","StyledLogoLink","$enabled","LOGO_LEFT_ADJUSTMENT","AttributionLogos","_ref4","logos","activeSidePanel","sidePanelWidth","useTheme","logo","logoUrl","undefined","bottom","marginBottom","src","height","alt"],"sources":["../../../src/map/attribution.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport styled, {useTheme} from 'styled-components';\n\nimport {AttributionWithStyle, DatasetAttribution} from '@kepler.gl/types';\nimport {BaseMapLibraryConfig, hasMobileWidth} from '@kepler.gl/utils';\nimport {breakPointValues} from '@kepler.gl/styles';\nimport type {GlobeAttribution} from '@kepler.gl/deckgl-layers';\n\nimport {StyledAttribution, EndHorizontalFlexbox} from '../common/styled-components';\n\ntype MapLibLogoProps = {\n  baseMapLibraryConfig: BaseMapLibraryConfig;\n};\n\nexport const MapLibLogo = ({baseMapLibraryConfig}: MapLibLogoProps) => (\n  <div className=\"attrition-logo\">\n    Basemap by:\n    <a\n      style={{marginLeft: '5px'}}\n      className={`${baseMapLibraryConfig.mapLibCssClass}-ctrl-logo`}\n      target=\"_blank\"\n      rel=\"noopener noreferrer\"\n      href={baseMapLibraryConfig.mapLibUrl}\n      aria-label={`${baseMapLibraryConfig.mapLibName} logo`}\n    />\n  </div>\n);\n\ninterface StyledDatasetAttributionsContainerProps {\n  isPalm: boolean;\n}\n\nconst StyledDatasetAttributionsContainer = styled.div<StyledDatasetAttributionsContainerProps>`\n  max-width: ${props => (props.isPalm ? '200px' : '300px')};\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ${props => props.theme.labelColor};\n  margin-right: 2px;\n  margin-bottom: 1px;\n  line-height: ${props => (props.isPalm ? '1em' : '1.4em')};\n\n  &:hover {\n    white-space: inherit;\n  }\n`;\n\nexport const DatasetAttributions = ({\n  datasetAttributions,\n  isPalm\n}: {\n  datasetAttributions: DatasetAttribution[];\n  isPalm: boolean;\n}) => (\n  <>\n    {datasetAttributions?.length ? (\n      <StyledDatasetAttributionsContainer isPalm={isPalm}>\n        {datasetAttributions.map((ds, idx) => (\n          <a\n            {...(ds.url ? {href: ds.url} : null)}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n            key={`${ds.title}_${idx}`}\n          >\n            {ds.title}\n            {idx !== datasetAttributions.length - 1 ? ', ' : null}\n          </a>\n        ))}\n      </StyledDatasetAttributionsContainer>\n    ) : null}\n  </>\n);\n\ntype AttributionProps = {\n  showBaseMapLibLogo: boolean;\n  basemapAttributions?: string[];\n  datasetAttributions: DatasetAttribution[];\n  baseMapLibraryConfig: BaseMapLibraryConfig;\n  globeAttributions?: GlobeAttribution[];\n};\n\nconst ATTRIBUTION_SAFE_HREF_REGEX = /^(https?:|mailto:)/i;\n\n/**\n * Decode the handful of HTML entities that commonly appear in basemap\n * attribution strings, so they render as text rather than raw entities. Only\n * needed on the SSR / no-DOM fallback path; in the browser DOMParser decodes\n * entities for us.\n */\nfunction decodeAttributionEntities(text: string): string {\n  return text\n    .replace(/&copy;/gi, '©')\n    .replace(/&nbsp;/gi, ' ')\n    .replace(/&lt;/gi, '<')\n    .replace(/&gt;/gi, '>')\n    .replace(/&quot;/gi, '\"')\n    .replace(/&#0*39;/gi, \"'\")\n    .replace(/&amp;/gi, '&');\n}\n\n/**\n * Strip all markup from a string as a fallback for environments without a DOM\n * (e.g. SSR), then decode common HTML entities. Uses a non-greedy tag matcher;\n * only used when DOMParser is unavailable, so it never has to be perfectly\n * correct.\n */\nfunction stripTags(html: string): string {\n  return decodeAttributionEntities(html.replace(/<[^>]*>/g, '')).trim();\n}\n\n/**\n * Recursively convert parsed DOM nodes into safe React nodes. Only anchor\n * elements with http(s)/mailto hrefs become links; every other element is\n * flattened to its text content. Text nodes are emitted with internal\n * whitespace collapsed to single spaces (matching HTML rendering), so the\n * meaningful single space between adjacent links is preserved while we avoid\n * emitting large whitespace blobs.\n *\n * Anchors are collapsed to their `textContent`, so any markup nested inside an\n * anchor (including an invalid nested `<a>`) becomes plain text — a link can\n * never contain another link.\n */\nfunction domNodesToReact(\n  nodes: NodeListOf<ChildNode> | ChildNode[],\n  keyPrefix: string,\n  counter: {i: number}\n): React.ReactNode[] {\n  const result: React.ReactNode[] = [];\n  nodes.forEach(node => {\n    if (node.nodeType === 3 /* TEXT_NODE */) {\n      // collapse whitespace runs to a single space (HTML-like), keeping a\n      // meaningful separating space between adjacent inline links\n      const text = (node.textContent || '').replace(/\\s+/g, ' ');\n      if (text) {\n        result.push(<React.Fragment key={`${keyPrefix}-t${counter.i++}`}>{text}</React.Fragment>);\n      }\n      return;\n    }\n    if (node.nodeType !== 1 /* ELEMENT_NODE */) {\n      return;\n    }\n    const el = node as Element;\n    const tag = el.tagName.toLowerCase();\n    // never surface the source of script/style/template elements as text\n    if (tag === 'script' || tag === 'style' || tag === 'template' || tag === 'noscript') {\n      return;\n    }\n    if (tag === 'a') {\n      const href = el.getAttribute('href') || '';\n      // textContent flattens any nested markup (incl. a nested <a>) to text, so\n      // the rendered link can never contain another link\n      const text = el.textContent || '';\n      if (!text.trim()) return;\n      if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {\n        result.push(\n          <a\n            key={`${keyPrefix}-a${counter.i++}`}\n            href={href}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            {text}\n          </a>\n        );\n      } else {\n        // drop unsafe hrefs (e.g. javascript:) but keep the link text\n        result.push(<React.Fragment key={`${keyPrefix}-a${counter.i++}`}>{text}</React.Fragment>);\n      }\n      return;\n    }\n    // any other element: keep its (recursively resolved) children\n    result.push(...domNodesToReact(el.childNodes, keyPrefix, counter));\n  });\n  return result;\n}\n\nfunction resolveDOMParser(): {new (): DOMParser} | null {\n  return (\n    (typeof window !== 'undefined' && (window as any).DOMParser) ||\n    (typeof globalThis !== 'undefined' && (globalThis as any).DOMParser) ||\n    null\n  );\n}\n\n/**\n * Parse a basemap attribution HTML string into safe React nodes. Only anchor\n * tags with http(s)/mailto hrefs become links; everything else is rendered as\n * plain text. This avoids dangerouslySetInnerHTML while preserving the links\n * custom basemap styles (e.g. OpenFreeMap) declare in their attribution.\n *\n * Uses the browser's DOMParser (inert: scripts don't run and no resources are\n * fetched) so nested tags, `>` inside attributes, unusual quoting, and HTML\n * entities are all handled correctly. Falls back to plain text where no DOM is\n * available (e.g. SSR).\n */\nexport function renderBasemapAttribution(html: string, keyPrefix: string): React.ReactNode[] {\n  const DOMParserCtor = resolveDOMParser();\n  if (!DOMParserCtor) {\n    const text = stripTags(html);\n    return text ? [<React.Fragment key={`${keyPrefix}-t0`}>{text}</React.Fragment>] : [];\n  }\n  try {\n    const doc = new DOMParserCtor().parseFromString(html, 'text/html');\n    return domNodesToReact(doc.body.childNodes, keyPrefix, {i: 0}).filter(Boolean);\n  } catch {\n    const text = stripTags(html);\n    return text ? [<React.Fragment key={`${keyPrefix}-t0`}>{text}</React.Fragment>] : [];\n  }\n}\n\n/**\n * Build a set of \"signature\" tokens for an attribution string: the hostname of\n * each safe link plus the normalized plain text (lowercased, punctuation and\n * the boilerplate word \"contributors\" removed). Two attributions that point at\n * the same providers therefore produce overlapping signatures even when their\n * wording differs (e.g. \"© OpenStreetMap\" vs \"© OpenStreetMap contributors\").\n */\nfunction attributionSignature(html: string): Set<string> {\n  const tokens = new Set<string>();\n  const DOMParserCtor = resolveDOMParser();\n  let text = html;\n  if (DOMParserCtor) {\n    try {\n      const doc = new DOMParserCtor().parseFromString(html, 'text/html');\n      doc.body.querySelectorAll('a').forEach(a => {\n        const href = a.getAttribute('href') || '';\n        if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {\n          try {\n            tokens.add(`href:${new URL(href).hostname.replace(/^www\\./, '').toLowerCase()}`);\n          } catch {\n            tokens.add(`href:${href.toLowerCase()}`);\n          }\n        }\n      });\n      text = doc.body.textContent || '';\n    } catch {\n      text = stripTags(html);\n    }\n  } else {\n    text = stripTags(html);\n  }\n  const normalized = text\n    .toLowerCase()\n    .replace(/©|&copy;/g, '')\n    .replace(/\\bcontributors?\\b/g, '')\n    .replace(/[^a-z0-9]+/g, ' ')\n    .trim();\n  if (normalized) {\n    // emit per-word tokens so a shorter attribution's words can be subsumed by\n    // a longer one that mentions the same providers (e.g. \"openstreetmap\" is\n    // covered by a CARTO string mentioning both \"carto\" and \"openstreetmap\")\n    normalized.split(' ').forEach(word => {\n      if (word) tokens.add(`text:${word}`);\n    });\n  }\n  return tokens;\n}\n\n/**\n * Drop attributions whose providers are already fully represented by a single\n * earlier (kept) attribution. Order is preserved, and the longer/more complete\n * strings tend to come first from the sources so they survive. This collapses\n * near-duplicates such as a standalone \"© OpenStreetMap\" when a CARTO string\n * that already links OpenStreetMap is present.\n *\n * Subsumption is checked against each kept attribution *individually* (never a\n * merged union), so an entry is only dropped when some single earlier entry\n * fully covers it. This avoids false positives where two unrelated providers'\n * tokens together happen to cover a distinct third provider.\n */\nexport function dedupeBasemapAttributions(attributions: string[]): string[] {\n  const kept: string[] = [];\n  const keptTokens: Set<string>[] = [];\n  attributions.forEach(attribution => {\n    const sig = attributionSignature(attribution);\n    if (sig.size === 0) {\n      // nothing to compare on; keep as-is (exact dedup already done upstream)\n      if (!kept.includes(attribution)) {\n        kept.push(attribution);\n        keptTokens.push(sig);\n      }\n      return;\n    }\n    // subsumed only if some single kept attribution's tokens are a superset\n    const isSubsumed = keptTokens.some(\n      tokens => tokens.size > 0 && [...sig].every(t => tokens.has(t))\n    );\n    if (!isSubsumed) {\n      kept.push(attribution);\n      keptTokens.push(sig);\n    }\n  });\n  return kept;\n}\n\n/**\n * Render a list of items as `| item | item ...` fragments, each preceded by a\n * pipe separator. Keys are index-based (safe even when item content collides,\n * e.g. two globe attributions sharing a label). Returns null when empty so\n * callers can `{group}` inline.\n */\nfunction renderSeparatedLinks<T>(\n  items: T[],\n  keyPrefix: string,\n  renderItem: (item: T, index: number) => React.ReactNode\n): React.ReactNode {\n  if (!items.length) return null;\n  return (\n    <>\n      {items.map((item, idx) => (\n        <React.Fragment key={`${keyPrefix}-${idx}`}>\n          <span className=\"pipe-separator\">|</span>\n          {renderItem(item, idx)}\n        </React.Fragment>\n      ))}\n    </>\n  );\n}\n\nexport const Attribution: React.FC<AttributionProps> = ({\n  showBaseMapLibLogo = true,\n  basemapAttributions = [],\n  datasetAttributions,\n  baseMapLibraryConfig,\n  globeAttributions = []\n}: AttributionProps) => {\n  const isPalm = hasMobileWidth(breakPointValues);\n\n  const memoizedComponents = useMemo(() => {\n    // collapse near-duplicate attributions (e.g. a standalone OSM link when a\n    // CARTO string already links OSM) before rendering\n    const dedupedBasemapAttributions = dedupeBasemapAttributions(basemapAttributions);\n    // attributions declared by custom basemap styles, rendered as safe links\n    const basemapAttributionNodes = renderSeparatedLinks(\n      dedupedBasemapAttributions,\n      'basemap-attr',\n      (attribution, idx) => (\n        <span className=\"basemap-attribution\">\n          {renderBasemapAttribution(attribution, `basemap-attr-${idx}`)}\n        </span>\n      )\n    );\n\n    const globeAttributionNodes = renderSeparatedLinks(globeAttributions, 'globe-attr', attr => (\n      <a href={attr.href} target=\"_blank\" rel=\"noopener noreferrer\">\n        {attr.label}\n      </a>\n    ));\n\n    if (!showBaseMapLibLogo) {\n      return (\n        <StyledAttribution\n          mapLibCssClass={baseMapLibraryConfig.mapLibCssClass}\n          mapLibAttributionCssClass={baseMapLibraryConfig.mapLibAttributionCssClass}\n          showLogo={globeAttributions.length > 0}\n        >\n          <EndHorizontalFlexbox>\n            <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n            <div className=\"attrition-link\">\n              {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n              {globeAttributions.length && isPalm ? (\n                <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} />\n              ) : null}\n              <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n                © kepler.gl\n              </a>\n              {basemapAttributionNodes}\n              {globeAttributionNodes}\n              {globeAttributions.length ? <span className=\"pipe-separator\">|</span> : null}\n              {globeAttributions.length && !isPalm ? (\n                <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} />\n              ) : null}\n            </div>\n          </EndHorizontalFlexbox>\n        </StyledAttribution>\n      );\n    }\n\n    return (\n      <StyledAttribution\n        mapLibCssClass={baseMapLibraryConfig.mapLibCssClass}\n        mapLibAttributionCssClass={baseMapLibraryConfig.mapLibAttributionCssClass}\n        showLogo={true}\n      >\n        <EndHorizontalFlexbox>\n          <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n          <div className=\"attrition-link\">\n            {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n            {isPalm ? <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} /> : null}\n            <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n              © kepler.gl\n            </a>\n            {basemapAttributionNodes}\n            {globeAttributionNodes}\n            <span className=\"pipe-separator\">|</span>\n            {!isPalm ? <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} /> : null}\n          </div>\n        </EndHorizontalFlexbox>\n      </StyledAttribution>\n    );\n  }, [\n    showBaseMapLibLogo,\n    basemapAttributions,\n    datasetAttributions,\n    isPalm,\n    baseMapLibraryConfig,\n    globeAttributions\n  ]);\n\n  return memoizedComponents;\n};\n\nconst StyledAttributionLogoContainer = styled.div<{$left: number}>`\n  position: absolute;\n  bottom: ${props => props.theme.sidePanel.margin.left}px;\n  left: ${props => props.$left}px;\n  z-index: 1;\n  display: flex;\n  align-items: flex-end;\n  gap: 4px;\n  pointer-events: auto;\n  transition: left 250ms ease-in-out;\n`;\n\nconst StyledLogoLink = styled.a<{$enabled: boolean}>`\n  cursor: ${props => (props.$enabled ? 'pointer' : 'default')};\n  display: flex;\n  align-items: flex-end;\n`;\n\ntype AttributionLogosProps = {\n  logos: AttributionWithStyle[];\n  activeSidePanel?: boolean;\n  sidePanelWidth?: number;\n};\n\nconst LOGO_LEFT_ADJUSTMENT = 3;\n\nexport const AttributionLogos: React.FC<AttributionLogosProps> = ({\n  logos,\n  activeSidePanel,\n  sidePanelWidth\n}) => {\n  const theme = useTheme() as any;\n  const left =\n    (activeSidePanel ? (sidePanelWidth || 0) + LOGO_LEFT_ADJUSTMENT : 0) +\n    theme.sidePanel.margin.left;\n\n  if (!logos?.length) return null;\n  return (\n    <StyledAttributionLogoContainer $left={left}>\n      {logos.map((logo, idx) => (\n        <StyledLogoLink\n          key={logo.logoUrl || idx}\n          href={logo.url || undefined}\n          {...(logo.url ? {target: '_blank', rel: 'noopener noreferrer'} : {})}\n          $enabled={Boolean(logo.url)}\n          style={logo.bottom ? {marginBottom: logo.bottom} : undefined}\n        >\n          <img src={logo.logoUrl} style={{height: logo.height || 12}} alt={logo.title} />\n        </StyledLogoLink>\n      ))}\n    </StyledAttributionLogoContainer>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;AAGA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAF,uBAAA,CAAAC,OAAA;AAGA,IAAAE,MAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AAGA,IAAAI,kBAAA,GAAAJ,OAAA;AAAoF,IAAAK,eAAA,EAAAC,gBAAA,EAAAC,gBAAA,EAXpF;AACA;AAAA,SAAAR,wBAAAS,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAX,uBAAA,YAAAA,wBAAAS,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,mBAAAT,CAAA,iBAAAA,CAAA,gBAAAU,OAAA,CAAAV,CAAA,0BAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,cAAAM,EAAA,IAAAd,CAAA,gBAAAc,EAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,EAAA,OAAAP,CAAA,IAAAD,CAAA,GAAAW,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAnB,CAAA,EAAAc,EAAA,OAAAP,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAM,EAAA,EAAAP,CAAA,IAAAC,CAAA,CAAAM,EAAA,IAAAd,CAAA,CAAAc,EAAA,WAAAN,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAgBO,IAAMmB,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAG,SAAbA,UAAUA,CAAAE,IAAA;EAAA,IAAKC,oBAAoB,GAAAD,IAAA,CAApBC,oBAAoB;EAAA,oBAC9CjC,MAAA,YAAAkC,aAAA;IAAKC,SAAS,EAAC;EAAgB,GAAC,aAE9B,eAAAnC,MAAA,YAAAkC,aAAA;IACEE,KAAK,EAAE;MAACC,UAAU,EAAE;IAAK,CAAE;IAC3BF,SAAS,KAAAG,MAAA,CAAKL,oBAAoB,CAACM,cAAc,eAAa;IAC9DC,MAAM,EAAC,QAAQ;IACfC,GAAG,EAAC,qBAAqB;IACzBC,IAAI,EAAET,oBAAoB,CAACU,SAAU;IACrC,iBAAAL,MAAA,CAAeL,oBAAoB,CAACW,UAAU;EAAQ,CACvD,CACE,CAAC;AAAA,CACP;AAMD,IAAMC,kCAAkC,GAAGC,4BAAM,CAACC,GAAG,CAAAxC,eAAA,KAAAA,eAAA,OAAAyC,uBAAA,sPACtC,UAAAC,KAAK;EAAA,OAAKA,KAAK,CAACC,MAAM,GAAG,OAAO,GAAG,OAAO;AAAA,CAAC,EAI/C,UAAAD,KAAK;EAAA,OAAIA,KAAK,CAACE,KAAK,CAACC,UAAU;AAAA,GAGzB,UAAAH,KAAK;EAAA,OAAKA,KAAK,CAACC,MAAM,GAAG,KAAK,GAAG,OAAO;AAAA,CAAC,CAKzD;AAEM,IAAMG,mBAAmB,GAAAtB,OAAA,CAAAsB,mBAAA,GAAG,SAAtBA,mBAAmBA,CAAAC,KAAA;EAAA,IAC9BC,mBAAmB,GAAAD,KAAA,CAAnBC,mBAAmB;IACnBL,MAAM,GAAAI,KAAA,CAANJ,MAAM;EAAA,oBAKNlD,MAAA,YAAAkC,aAAA,CAAAlC,MAAA,YAAAwD,QAAA,QACGD,mBAAmB,aAAnBA,mBAAmB,eAAnBA,mBAAmB,CAAEE,MAAM,gBAC1BzD,MAAA,YAAAkC,aAAA,CAACW,kCAAkC;IAACK,MAAM,EAAEA;EAAO,GAChDK,mBAAmB,CAACG,GAAG,CAAC,UAACC,EAAE,EAAEC,GAAG;IAAA,oBAC/B5D,MAAA,YAAAkC,aAAA,UAAA2B,SAAA,iBACOF,EAAE,CAACG,GAAG,GAAG;MAACpB,IAAI,EAAEiB,EAAE,CAACG;IAAG,CAAC,GAAG,IAAI;MACnCtB,MAAM,EAAC,QAAQ;MACfC,GAAG,EAAC,qBAAqB;MACzBsB,GAAG,KAAAzB,MAAA,CAAKqB,EAAE,CAACK,KAAK,OAAA1B,MAAA,CAAIsB,GAAG;IAAG,IAEzBD,EAAE,CAACK,KAAK,EACRJ,GAAG,KAAKL,mBAAmB,CAACE,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,IAChD,CAAC;EAAA,CACL,CACiC,CAAC,GACnC,IACJ,CAAC;AAAA,CACJ;AAUD,IAAMQ,2BAA2B,GAAG,qBAAqB;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,yBAAyBA,CAACC,IAAY,EAAU;EACvD,OAAOA,IAAI,CACRC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CACxBA,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CACxBA,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CACtBA,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CACtBA,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CACxBA,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,CACzBA,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;AAC5B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,SAASA,CAACC,IAAY,EAAU;EACvC,OAAOJ,yBAAyB,CAACI,IAAI,CAACF,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAACG,IAAI,CAAC,CAAC;AACvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,eAAeA,CACtBC,KAA0C,EAC1CC,SAAiB,EACjBC,OAAoB,EACD;EACnB,IAAMC,MAAyB,GAAG,EAAE;EACpCH,KAAK,CAACI,OAAO,CAAC,UAAAC,IAAI,EAAI;IACpB,IAAIA,IAAI,CAACC,QAAQ,KAAK,CAAC,CAAC,iBAAiB;MACvC;MACA;MACA,IAAMZ,IAAI,GAAG,CAACW,IAAI,CAACE,WAAW,IAAI,EAAE,EAAEZ,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC;MAC1D,IAAID,IAAI,EAAE;QACRS,MAAM,CAACK,IAAI,cAACjF,MAAA,YAAAkC,aAAA,CAAClC,MAAA,WAAK,CAACwD,QAAQ;UAACO,GAAG,KAAAzB,MAAA,CAAKoC,SAAS,QAAApC,MAAA,CAAKqC,OAAO,CAAC1D,CAAC,EAAE;QAAG,GAAEkD,IAAqB,CAAC,CAAC;MAC3F;MACA;IACF;IACA,IAAIW,IAAI,CAACC,QAAQ,KAAK,CAAC,CAAC,oBAAoB;MAC1C;IACF;IACA,IAAMG,EAAE,GAAGJ,IAAe;IAC1B,IAAMK,GAAG,GAAGD,EAAE,CAACE,OAAO,CAACC,WAAW,CAAC,CAAC;IACpC;IACA,IAAIF,GAAG,KAAK,QAAQ,IAAIA,GAAG,KAAK,OAAO,IAAIA,GAAG,KAAK,UAAU,IAAIA,GAAG,KAAK,UAAU,EAAE;MACnF;IACF;IACA,IAAIA,GAAG,KAAK,GAAG,EAAE;MACf,IAAMzC,IAAI,GAAGwC,EAAE,CAACI,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE;MAC1C;MACA;MACA,IAAMnB,KAAI,GAAGe,EAAE,CAACF,WAAW,IAAI,EAAE;MACjC,IAAI,CAACb,KAAI,CAACI,IAAI,CAAC,CAAC,EAAE;MAClB,IAAIN,2BAA2B,CAACsB,IAAI,CAAC7C,IAAI,CAAC,EAAE;QAC1CkC,MAAM,CAACK,IAAI,cACTjF,MAAA,YAAAkC,aAAA;UACE6B,GAAG,KAAAzB,MAAA,CAAKoC,SAAS,QAAApC,MAAA,CAAKqC,OAAO,CAAC1D,CAAC,EAAE,CAAG;UACpCyB,IAAI,EAAEA,IAAK;UACXF,MAAM,EAAC,QAAQ;UACfC,GAAG,EAAC;QAAqB,GAExB0B,KACA,CACL,CAAC;MACH,CAAC,MAAM;QACL;QACAS,MAAM,CAACK,IAAI,cAACjF,MAAA,YAAAkC,aAAA,CAAClC,MAAA,WAAK,CAACwD,QAAQ;UAACO,GAAG,KAAAzB,MAAA,CAAKoC,SAAS,QAAApC,MAAA,CAAKqC,OAAO,CAAC1D,CAAC,EAAE;QAAG,GAAEkD,KAAqB,CAAC,CAAC;MAC3F;MACA;IACF;IACA;IACAS,MAAM,CAACK,IAAI,CAAAO,KAAA,CAAXZ,MAAM,MAAAa,mBAAA,aAASjB,eAAe,CAACU,EAAE,CAACQ,UAAU,EAAEhB,SAAS,EAAEC,OAAO,CAAC,EAAC;EACpE,CAAC,CAAC;EACF,OAAOC,MAAM;AACf;AAEA,SAASe,gBAAgBA,CAAA,EAA+B;EACtD,OACG,OAAOC,MAAM,KAAK,WAAW,IAAKA,MAAM,CAASC,SAAS,IAC1D,OAAOC,UAAU,KAAK,WAAW,IAAKA,UAAU,CAASD,SAAU,IACpE,IAAI;AAER;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,wBAAwBA,CAACzB,IAAY,EAAEI,SAAiB,EAAqB;EAC3F,IAAMsB,aAAa,GAAGL,gBAAgB,CAAC,CAAC;EACxC,IAAI,CAACK,aAAa,EAAE;IAClB,IAAM7B,IAAI,GAAGE,SAAS,CAACC,IAAI,CAAC;IAC5B,OAAOH,IAAI,GAAG,cAACnE,MAAA,YAAAkC,aAAA,CAAClC,MAAA,WAAK,CAACwD,QAAQ;MAACO,GAAG,KAAAzB,MAAA,CAAKoC,SAAS;IAAM,GAAEP,IAAqB,CAAC,CAAC,GAAG,EAAE;EACtF;EACA,IAAI;IACF,IAAM8B,GAAG,GAAG,IAAID,aAAa,CAAC,CAAC,CAACE,eAAe,CAAC5B,IAAI,EAAE,WAAW,CAAC;IAClE,OAAOE,eAAe,CAACyB,GAAG,CAACE,IAAI,CAACT,UAAU,EAAEhB,SAAS,EAAE;MAACzD,CAAC,EAAE;IAAC,CAAC,CAAC,CAACmF,MAAM,CAACC,OAAO,CAAC;EAChF,CAAC,CAAC,OAAAC,OAAA,EAAM;IACN,IAAMnC,MAAI,GAAGE,SAAS,CAACC,IAAI,CAAC;IAC5B,OAAOH,MAAI,GAAG,cAACnE,MAAA,YAAAkC,aAAA,CAAClC,MAAA,WAAK,CAACwD,QAAQ;MAACO,GAAG,KAAAzB,MAAA,CAAKoC,SAAS;IAAM,GAAEP,MAAqB,CAAC,CAAC,GAAG,EAAE;EACtF;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASoC,oBAAoBA,CAACjC,IAAY,EAAe;EACvD,IAAMkC,MAAM,GAAG,IAAIC,GAAG,CAAS,CAAC;EAChC,IAAMT,aAAa,GAAGL,gBAAgB,CAAC,CAAC;EACxC,IAAIxB,IAAI,GAAGG,IAAI;EACf,IAAI0B,aAAa,EAAE;IACjB,IAAI;MACF,IAAMC,GAAG,GAAG,IAAID,aAAa,CAAC,CAAC,CAACE,eAAe,CAAC5B,IAAI,EAAE,WAAW,CAAC;MAClE2B,GAAG,CAACE,IAAI,CAACO,gBAAgB,CAAC,GAAG,CAAC,CAAC7B,OAAO,CAAC,UAAA8B,CAAC,EAAI;QAC1C,IAAMjE,IAAI,GAAGiE,CAAC,CAACrB,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE;QACzC,IAAIrB,2BAA2B,CAACsB,IAAI,CAAC7C,IAAI,CAAC,EAAE;UAC1C,IAAI;YACF8D,MAAM,CAACI,GAAG,SAAAtE,MAAA,CAAS,IAAIuE,GAAG,CAACnE,IAAI,CAAC,CAACoE,QAAQ,CAAC1C,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAACiB,WAAW,CAAC,CAAC,CAAE,CAAC;UAClF,CAAC,CAAC,OAAA0B,QAAA,EAAM;YACNP,MAAM,CAACI,GAAG,SAAAtE,MAAA,CAASI,IAAI,CAAC2C,WAAW,CAAC,CAAC,CAAE,CAAC;UAC1C;QACF;MACF,CAAC,CAAC;MACFlB,IAAI,GAAG8B,GAAG,CAACE,IAAI,CAACnB,WAAW,IAAI,EAAE;IACnC,CAAC,CAAC,OAAAgC,QAAA,EAAM;MACN7C,IAAI,GAAGE,SAAS,CAACC,IAAI,CAAC;IACxB;EACF,CAAC,MAAM;IACLH,IAAI,GAAGE,SAAS,CAACC,IAAI,CAAC;EACxB;EACA,IAAM2C,UAAU,GAAG9C,IAAI,CACpBkB,WAAW,CAAC,CAAC,CACbjB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CACxBA,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CACjCA,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,CAC3BG,IAAI,CAAC,CAAC;EACT,IAAI0C,UAAU,EAAE;IACd;IACA;IACA;IACAA,UAAU,CAACC,KAAK,CAAC,GAAG,CAAC,CAACrC,OAAO,CAAC,UAAAsC,IAAI,EAAI;MACpC,IAAIA,IAAI,EAAEX,MAAM,CAACI,GAAG,SAAAtE,MAAA,CAAS6E,IAAI,CAAE,CAAC;IACtC,CAAC,CAAC;EACJ;EACA,OAAOX,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASY,yBAAyBA,CAACC,YAAsB,EAAY;EAC1E,IAAMC,IAAc,GAAG,EAAE;EACzB,IAAMC,UAAyB,GAAG,EAAE;EACpCF,YAAY,CAACxC,OAAO,CAAC,UAAA2C,WAAW,EAAI;IAClC,IAAMC,GAAG,GAAGlB,oBAAoB,CAACiB,WAAW,CAAC;IAC7C,IAAIC,GAAG,CAACC,IAAI,KAAK,CAAC,EAAE;MAClB;MACA,IAAI,CAACJ,IAAI,CAACK,QAAQ,CAACH,WAAW,CAAC,EAAE;QAC/BF,IAAI,CAACrC,IAAI,CAACuC,WAAW,CAAC;QACtBD,UAAU,CAACtC,IAAI,CAACwC,GAAG,CAAC;MACtB;MACA;IACF;IACA;IACA,IAAMG,UAAU,GAAGL,UAAU,CAACM,IAAI,CAChC,UAAArB,MAAM;MAAA,OAAIA,MAAM,CAACkB,IAAI,GAAG,CAAC,IAAI,IAAAjC,mBAAA,aAAIgC,GAAG,EAAEK,KAAK,CAAC,UAAAnH,CAAC;QAAA,OAAI6F,MAAM,CAACnF,GAAG,CAACV,CAAC,CAAC;MAAA,EAAC;IAAA,CACjE,CAAC;IACD,IAAI,CAACiH,UAAU,EAAE;MACfN,IAAI,CAACrC,IAAI,CAACuC,WAAW,CAAC;MACtBD,UAAU,CAACtC,IAAI,CAACwC,GAAG,CAAC;IACtB;EACF,CAAC,CAAC;EACF,OAAOH,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASS,oBAAoBA,CAC3BC,KAAU,EACVtD,SAAiB,EACjBuD,UAAuD,EACtC;EACjB,IAAI,CAACD,KAAK,CAACvE,MAAM,EAAE,OAAO,IAAI;EAC9B,oBACEzD,MAAA,YAAAkC,aAAA,CAAAlC,MAAA,YAAAwD,QAAA,QACGwE,KAAK,CAACtE,GAAG,CAAC,UAACwE,IAAI,EAAEtE,GAAG;IAAA,oBACnB5D,MAAA,YAAAkC,aAAA,CAAClC,MAAA,WAAK,CAACwD,QAAQ;MAACO,GAAG,KAAAzB,MAAA,CAAKoC,SAAS,OAAApC,MAAA,CAAIsB,GAAG;IAAG,gBACzC5D,MAAA,YAAAkC,aAAA;MAAMC,SAAS,EAAC;IAAgB,GAAC,GAAO,CAAC,EACxC8F,UAAU,CAACC,IAAI,EAAEtE,GAAG,CACP,CAAC;EAAA,CAClB,CACD,CAAC;AAEP;AAEO,IAAMuE,WAAuC,GAAApG,OAAA,CAAAoG,WAAA,GAAG,SAA1CA,WAAuCA,CAAAC,KAAA,EAM5B;EAAA,IAAAC,qBAAA,GAAAD,KAAA,CALtBE,kBAAkB;IAAlBA,kBAAkB,GAAAD,qBAAA,cAAG,IAAI,GAAAA,qBAAA;IAAAE,qBAAA,GAAAH,KAAA,CACzBI,mBAAmB;IAAnBA,mBAAmB,GAAAD,qBAAA,cAAG,EAAE,GAAAA,qBAAA;IACxBhF,mBAAmB,GAAA6E,KAAA,CAAnB7E,mBAAmB;IACnBtB,oBAAoB,GAAAmG,KAAA,CAApBnG,oBAAoB;IAAAwG,qBAAA,GAAAL,KAAA,CACpBM,iBAAiB;IAAjBA,iBAAiB,GAAAD,qBAAA,cAAG,EAAE,GAAAA,qBAAA;EAEtB,IAAMvF,MAAM,GAAG,IAAAyF,qBAAc,EAACC,wBAAgB,CAAC;EAE/C,IAAMC,kBAAkB,GAAG,IAAAC,cAAO,EAAC,YAAM;IACvC;IACA;IACA,IAAMC,0BAA0B,GAAG3B,yBAAyB,CAACoB,mBAAmB,CAAC;IACjF;IACA,IAAMQ,uBAAuB,GAAGjB,oBAAoB,CAClDgB,0BAA0B,EAC1B,cAAc,EACd,UAACvB,WAAW,EAAE5D,GAAG;MAAA,oBACf5D,MAAA,YAAAkC,aAAA;QAAMC,SAAS,EAAC;MAAqB,GAClC4D,wBAAwB,CAACyB,WAAW,kBAAAlF,MAAA,CAAkBsB,GAAG,CAAE,CACxD,CAAC;IAAA,CAEX,CAAC;IAED,IAAMqF,qBAAqB,GAAGlB,oBAAoB,CAACW,iBAAiB,EAAE,YAAY,EAAE,UAAAQ,IAAI;MAAA,oBACtFlJ,MAAA,YAAAkC,aAAA;QAAGQ,IAAI,EAAEwG,IAAI,CAACxG,IAAK;QAACF,MAAM,EAAC,QAAQ;QAACC,GAAG,EAAC;MAAqB,GAC1DyG,IAAI,CAACC,KACL,CAAC;IAAA,CACL,CAAC;IAEF,IAAI,CAACb,kBAAkB,EAAE;MACvB,oBACEtI,MAAA,YAAAkC,aAAA,CAAC5B,kBAAA,CAAA8I,iBAAiB;QAChB7G,cAAc,EAAEN,oBAAoB,CAACM,cAAe;QACpD8G,yBAAyB,EAAEpH,oBAAoB,CAACoH,yBAA0B;QAC1EC,QAAQ,EAAEZ,iBAAiB,CAACjF,MAAM,GAAG;MAAE,gBAEvCzD,MAAA,YAAAkC,aAAA,CAAC5B,kBAAA,CAAAiJ,oBAAoB,qBACnBvJ,MAAA,YAAAkC,aAAA,CAACmB,mBAAmB;QAACE,mBAAmB,EAAEA,mBAAoB;QAACL,MAAM,EAAEA;MAAO,CAAE,CAAC,eACjFlD,MAAA,YAAAkC,aAAA;QAAKC,SAAS,EAAC;MAAgB,GAC5BoB,mBAAmB,aAAnBA,mBAAmB,eAAnBA,mBAAmB,CAAEE,MAAM,gBAAGzD,MAAA,YAAAkC,aAAA;QAAMC,SAAS,EAAC;MAAgB,GAAC,GAAO,CAAC,GAAG,IAAI,EAC9EuG,iBAAiB,CAACjF,MAAM,IAAIP,MAAM,gBACjClD,MAAA,YAAAkC,aAAA,CAACJ,UAAU;QAACG,oBAAoB,EAAEA;MAAqB,CAAE,CAAC,GACxD,IAAI,eACRjC,MAAA,YAAAkC,aAAA;QAAGQ,IAAI,EAAC,2BAA2B;QAACF,MAAM,EAAC,QAAQ;QAACC,GAAG,EAAC;MAAqB,GAAC,gBAE3E,CAAC,EACHuG,uBAAuB,EACvBC,qBAAqB,EACrBP,iBAAiB,CAACjF,MAAM,gBAAGzD,MAAA,YAAAkC,aAAA;QAAMC,SAAS,EAAC;MAAgB,GAAC,GAAO,CAAC,GAAG,IAAI,EAC3EuG,iBAAiB,CAACjF,MAAM,IAAI,CAACP,MAAM,gBAClClD,MAAA,YAAAkC,aAAA,CAACJ,UAAU;QAACG,oBAAoB,EAAEA;MAAqB,CAAE,CAAC,GACxD,IACD,CACe,CACL,CAAC;IAExB;IAEA,oBACEjC,MAAA,YAAAkC,aAAA,CAAC5B,kBAAA,CAAA8I,iBAAiB;MAChB7G,cAAc,EAAEN,oBAAoB,CAACM,cAAe;MACpD8G,yBAAyB,EAAEpH,oBAAoB,CAACoH,yBAA0B;MAC1EC,QAAQ,EAAE;IAAK,gBAEftJ,MAAA,YAAAkC,aAAA,CAAC5B,kBAAA,CAAAiJ,oBAAoB,qBACnBvJ,MAAA,YAAAkC,aAAA,CAACmB,mBAAmB;MAACE,mBAAmB,EAAEA,mBAAoB;MAACL,MAAM,EAAEA;IAAO,CAAE,CAAC,eACjFlD,MAAA,YAAAkC,aAAA;MAAKC,SAAS,EAAC;IAAgB,GAC5BoB,mBAAmB,aAAnBA,mBAAmB,eAAnBA,mBAAmB,CAAEE,MAAM,gBAAGzD,MAAA,YAAAkC,aAAA;MAAMC,SAAS,EAAC;IAAgB,GAAC,GAAO,CAAC,GAAG,IAAI,EAC9Ee,MAAM,gBAAGlD,MAAA,YAAAkC,aAAA,CAACJ,UAAU;MAACG,oBAAoB,EAAEA;IAAqB,CAAE,CAAC,GAAG,IAAI,eAC3EjC,MAAA,YAAAkC,aAAA;MAAGQ,IAAI,EAAC,2BAA2B;MAACF,MAAM,EAAC,QAAQ;MAACC,GAAG,EAAC;IAAqB,GAAC,gBAE3E,CAAC,EACHuG,uBAAuB,EACvBC,qBAAqB,eACtBjJ,MAAA,YAAAkC,aAAA;MAAMC,SAAS,EAAC;IAAgB,GAAC,GAAO,CAAC,EACxC,CAACe,MAAM,gBAAGlD,MAAA,YAAAkC,aAAA,CAACJ,UAAU;MAACG,oBAAoB,EAAEA;IAAqB,CAAE,CAAC,GAAG,IACrE,CACe,CACL,CAAC;EAExB,CAAC,EAAE,CACDqG,kBAAkB,EAClBE,mBAAmB,EACnBjF,mBAAmB,EACnBL,MAAM,EACNjB,oBAAoB,EACpByG,iBAAiB,CAClB,CAAC;EAEF,OAAOG,kBAAkB;AAC3B,CAAC;AAED,IAAMW,8BAA8B,GAAG1G,4BAAM,CAACC,GAAG,CAAAvC,gBAAA,KAAAA,gBAAA,OAAAwC,uBAAA,0NAErC,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACE,KAAK,CAACsG,SAAS,CAACC,MAAM,CAACC,IAAI;AAAA,GAC5C,UAAA1G,KAAK;EAAA,OAAIA,KAAK,CAAC2G,KAAK;AAAA,EAO7B;AAED,IAAMC,cAAc,GAAG/G,4BAAM,CAAC6D,CAAC,CAAAlG,gBAAA,KAAAA,gBAAA,OAAAuC,uBAAA,oFACnB,UAAAC,KAAK;EAAA,OAAKA,KAAK,CAAC6G,QAAQ,GAAG,SAAS,GAAG,SAAS;AAAA,CAAC,CAG5D;AAQD,IAAMC,oBAAoB,GAAG,CAAC;AAEvB,IAAMC,gBAAiD,GAAAjI,OAAA,CAAAiI,gBAAA,GAAG,SAApDA,gBAAiDA,CAAAC,KAAA,EAIxD;EAAA,IAHJC,KAAK,GAAAD,KAAA,CAALC,KAAK;IACLC,eAAe,GAAAF,KAAA,CAAfE,eAAe;IACfC,cAAc,GAAAH,KAAA,CAAdG,cAAc;EAEd,IAAMjH,KAAK,GAAG,IAAAkH,0BAAQ,EAAC,CAAQ;EAC/B,IAAMV,IAAI,GACR,CAACQ,eAAe,GAAG,CAACC,cAAc,IAAI,CAAC,IAAIL,oBAAoB,GAAG,CAAC,IACnE5G,KAAK,CAACsG,SAAS,CAACC,MAAM,CAACC,IAAI;EAE7B,IAAI,EAACO,KAAK,aAALA,KAAK,eAALA,KAAK,CAAEzG,MAAM,GAAE,OAAO,IAAI;EAC/B,oBACEzD,MAAA,YAAAkC,aAAA,CAACsH,8BAA8B;IAACI,KAAK,EAAED;EAAK,GACzCO,KAAK,CAACxG,GAAG,CAAC,UAAC4G,IAAI,EAAE1G,GAAG;IAAA,oBACnB5D,MAAA,YAAAkC,aAAA,CAAC2H,cAAc,MAAAhG,SAAA;MACbE,GAAG,EAAEuG,IAAI,CAACC,OAAO,IAAI3G,GAAI;MACzBlB,IAAI,EAAE4H,IAAI,CAACxG,GAAG,IAAI0G;IAAU,GACvBF,IAAI,CAACxG,GAAG,GAAG;MAACtB,MAAM,EAAE,QAAQ;MAAEC,GAAG,EAAE;IAAqB,CAAC,GAAG,CAAC,CAAC;MACnEqH,QAAQ,EAAEzD,OAAO,CAACiE,IAAI,CAACxG,GAAG,CAAE;MAC5B1B,KAAK,EAAEkI,IAAI,CAACG,MAAM,GAAG;QAACC,YAAY,EAAEJ,IAAI,CAACG;MAAM,CAAC,GAAGD;IAAU,iBAE7DxK,MAAA,YAAAkC,aAAA;MAAKyI,GAAG,EAAEL,IAAI,CAACC,OAAQ;MAACnI,KAAK,EAAE;QAACwI,MAAM,EAAEN,IAAI,CAACM,MAAM,IAAI;MAAE,CAAE;MAACC,GAAG,EAAEP,IAAI,CAACtG;IAAM,CAAE,CAChE,CAAC;EAAA,CAClB,CAC6B,CAAC;AAErC,CAAC","ignoreList":[]}

package/dist/cjs/map/coordinate-info.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _utils = require("@kepler.gl/utils");
+var _icons = require("../common/icons");
+var _layerHoverInfo = require("./layer-hover-info");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// 6th decimal is worth up to 0.11 m
+// https://gis.stackexchange.com/questions/8650/measuring-accuracy-of-latitude-and-longitude
+var DECIMAL = 6;
+var DECIMAL_Z = 1;
+var CoordinateInfoFactory = function CoordinateInfoFactory() {
+  var CoordinateInfo = function CoordinateInfo(_ref) {
+    var coordinate = _ref.coordinate,
+      zoom = _ref.zoom;
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "coordingate-hover-info"
+    }, /*#__PURE__*/_react["default"].createElement(_layerHoverInfo.StyledLayerName, {
+      className: "map-popover__layer-name"
+    }, /*#__PURE__*/_react["default"].createElement(_icons.CursorClick, {
+      height: "12px"
+    }), "Coordinate"), /*#__PURE__*/_react["default"].createElement("table", null, /*#__PURE__*/_react["default"].createElement("tbody", null, /*#__PURE__*/_react["default"].createElement("tr", {
+      className: "row"
+    }, /*#__PURE__*/_react["default"].createElement("td", {
+      className: "row__value"
+    }, (0, _utils.preciseRound)(coordinate[1], DECIMAL), ","), /*#__PURE__*/_react["default"].createElement("td", {
+      className: "row__value"
+    }, (0, _utils.preciseRound)(coordinate[0], DECIMAL), ","), /*#__PURE__*/_react["default"].createElement("td", {
+      className: "row__value"
+    }, (0, _utils.preciseRound)(zoom, DECIMAL_Z), "z")))));
+  };
+  return CoordinateInfo;
+};
+var _default = exports["default"] = CoordinateInfoFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cjs/map/effects/effect-control.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = EffectControlFactory;
+var _react = _interopRequireWildcard(require("react"));
+var _icons = require("../../common/icons");
+var _styledComponents = require("../../common/styled-components");
+var _mapControlTooltip = _interopRequireDefault(require("../map-control-tooltip"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+EffectControlFactory.deps = [_mapControlTooltip["default"]];
+function EffectControlFactory(MapControlTooltip) {
+  var defaultActionIcons = {
+    effectsIcon: _icons.MagicWand
+  };
+  var EffectControl = function EffectControl(_ref) {
+    var _mapControls$effect, _mapControls$effect2;
+    var mapControls = _ref.mapControls,
+      onToggleMapControl = _ref.onToggleMapControl,
+      _ref$actionIcons = _ref.actionIcons,
+      actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    var onClick = (0, _react.useCallback)(function (event) {
+      event.preventDefault();
+      onToggleMapControl('effect');
+    }, [onToggleMapControl]);
+    var showControl = mapControls === null || mapControls === void 0 || (_mapControls$effect = mapControls.effect) === null || _mapControls$effect === void 0 ? void 0 : _mapControls$effect.show;
+    if (!showControl) {
+      return null;
+    }
+    var active = mapControls === null || mapControls === void 0 || (_mapControls$effect2 = mapControls.effect) === null || _mapControls$effect2 === void 0 ? void 0 : _mapControls$effect2.active;
+    return /*#__PURE__*/_react["default"].createElement(MapControlTooltip, {
+      id: "show-effect",
+      message: active ? 'tooltip.hideEffectPanel' : 'tooltip.showEffectPanel'
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents.MapControlButton, {
+      className: "map-control-button toggle-effect",
+      onClick: onClick,
+      active: active
+    }, /*#__PURE__*/_react["default"].createElement(actionIcons.effectsIcon, {
+      height: "22px"
+    })));
+  };
+  EffectControl.displayName = 'EffectControl';
+  return /*#__PURE__*/_react["default"].memo(EffectControl);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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