@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/common/portaled.js

@@ -0,0 +1,280 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+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, { Component, createRef } from 'react';
+import debounce from 'lodash/debounce';
+import isEqual from 'lodash/isEqual';
+import { canUseDOM } from 'exenv';
+import { withTheme } from 'styled-components';
+import { RootContext } from '../context';
+import Modal from 'react-modal';
+import Window from 'global/window';
+import { theme } from '@kepler.gl/styles';
+var listeners = {};
+var startListening = function startListening() {
+  return Object.keys(listeners).forEach(function (key) {
+    return listeners[key]();
+  });
+};
+var getPageOffset = function getPageOffset() {
+  return {
+    x: Window.pageXOffset !== undefined ? Window.pageXOffset : (document.documentElement || document.body.parentNode || document.body).scrollLeft,
+    y: Window.pageYOffset !== undefined ? Window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop
+  };
+};
+var addEventListeners = function addEventListeners() {
+  if (document && document.body) document.body.addEventListener('mousewheel', debounce(startListening, 100, {
+    leading: true
+  }));
+  Window.addEventListener('resize', debounce(startListening, 50, {
+    leading: true
+  }));
+};
+export var getChildPos = function getChildPos(_ref) {
+  var offsets = _ref.offsets,
+    rect = _ref.rect,
+    childRect = _ref.childRect,
+    pageOffset = _ref.pageOffset,
+    padding = _ref.padding;
+  var topOffset = offsets.topOffset,
+    leftOffset = offsets.leftOffset,
+    rightOffset = offsets.rightOffset;
+  var anchorLeft = leftOffset !== undefined;
+  var pos = _objectSpread({
+    top: pageOffset.y + rect.top + (topOffset || 0)
+  }, anchorLeft ? {
+    left: pageOffset.x + rect.left + (leftOffset || 0)
+  } : {
+    right: Window.innerWidth - rect.right - pageOffset.x + (rightOffset || 0)
+  });
+  var leftOrRight = anchorLeft ? 'left' : 'right';
+  if (pos[leftOrRight] && pos[leftOrRight] < 0) {
+    pos[leftOrRight] = padding;
+  } else if (pos[leftOrRight] && pos[leftOrRight] + childRect.width > Window.innerWidth) {
+    pos[leftOrRight] = Window.innerWidth - childRect.width - padding;
+  }
+  if (pos.top < 0) {
+    pos.top = padding;
+  } else if (pos.top + childRect.height > Window.innerHeight) {
+    pos.top = Window.innerHeight - childRect.height - padding;
+  }
+  return pos;
+};
+if (canUseDOM) {
+  if (document.body) {
+    addEventListeners();
+  } else {
+    document.addEventListener('DOMContentLoaded', addEventListeners);
+  }
+}
+var listenerIdCounter = 0;
+function subscribe(fn) {
+  listenerIdCounter += 1;
+  var id = listenerIdCounter;
+  listeners[id] = fn;
+  return function () {
+    return delete listeners[id];
+  };
+}
+var defaultModalStyle = {
+  content: {
+    top: 0,
+    left: 0,
+    border: 0,
+    right: 'auto',
+    bottom: 'auto',
+    padding: '0px 0px 0px 0px'
+  },
+  overlay: {
+    right: 'auto',
+    bottom: 'auto',
+    width: '100vw',
+    height: '100vh',
+    backgroundColor: 'rgba(0, 0, 0, 0)'
+  }
+};
+var WINDOW_PAD = 40;
+var noop = function noop() {
+  return;
+};
+var DefaultComponent = 'div';
+var Portaled = /*#__PURE__*/function (_Component) {
+  function Portaled() {
+    var _this;
+    _classCallCheck(this, Portaled);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Portaled, [].concat(args));
+    _defineProperty(_this, "state", {
+      pos: null,
+      isVisible: false
+    });
+    _defineProperty(_this, "unsubscribe", undefined);
+    _defineProperty(_this, "_unmounted", false);
+    _defineProperty(_this, "element", /*#__PURE__*/createRef());
+    _defineProperty(_this, "child", /*#__PURE__*/createRef());
+    // eslint-disable-next-line complexity
+    _defineProperty(_this, "handleScroll", function () {
+      if (_this.child.current && _this.element.current) {
+        var rect = _this.element.current.getBoundingClientRect();
+        var childRect = _this.child.current.getBoundingClientRect();
+        var pageOffset = getPageOffset();
+        var _this$props = _this.props,
+          topOffset = _this$props.top,
+          _this$props$left = _this$props.left,
+          leftOffset = _this$props$left === void 0 ? 0 : _this$props$left,
+          rightOffset = _this$props.right;
+        var pos = getChildPos({
+          offsets: {
+            topOffset: topOffset,
+            leftOffset: leftOffset,
+            rightOffset: rightOffset
+          },
+          rect: rect,
+          childRect: childRect,
+          pageOffset: pageOffset,
+          padding: WINDOW_PAD
+        });
+        if (!isEqual(pos, _this.state.pos)) {
+          _this.setState({
+            pos: pos
+          });
+        }
+      }
+    });
+    return _this;
+  }
+  _inherits(Portaled, _Component);
+  return _createClass(Portaled, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._unmounted = false;
+      // relative
+      this.unsubscribe = subscribe(this.handleScroll);
+      this.handleScroll();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this2 = this;
+      var didOpen = this.props.isOpened && !prevProps.isOpened;
+      var didClose = !this.props.isOpened && prevProps.isOpened;
+      if (didOpen || didClose) {
+        Window.requestAnimationFrame(function () {
+          if (_this2._unmounted) return;
+          _this2.setState({
+            isVisible: Boolean(didOpen)
+          });
+        });
+      }
+      this.handleScroll();
+    }
+
+    // ColorPicker will throw a cross-origin error when it is closed
+    // when the app is within an iframe.
+    // This is a known issue of react-color component:
+    // see: https://github.com/casesandberg/react-color/issues/806
+  }, {
+    key: "componentDidCatch",
+    value: function componentDidCatch() {
+      // Do nothing here, since React will try to recreate this component
+      // tree from scratch using the error boundary, which is this component
+      // itself. This is a temporal fix for a crash.
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._unmounted = true;
+      // @ts-ignore
+      this.unsubscribe();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      var _this$props2 = this.props,
+        _this$props2$componen = _this$props2.component,
+        component = _this$props2$componen === void 0 ? DefaultComponent : _this$props2$componen,
+        overlayZIndex = _this$props2.overlayZIndex,
+        isOpened = _this$props2.isOpened,
+        onClose = _this$props2.onClose,
+        children = _this$props2.children,
+        modalProps = _this$props2.modalProps,
+        _this$props2$modalSty = _this$props2.modalStyle,
+        modalStyle = _this$props2$modalSty === void 0 ? {} : _this$props2$modalSty;
+      var _this$state = this.state,
+        isVisible = _this$state.isVisible,
+        pos = _this$state.pos;
+      var newModalStyle = _objectSpread(_objectSpread({}, defaultModalStyle), {}, {
+        content: _objectSpread({}, modalStyle.content || {}),
+        overlay: _objectSpread(_objectSpread(_objectSpread({}, defaultModalStyle.overlay), modalStyle.overlay || {}), {}, {
+          // needs to be on top of existing modal
+          zIndex: overlayZIndex || 9999
+        })
+      });
+      var Comp = component;
+      return /*#__PURE__*/React.createElement(RootContext.Consumer, null, function (context) {
+        return /*#__PURE__*/React.createElement(Comp, {
+          ref: _this3.element
+        }, isOpened ? /*#__PURE__*/React.createElement(Modal, _extends({
+          className: "modal-portal"
+        }, modalProps, {
+          ariaHideApp: false,
+          isOpen: true,
+          style: newModalStyle,
+          parentSelector: function parentSelector() {
+            // React modal issue: https://github.com/reactjs/react-modal/issues/769
+            // failed to execute removeChild on parent node when it is already unmounted
+            return context && context.current || document.body;
+          },
+          onRequestClose: onClose
+        }), /*#__PURE__*/React.createElement("div", {
+          className: "portaled-content",
+          key: "item",
+          style: _objectSpread({
+            position: 'fixed',
+            opacity: isVisible ? 1 : 0,
+            transition: _this3.props.theme.transitionFast,
+            marginTop: isVisible ? '0px' : '14px'
+          }, pos)
+        }, /*#__PURE__*/React.createElement("div", {
+          ref: _this3.child,
+          style: {
+            position: 'absolute',
+            zIndex: overlayZIndex ? overlayZIndex + 1 : 10000
+          }
+        }, children))) : null);
+      });
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value:
+    // Make Portaled a component with Error Boundary, so React can recreate
+    // this component if the child 'ColorPicker' throws cross-origin error.
+    // see function componentDidCatch()
+    function getDerivedStateFromError() {
+      return {
+        hasError: true
+      };
+    }
+  }]);
+}(Component);
+_defineProperty(Portaled, "defaultProps", {
+  component: DefaultComponent,
+  onClose: noop,
+  theme: theme
+});
+export default withTheme(Portaled);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","debounce","isEqual","canUseDOM","withTheme","RootContext","Modal","Window","theme","listeners","startListening","Object","keys","forEach","key","getPageOffset","x","pageXOffset","undefined","document","documentElement","body","parentNode","scrollLeft","y","pageYOffset","scrollTop","addEventListeners","addEventListener","leading","getChildPos","_ref","offsets","rect","childRect","pageOffset","padding","topOffset","leftOffset","rightOffset","anchorLeft","pos","_objectSpread","top","left","right","innerWidth","leftOrRight","width","height","innerHeight","listenerIdCounter","subscribe","fn","id","defaultModalStyle","content","border","bottom","overlay","backgroundColor","WINDOW_PAD","noop","DefaultComponent","Portaled","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","isVisible","child","current","element","getBoundingClientRect","_this$props","props","_this$props$left","state","setState","_inherits","_createClass","value","componentDidMount","_unmounted","unsubscribe","handleScroll","componentDidUpdate","prevProps","_this2","didOpen","isOpened","didClose","requestAnimationFrame","Boolean","componentDidCatch","componentWillUnmount","render","_this3","_this$props2","_this$props2$componen","component","overlayZIndex","onClose","children","modalProps","_this$props2$modalSty","modalStyle","_this$state","newModalStyle","zIndex","Comp","createElement","Consumer","context","ref","_extends","className","ariaHideApp","isOpen","style","parentSelector","onRequestClose","position","opacity","transition","transitionFast","marginTop","getDerivedStateFromError","hasError"],"sources":["../../../src/common/portaled.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef, PropsWithChildren} from 'react';\nimport debounce from 'lodash/debounce';\nimport isEqual from 'lodash/isEqual';\n\nimport {canUseDOM} from 'exenv';\nimport {withTheme} from 'styled-components';\nimport {RootContext} from '../context';\nimport Modal from 'react-modal';\nimport Window from 'global/window';\nimport {theme} from '@kepler.gl/styles';\n\nconst listeners = {};\n\nconst startListening = () => Object.keys(listeners).forEach(key => listeners[key]());\n\nconst getPageOffset = () => ({\n  x:\n    Window.pageXOffset !== undefined\n      ? Window.pageXOffset\n      : (document.documentElement || document.body.parentNode || document.body).scrollLeft,\n  y:\n    Window.pageYOffset !== undefined\n      ? Window.pageYOffset\n      : (document.documentElement || document.body.parentNode || document.body).scrollTop\n});\n\nconst addEventListeners = () => {\n  if (document && document.body)\n    document.body.addEventListener('mousewheel', debounce(startListening, 100, {leading: true}));\n  Window.addEventListener('resize', debounce(startListening, 50, {leading: true}));\n};\n\ninterface GetChildPosProps {\n  offsets: Partial<{\n    topOffset: number;\n    leftOffset: number;\n    rightOffset: number;\n  }>;\n  rect: DOMRect;\n  childRect: DOMRect;\n  pageOffset: {\n    x: number;\n    y: number;\n  };\n  padding: number;\n}\n\nexport const getChildPos = ({offsets, rect, childRect, pageOffset, padding}: GetChildPosProps) => {\n  const {topOffset, leftOffset, rightOffset} = offsets;\n\n  const anchorLeft = leftOffset !== undefined;\n  const pos = {\n    top: pageOffset.y + rect.top + (topOffset || 0),\n    ...(anchorLeft\n      ? {left: pageOffset.x + rect.left + (leftOffset || 0)}\n      : {right: Window.innerWidth - rect.right - pageOffset.x + (rightOffset || 0)})\n  };\n\n  const leftOrRight = anchorLeft ? 'left' : 'right';\n\n  if (pos[leftOrRight] && pos[leftOrRight] < 0) {\n    pos[leftOrRight] = padding;\n  } else if (pos[leftOrRight] && pos[leftOrRight] + childRect.width > Window.innerWidth) {\n    pos[leftOrRight] = Window.innerWidth - childRect.width - padding;\n  }\n\n  if (pos.top < 0) {\n    pos.top = padding;\n  } else if (pos.top + childRect.height > Window.innerHeight) {\n    pos.top = Window.innerHeight - childRect.height - padding;\n  }\n\n  return pos;\n};\n\nif (canUseDOM) {\n  if (document.body) {\n    addEventListeners();\n  } else {\n    document.addEventListener('DOMContentLoaded', addEventListeners);\n  }\n}\n\nlet listenerIdCounter = 0;\nfunction subscribe(fn) {\n  listenerIdCounter += 1;\n  const id = listenerIdCounter;\n  listeners[id] = fn;\n  return () => delete listeners[id];\n}\n\nconst defaultModalStyle = {\n  content: {\n    top: 0,\n    left: 0,\n    border: 0,\n    right: 'auto',\n    bottom: 'auto',\n    padding: '0px 0px 0px 0px'\n  },\n  overlay: {\n    right: 'auto',\n    bottom: 'auto',\n    width: '100vw',\n    height: '100vh',\n    backgroundColor: 'rgba(0, 0, 0, 0)'\n  }\n};\n\nconst WINDOW_PAD = 40;\n\nconst noop = () => {\n  return;\n};\n\ntype PortaledProps = PropsWithChildren<{\n  right?: number;\n  left?: number;\n  top?: number;\n  component?: React.ElementType<any>;\n  onClose?: (\n    event: React.MouseEvent<Element, globalThis.MouseEvent> | React.KeyboardEvent<Element>\n  ) => void;\n  topOffset?: number;\n  leftOffset?: number;\n  rightOffset?: number;\n  overlayZIndex?: number;\n  isOpened?: boolean;\n  modalProps?: Partial<ReactModal.Props>;\n  modalStyle?: Partial<typeof defaultModalStyle>;\n  theme?: any;\n}>;\n\ninterface PortaledState {\n  pos:\n    | {\n        left: number;\n        top: number;\n      }\n    | {\n        right: number;\n        top: number;\n      }\n    | null;\n  isVisible: boolean;\n}\n\nconst DefaultComponent = 'div';\n\nclass Portaled extends Component<PortaledProps, PortaledState> {\n  // Make Portaled a component with Error Boundary, so React can recreate\n  // this component if the child 'ColorPicker' throws cross-origin error.\n  // see function componentDidCatch()\n  static getDerivedStateFromError(): {hasError: boolean} {\n    return {hasError: true};\n  }\n\n  static defaultProps: PortaledProps = {\n    component: DefaultComponent,\n    onClose: noop,\n    theme\n  };\n\n  state = {\n    pos: null,\n    isVisible: false\n  };\n\n  unsubscribe: (() => boolean) | undefined = undefined;\n  _unmounted = false;\n\n  componentDidMount() {\n    this._unmounted = false;\n    // relative\n    this.unsubscribe = subscribe(this.handleScroll);\n    this.handleScroll();\n  }\n\n  componentDidUpdate(prevProps: PortaledProps) {\n    const didOpen = this.props.isOpened && !prevProps.isOpened;\n    const didClose = !this.props.isOpened && prevProps.isOpened;\n    if (didOpen || didClose) {\n      Window.requestAnimationFrame(() => {\n        if (this._unmounted) return;\n        this.setState({isVisible: Boolean(didOpen)});\n      });\n    }\n\n    this.handleScroll();\n  }\n\n  // ColorPicker will throw a cross-origin error when it is closed\n  // when the app is within an iframe.\n  // This is a known issue of react-color component:\n  // see: https://github.com/casesandberg/react-color/issues/806\n  componentDidCatch() {\n    // Do nothing here, since React will try to recreate this component\n    // tree from scratch using the error boundary, which is this component\n    // itself. This is a temporal fix for a crash.\n  }\n\n  componentWillUnmount() {\n    this._unmounted = true;\n    // @ts-ignore\n    this.unsubscribe();\n  }\n\n  element = createRef<HTMLDivElement>();\n  child = createRef<HTMLDivElement>();\n\n  // eslint-disable-next-line complexity\n  handleScroll = () => {\n    if (this.child.current && this.element.current) {\n      const rect = this.element.current.getBoundingClientRect();\n      const childRect = this.child.current.getBoundingClientRect();\n      const pageOffset = getPageOffset();\n      const {top: topOffset, left: leftOffset = 0, right: rightOffset} = this.props;\n\n      const pos = getChildPos({\n        offsets: {topOffset, leftOffset, rightOffset},\n        rect,\n        childRect,\n        pageOffset,\n        padding: WINDOW_PAD\n      });\n\n      if (!isEqual(pos, this.state.pos)) {\n        this.setState({pos});\n      }\n    }\n  };\n\n  render(): JSX.Element {\n    const {\n      // relative\n      component = DefaultComponent,\n      overlayZIndex,\n      isOpened,\n      onClose,\n\n      // Modal\n      children,\n      modalProps,\n      modalStyle = {}\n    } = this.props;\n\n    const {isVisible, pos} = this.state;\n\n    const newModalStyle = {\n      ...defaultModalStyle,\n      content: {\n        ...(modalStyle.content || {})\n      },\n      overlay: {\n        ...defaultModalStyle.overlay,\n        ...(modalStyle.overlay || {}),\n        // needs to be on top of existing modal\n        zIndex: overlayZIndex || 9999\n      }\n    };\n\n    const Comp = component;\n\n    return (\n      <RootContext.Consumer>\n        {context => (\n          <Comp ref={this.element}>\n            {isOpened ? (\n              <Modal\n                className=\"modal-portal\"\n                {...modalProps}\n                ariaHideApp={false}\n                isOpen\n                style={newModalStyle}\n                parentSelector={() => {\n                  // React modal issue: https://github.com/reactjs/react-modal/issues/769\n                  // failed to execute removeChild on parent node when it is already unmounted\n                  return (context && context.current) || document.body;\n                }}\n                onRequestClose={onClose}\n              >\n                <div\n                  className=\"portaled-content\"\n                  key=\"item\"\n                  style={{\n                    position: 'fixed',\n                    opacity: isVisible ? 1 : 0,\n                    transition: this.props.theme.transitionFast,\n                    marginTop: isVisible ? '0px' : '14px',\n                    // @ts-ignore\n                    ...pos\n                  }}\n                >\n                  <div\n                    ref={this.child}\n                    style={{\n                      position: 'absolute',\n                      zIndex: overlayZIndex ? overlayZIndex + 1 : 10000\n                    }}\n                  >\n                    {children}\n                  </div>\n                </div>\n              </Modal>\n            ) : null}\n          </Comp>\n        )}\n      </RootContext.Consumer>\n    );\n  }\n}\n\nexport default withTheme(Portaled);\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/progress-bar.js

@@ -0,0 +1,43 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+
+/** @typedef {import('./progress-bar').ProgressBarProps} ProgressBarProps */
+
+var StyledBar = styled.span.attrs({
+  className: 'progress-bar__bar'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  background-color: ", ";\n  /* transition: width 200ms; */\n  display: block;\n"])), function (props) {
+  return props.barColor || props.theme.progressBarColor;
+});
+var StyledTrack = styled.div.attrs({
+  className: 'progress-bar'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  background-color: ", ";\n"])), function (props) {
+  return props.trackColor || props.theme.progressBarTrackColor;
+});
+/** @type {React.FunctionComponent<ProgressBarProps>} */
+var ProgressBar = function ProgressBar(_ref) {
+  var percent = _ref.percent,
+    _ref$height = _ref.height,
+    height = _ref$height === void 0 ? 4 : _ref$height,
+    isLoading = _ref.isLoading,
+    barColor = _ref.barColor,
+    trackColor = _ref.trackColor,
+    theme = _ref.theme;
+  return /*#__PURE__*/React.createElement(StyledTrack, {
+    trackColor: trackColor,
+    theme: theme
+  }, /*#__PURE__*/React.createElement(StyledBar, {
+    barColor: barColor,
+    style: {
+      width: percent,
+      height: "".concat(height, "px"),
+      opacity: isLoading ? 1 : 0
+    }
+  }));
+};
+export default ProgressBar;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/common/radius-legend.js

@@ -0,0 +1,124 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import { scaleSqrt } from 'd3-scale';
+import { SCALE_TYPES } from '@kepler.gl/constants';
+import { formatNumber } from '@kepler.gl/utils';
+import { max } from 'd3-array';
+import { console as Console } from 'global/window';
+var StyledLegend = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  width: ", "px;\n  height: ", "px;\n  position: relative;\n  svg {\n    circle {\n      stroke: ", ";\n      fill: none;\n    }\n    line {\n      stroke: ", ";\n      stroke-dasharray: 2, 1;\n    }\n  }\n"])), function (props) {
+  return props.width;
+}, function (props) {
+  return props.height;
+}, function (props) {
+  return props.theme.borderColorLT;
+}, function (props) {
+  return props.theme.borderColor;
+});
+var LabelsOuter = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  text-align: right;\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: ", "px;\n  height: ", "px;\n"])), function (props) {
+  return props.width;
+}, function (props) {
+  return props.height;
+});
+var tickHeight = 9;
+var ValueLabel = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  position: absolute;\n  font-size: ", "px;\n  height: ", "px;\n  line-height: ", "px;\n  margin-top: -", "px;\n  color: ", ";\n  background-color: ", ";\n  padding: 0 2px;\n  border-radius: 2px;\n"])), tickHeight, tickHeight, tickHeight, tickHeight / 2, function (props) {
+  return props.theme.textColor;
+}, function (props) {
+  return props.theme.mapPanelBackgroundColor;
+});
+var margin = {
+  left: 1,
+  top: 5,
+  right: 2,
+  bottom: 5
+};
+var RadiusLegend = function RadiusLegend(_ref) {
+  var scaleType = _ref.scaleType,
+    width = _ref.width,
+    domain = _ref.domain,
+    range = _ref.range,
+    fieldType = _ref.fieldType;
+  var radiusScale = useMemo(function () {
+    if (scaleType !== SCALE_TYPES.sqrt) {
+      Console.warn("Unsupported radius scale type: ".concat(scaleType));
+      return undefined;
+    }
+    if (!Array.isArray(domain) || !domain.every(Number.isFinite)) {
+      return undefined;
+    }
+    return scaleSqrt().domain(domain).range(range);
+  }, [domain, range, scaleType]);
+  var radiusTicks = useMemo(function () {
+    if (radiusScale === undefined) return [];
+    var numTicksToFit = Math.min(10, (range[1] - range[0]) * 2 / tickHeight);
+    var ticks = radiusScale.ticks(numTicksToFit);
+    // Add min and max values
+    if (ticks[0] > domain[0]) {
+      ticks.unshift(domain[0]);
+    }
+    if (ticks[ticks.length - 1] < domain[1]) {
+      ticks.push(domain[1]);
+    }
+    // Make sure there is no overlap
+    return ticks.reduceRight(function (acc, v) {
+      if (acc.length === 0 || Math.abs(radiusScale(acc[0]) - radiusScale(v)) * 2 > tickHeight) {
+        // @ts-ignore
+        acc.unshift(v);
+      }
+      return acc;
+    }, new Array());
+  }, [radiusScale, domain, range]);
+  if (!radiusScale || !radiusTicks.length) {
+    return null;
+  }
+  var maxR = Math.ceil(radiusScale(max(radiusTicks) || 0));
+  var w = width - margin.left - margin.right;
+  var h = maxR * 2;
+  var height = h + margin.top + margin.bottom;
+  return /*#__PURE__*/React.createElement(StyledLegend, {
+    width: width,
+    height: height
+  }, /*#__PURE__*/React.createElement("svg", {
+    width: width,
+    height: height
+  }, /*#__PURE__*/React.createElement("g", {
+    transform: "translate(".concat(margin.left, ",").concat(margin.top, ")")
+  }, /*#__PURE__*/React.createElement("g", null, radiusTicks.map(function (v, i) {
+    return /*#__PURE__*/React.createElement("g", {
+      key: i
+    }, /*#__PURE__*/React.createElement("g", {
+      transform: "translate(".concat(w, ",").concat(h - radiusScale(v) * 2, ")")
+    }, /*#__PURE__*/React.createElement("line", {
+      x1: 0,
+      x2: maxR - w
+    })));
+  })), /*#__PURE__*/React.createElement("g", null, radiusTicks.map(function (v, i) {
+    var r = radiusScale(v);
+    return /*#__PURE__*/React.createElement("g", {
+      key: i
+    }, /*#__PURE__*/React.createElement("g", {
+      transform: "translate(0,".concat(h - r * 2, ")")
+    }, /*#__PURE__*/React.createElement("circle", {
+      cx: maxR,
+      cy: r,
+      r: Math.max(0, r - 1) /* stroke is drawn outside, hence r-1 */
+    })));
+  })))), /*#__PURE__*/React.createElement(LabelsOuter, {
+    width: width,
+    height: height
+  }, radiusTicks.map(function (v, i) {
+    return /*#__PURE__*/React.createElement(ValueLabel, {
+      key: i,
+      style: {
+        right: margin.right,
+        top: margin.top + h - radiusScale(v) * 2
+      }
+    }, formatNumber(v, fieldType));
+  })));
+};
+export default RadiusLegend;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","styled","scaleSqrt","SCALE_TYPES","formatNumber","max","console","Console","StyledLegend","div","_templateObject","_taggedTemplateLiteral","props","width","height","theme","borderColorLT","borderColor","LabelsOuter","_templateObject2","tickHeight","ValueLabel","_templateObject3","textColor","mapPanelBackgroundColor","margin","left","top","right","bottom","RadiusLegend","_ref","scaleType","domain","range","fieldType","radiusScale","sqrt","warn","concat","undefined","Array","isArray","every","Number","isFinite","radiusTicks","numTicksToFit","Math","min","ticks","unshift","length","push","reduceRight","acc","v","abs","maxR","ceil","w","h","createElement","transform","map","i","key","x1","x2","r","cx","cy","style"],"sources":["../../../src/common/radius-legend.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo, FC} from 'react';\nimport styled from 'styled-components';\nimport {scaleSqrt} from 'd3-scale';\nimport {SCALE_TYPES} from '@kepler.gl/constants';\nimport {formatNumber} from '@kepler.gl/utils';\nimport {max} from 'd3-array';\nimport {console as Console} from 'global/window';\n\nconst StyledLegend = styled.div<{width: number; height: number}>`\n  width: ${props => props.width}px;\n  height: ${props => props.height}px;\n  position: relative;\n  svg {\n    circle {\n      stroke: ${props => props.theme.borderColorLT};\n      fill: none;\n    }\n    line {\n      stroke: ${props => props.theme.borderColor};\n      stroke-dasharray: 2, 1;\n    }\n  }\n`;\n\nconst LabelsOuter = styled.div<{width: number; height: number}>`\n  text-align: right;\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: ${props => props.width}px;\n  height: ${props => props.height}px;\n`;\n\nconst tickHeight = 9;\n\nconst ValueLabel = styled.div`\n  position: absolute;\n  font-size: ${tickHeight}px;\n  height: ${tickHeight}px;\n  line-height: ${tickHeight}px;\n  margin-top: -${tickHeight / 2}px;\n  color: ${props => props.theme.textColor};\n  background-color: ${props => props.theme.mapPanelBackgroundColor};\n  padding: 0 2px;\n  border-radius: 2px;\n`;\n\nconst margin = {left: 1, top: 5, right: 2, bottom: 5};\n\ntype Props = {\n  width: number;\n  scaleType: string;\n  domain: [number, number];\n  fieldType: string;\n  range: [number, number];\n};\n\nconst RadiusLegend: FC<Props> = ({scaleType, width, domain, range, fieldType}) => {\n  const radiusScale = useMemo(() => {\n    if (scaleType !== SCALE_TYPES.sqrt) {\n      Console.warn(`Unsupported radius scale type: ${scaleType}`);\n      return undefined;\n    }\n    if (!Array.isArray(domain) || !domain.every(Number.isFinite)) {\n      return undefined;\n    }\n    return scaleSqrt().domain(domain).range(range);\n  }, [domain, range, scaleType]);\n\n  const radiusTicks = useMemo(() => {\n    if (radiusScale === undefined) return [];\n    const numTicksToFit = Math.min(10, ((range[1] - range[0]) * 2) / tickHeight);\n    const ticks = radiusScale.ticks(numTicksToFit);\n    // Add min and max values\n    if (ticks[0] > domain[0]) {\n      ticks.unshift(domain[0]);\n    }\n    if (ticks[ticks.length - 1] < domain[1]) {\n      ticks.push(domain[1]);\n    }\n    // Make sure there is no overlap\n    return ticks.reduceRight((acc, v) => {\n      if (acc.length === 0 || Math.abs(radiusScale(acc[0]) - radiusScale(v)) * 2 > tickHeight) {\n        // @ts-ignore\n        acc.unshift(v);\n      }\n      return acc;\n    }, new Array<number>());\n  }, [radiusScale, domain, range]);\n\n  if (!radiusScale || !radiusTicks.length) {\n    return null;\n  }\n  const maxR = Math.ceil(radiusScale(max(radiusTicks) || 0));\n  const w = width - margin.left - margin.right;\n  const h = maxR * 2;\n  const height = h + margin.top + margin.bottom;\n\n  return (\n    <StyledLegend width={width} height={height}>\n      <svg width={width} height={height}>\n        <g transform={`translate(${margin.left},${margin.top})`}>\n          <g>\n            {radiusTicks.map((v, i) => (\n              <g key={i}>\n                <g transform={`translate(${w},${h - radiusScale(v) * 2})`}>\n                  <line x1={0} x2={maxR - w} />\n                </g>\n              </g>\n            ))}\n          </g>\n          <g>\n            {radiusTicks.map((v, i) => {\n              const r = radiusScale(v);\n              return (\n                <g key={i}>\n                  <g transform={`translate(0,${h - r * 2})`}>\n                    <circle\n                      cx={maxR}\n                      cy={r}\n                      r={Math.max(0, r - 1)} /* stroke is drawn outside, hence r-1 */\n                    />\n                  </g>\n                </g>\n              );\n            })}\n          </g>\n        </g>\n      </svg>\n      <LabelsOuter width={width} height={height}>\n        {radiusTicks.map((v, i) => (\n          <ValueLabel\n            key={i}\n            style={{\n              right: margin.right,\n              top: margin.top + h - radiusScale(v) * 2\n            }}\n          >\n            {formatNumber(v, fieldType)}\n          </ValueLabel>\n        ))}\n      </LabelsOuter>\n    </StyledLegend>\n  );\n};\n\nexport default RadiusLegend;\n"],"mappings":"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","ignoreList":[]}