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

package/dist/components/common/range-brush.js

@@ -0,0 +1,319 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _d3Selection = require("d3-selection");
+
+var _d3Brush = require("d3-brush");
+
+var _dataUtils = require("../../utils/data-utils");
+
+var _templateObject;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var StyledG = _styledComponents["default"].g(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .selection {\n    stroke: none;\n    fill: ", ";\n    fill-opacity: ", ";\n  }\n  .handle {\n    fill: ", ";\n    fill-opacity: 0.3;\n  }\n"])), function (props) {
+  return props.isRanged ? props.theme.rangeBrushBgd : props.theme.BLUE2;
+}, function (props) {
+  return props.isRanged ? 0.3 : 1;
+}, function (props) {
+  return props.theme.BLUE2;
+});
+
+function moveRight(startSel, selection) {
+  var _startSel = (0, _slicedToArray2["default"])(startSel, 1),
+      startSel0 = _startSel[0];
+
+  var _selection = (0, _slicedToArray2["default"])(selection, 1),
+      sel0 = _selection[0];
+
+  return Boolean(startSel0 === sel0);
+} // style brush resize handle
+// https://github.com/crossfilter/crossfilter/blob/gh-pages/index.html#L466
+
+
+var getHandlePath = function getHandlePath(props) {
+  return function brushResizePath(d) {
+    var e = Number(d.type === 'e');
+    var x = e ? 1 : -1;
+    var h = 39;
+    var w = 4.5;
+    var y = (props.height - h) / 2;
+    return "M".concat(0.5 * x, ",").concat(y, "c").concat(2.5 * x, ",0,").concat(w * x, ",2,").concat(w * x, ",").concat(w, "v").concat(h - w * 2, "c0,2.5,").concat(-2 * x, ",").concat(w, ",").concat(-w * x, ",").concat(w, "V").concat(y, "z");
+  };
+};
+
+function RangeBrushFactory() {
+  var RangeBrush = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(RangeBrush, _Component);
+
+    var _super = _createSuper(RangeBrush);
+
+    function RangeBrush() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, RangeBrush);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "rootContainer", /*#__PURE__*/(0, _react.createRef)());
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_brushed", function (evt) {
+        var _this2;
+
+        // Ignore brush events which don't have an underlying sourceEvent
+        if (!evt.sourceEvent) return;
+
+        var _evt$selection = (0, _slicedToArray2["default"])(evt.selection, 2),
+            sel0 = _evt$selection[0],
+            sel1 = _evt$selection[1];
+
+        var right = moveRight(_this._startSel, evt.selection);
+
+        var _this$props = _this.props,
+            _this$props$range = (0, _slicedToArray2["default"])(_this$props.range, 2),
+            min = _this$props$range[0],
+            max = _this$props$range[1],
+            step = _this$props.step,
+            width = _this$props.width,
+            marks = _this$props.marks,
+            isRanged = _this$props.isRanged;
+
+        var invert = function invert(x) {
+          return x * (max - min) / width + min;
+        };
+
+        var d0 = invert(sel0);
+        var d1 = invert(sel1);
+        d0 = (0, _dataUtils.normalizeSliderValue)(d0, min, step, marks);
+        d1 = (0, _dataUtils.normalizeSliderValue)(d1, min, step, marks);
+        if (isRanged) _this._move(d0, d1);else (_this2 = _this)._move.apply(_this2, (0, _toConsumableArray2["default"])(right ? [d1, d1] : [d0, d0]));
+        if (isRanged) _this._onBrush(d0, d1);else _this._onBrush(right ? d1 : d0);
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(RangeBrush, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this3 = this;
+
+        // We want the React app to respond to brush state and vice-versa
+        // but d3-brush fires the same events for both user-initiated brushing
+        // and programmatic brushing (brush.move). We need these flags to
+        // distinguish between the uses.
+        //
+        // We don't use state because that would trigger another `componentDidUpdate`
+        var _this$props2 = this.props,
+            theme = _this$props2.theme,
+            isRanged = _this$props2.isRanged,
+            onMouseoverHandle = _this$props2.onMouseoverHandle,
+            onMouseoutHandle = _this$props2.onMouseoutHandle;
+        this.brushing = false;
+        this.moving = false;
+        this.root = (0, _d3Selection.select)(this.rootContainer.current);
+        this.brush = (0, _d3Brush.brushX)().handleSize(3).on('start', function (event) {
+          if (typeof _this3.props.onBrushStart === 'function') _this3.props.onBrushStart();
+          _this3._startSel = event.selection;
+        }).on('brush', function (event) {
+          if (_this3.moving) {
+            return;
+          }
+
+          if (event.selection) {
+            _this3._lastSel = event.selection;
+            _this3.brushing = true;
+
+            _this3._brushed(event);
+          }
+        }).on('end', function (event) {
+          if (!event.selection) {
+            if (_this3.brushing) {
+              // handle null selection
+              _this3._click(_this3._lastSel);
+            } else if (_this3._startSel) {
+              // handle click
+              _this3._click(_this3._startSel);
+            }
+          }
+
+          if (typeof _this3.props.onBrushEnd === 'function') _this3.props.onBrushEnd();
+          _this3.brushing = false;
+          _this3.moving = false;
+        });
+        this.root.call(this.brush);
+        var brushResizePath = getHandlePath(this.props);
+        this.handle = this.root.selectAll('.handle--custom').data([{
+          type: 'w'
+        }, {
+          type: 'e'
+        }]).enter().append('path').attr('class', 'handle--custom').attr('display', isRanged ? null : 'none').attr('fill', theme ? theme.sliderHandleColor : '#D3D8E0').attr('cursor', 'ew-resize').attr('d', brushResizePath).on('mouseover', function () {
+          if (onMouseoverHandle) onMouseoverHandle();
+        }).on('mouseout', function () {
+          if (onMouseoutHandle) onMouseoutHandle();
+        });
+
+        var _this$props$value = (0, _slicedToArray2["default"])(this.props.value, 2),
+            val0 = _this$props$value[0],
+            val1 = _this$props$value[1];
+
+        this.moving = true;
+
+        this._move(val0, val1);
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var _this$props3 = this.props,
+            _this$props3$value = (0, _slicedToArray2["default"])(_this$props3.value, 2),
+            val0 = _this$props3$value[0],
+            val1 = _this$props3$value[1],
+            width = _this$props3.width;
+
+        var _prevProps$value = (0, _slicedToArray2["default"])(prevProps.value, 2),
+            prevVal0 = _prevProps$value[0],
+            prevVal1 = _prevProps$value[1];
+
+        if (prevProps.width !== width) {
+          // width change should not trigger this._brushed
+          this.moving = true;
+          this.root.call(this.brush);
+
+          this._move(val0, val1);
+        }
+
+        if (!this.brushing && !this.moving) {
+          if (prevVal0 !== val0 || prevVal1 !== val1) {
+            this.moving = true;
+
+            this._move(val0, val1);
+          }
+        }
+
+        if (!this.props.isRanged) {
+          this.handle.attr('display', 'none');
+        }
+      }
+    }, {
+      key: "_click",
+      value: function _click(selection) {
+        // fake brush
+        this.brushing = true;
+
+        this._brushed({
+          sourceEvent: {},
+          selection: selection
+        });
+      }
+    }, {
+      key: "_move",
+      value: function _move(val0, val1) {
+        var _this$props4 = this.props,
+            _this$props4$range = (0, _slicedToArray2["default"])(_this$props4.range, 2),
+            min = _this$props4$range[0],
+            max = _this$props4$range[1],
+            width = _this$props4.width,
+            isRanged = _this$props4.isRanged;
+
+        if (width && max - min) {
+          var scale = function scale(x) {
+            return (x - min) * width / (max - min);
+          };
+
+          if (!isRanged) {
+            // only draw a 1 pixel line
+            this.brush.move(this.root, [scale(val0), scale(val0) + 1]);
+          } else {
+            this.brush.move(this.root, [scale(val0), scale(val1)]);
+            this.handle.attr('display', null).attr('transform', function (d, i) {
+              return "translate(".concat([i === 0 ? scale(val0) : scale(val1), 0], ")");
+            });
+          }
+        }
+      }
+    }, {
+      key: "_onBrush",
+      value: function _onBrush(val0, val1) {
+        var _this$props5 = this.props,
+            isRanged = _this$props5.isRanged,
+            _this$props5$value = (0, _slicedToArray2["default"])(_this$props5.value, 2),
+            currentVal0 = _this$props5$value[0],
+            currentVal1 = _this$props5$value[1];
+
+        if (currentVal0 === val0 && currentVal1 === val1) {
+          return;
+        }
+
+        if (isRanged) {
+          this.props.onBrush(val0, val1);
+        } else {
+          this.props.onBrush(val0, val0);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var isRanged = this.props.isRanged;
+        return /*#__PURE__*/_react["default"].createElement(StyledG, {
+          className: "kg-range-slider__brush",
+          isRanged: isRanged,
+          ref: this.rootContainer
+        });
+      }
+    }]);
+    return RangeBrush;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(RangeBrush, "propTypes", {
+    onBrush: _propTypes["default"].func.isRequired,
+    range: _propTypes["default"].arrayOf(_propTypes["default"].number).isRequired,
+    value: _propTypes["default"].arrayOf(_propTypes["default"].number).isRequired,
+    width: _propTypes["default"].number.isRequired,
+    isRanged: _propTypes["default"].bool
+  });
+  (0, _defineProperty2["default"])(RangeBrush, "defaultProps", {
+    isRanged: true
+  });
+  return (0, _styledComponents.withTheme)(RangeBrush);
+}
+
+var _default = RangeBrushFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/common/range-brush.js"],"names":["StyledG","styled","g","props","isRanged","theme","rangeBrushBgd","BLUE2","moveRight","startSel","selection","startSel0","sel0","Boolean","getHandlePath","brushResizePath","d","e","Number","type","x","h","w","y","height","RangeBrushFactory","RangeBrush","evt","sourceEvent","sel1","right","_startSel","range","min","max","step","width","marks","invert","d0","d1","_move","_onBrush","onMouseoverHandle","onMouseoutHandle","brushing","moving","root","rootContainer","current","brush","handleSize","on","event","onBrushStart","_lastSel","_brushed","_click","onBrushEnd","call","handle","selectAll","data","enter","append","attr","sliderHandleColor","value","val0","val1","prevProps","prevVal0","prevVal1","scale","move","i","currentVal0","currentVal1","onBrush","Component","PropTypes","func","isRequired","arrayOf","number","bool"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component, createRef} from 'react';\nimport PropTypes from 'prop-types';\nimport styled, {withTheme} from 'styled-components';\nimport {select} from 'd3-selection';\nimport {brushX} from 'd3-brush';\nimport {normalizeSliderValue} from 'utils/data-utils';\n\nconst StyledG = styled.g`\n  .selection {\n    stroke: none;\n    fill: ${props => (props.isRanged ? props.theme.rangeBrushBgd : props.theme.BLUE2)};\n    fill-opacity: ${props => (props.isRanged ? 0.3 : 1)};\n  }\n  .handle {\n    fill: ${props => props.theme.BLUE2};\n    fill-opacity: 0.3;\n  }\n`;\n\nfunction moveRight(startSel, selection) {\n  const [startSel0] = startSel;\n  const [sel0] = selection;\n\n  return Boolean(startSel0 === sel0);\n}\n// style brush resize handle\n// https://github.com/crossfilter/crossfilter/blob/gh-pages/index.html#L466\nconst getHandlePath = props => {\n  return function brushResizePath(d) {\n    const e = Number(d.type === 'e');\n    const x = e ? 1 : -1;\n    const h = 39;\n    const w = 4.5;\n    const y = (props.height - h) / 2;\n    return `M${0.5 * x},${y}c${2.5 * x},0,${w * x},2,${w * x},${w}v${h - w * 2}c0,2.5,${-2 *\n      x},${w},${-w * x},${w}V${y}z`;\n  };\n};\n\nfunction RangeBrushFactory() {\n  class RangeBrush extends Component {\n    static propTypes = {\n      onBrush: PropTypes.func.isRequired,\n      range: PropTypes.arrayOf(PropTypes.number).isRequired,\n      value: PropTypes.arrayOf(PropTypes.number).isRequired,\n      width: PropTypes.number.isRequired,\n      isRanged: PropTypes.bool\n    };\n\n    static defaultProps = {\n      isRanged: true\n    };\n\n    componentDidMount() {\n      // We want the React app to respond to brush state and vice-versa\n      // but d3-brush fires the same events for both user-initiated brushing\n      // and programmatic brushing (brush.move). We need these flags to\n      // distinguish between the uses.\n      //\n      // We don't use state because that would trigger another `componentDidUpdate`\n      const {theme, isRanged, onMouseoverHandle, onMouseoutHandle} = this.props;\n\n      this.brushing = false;\n      this.moving = false;\n\n      this.root = select(this.rootContainer.current);\n      this.brush = brushX()\n        .handleSize(3)\n        .on('start', event => {\n          if (typeof this.props.onBrushStart === 'function') this.props.onBrushStart();\n          this._startSel = event.selection;\n        })\n        .on('brush', event => {\n          if (this.moving) {\n            return;\n          }\n          if (event.selection) {\n            this._lastSel = event.selection;\n            this.brushing = true;\n            this._brushed(event);\n          }\n        })\n        .on('end', event => {\n          if (!event.selection) {\n            if (this.brushing) {\n              // handle null selection\n              this._click(this._lastSel);\n            } else if (this._startSel) {\n              // handle click\n              this._click(this._startSel);\n            }\n          }\n\n          if (typeof this.props.onBrushEnd === 'function') this.props.onBrushEnd();\n\n          this.brushing = false;\n          this.moving = false;\n        });\n\n      this.root.call(this.brush);\n      const brushResizePath = getHandlePath(this.props);\n      this.handle = this.root\n        .selectAll('.handle--custom')\n        .data([{type: 'w'}, {type: 'e'}])\n        .enter()\n        .append('path')\n        .attr('class', 'handle--custom')\n        .attr('display', isRanged ? null : 'none')\n        .attr('fill', theme ? theme.sliderHandleColor : '#D3D8E0')\n        .attr('cursor', 'ew-resize')\n        .attr('d', brushResizePath)\n        .on('mouseover', () => {\n          if (onMouseoverHandle) onMouseoverHandle();\n        })\n        .on('mouseout', () => {\n          if (onMouseoutHandle) onMouseoutHandle();\n        });\n\n      const {\n        value: [val0, val1]\n      } = this.props;\n      this.moving = true;\n      this._move(val0, val1);\n    }\n\n    componentDidUpdate(prevProps) {\n      const {\n        value: [val0, val1],\n        width\n      } = this.props;\n      const [prevVal0, prevVal1] = prevProps.value;\n\n      if (prevProps.width !== width) {\n        // width change should not trigger this._brushed\n        this.moving = true;\n        this.root.call(this.brush);\n        this._move(val0, val1);\n      }\n\n      if (!this.brushing && !this.moving) {\n        if (prevVal0 !== val0 || prevVal1 !== val1) {\n          this.moving = true;\n          this._move(val0, val1);\n        }\n      }\n\n      if (!this.props.isRanged) {\n        this.handle.attr('display', 'none');\n      }\n    }\n\n    rootContainer = createRef();\n\n    _click(selection) {\n      // fake brush\n      this.brushing = true;\n      this._brushed({sourceEvent: {}, selection});\n    }\n\n    _move(val0, val1) {\n      const {\n        range: [min, max],\n        width,\n        isRanged\n      } = this.props;\n\n      if (width && max - min) {\n        const scale = x => ((x - min) * width) / (max - min);\n        if (!isRanged) {\n          // only draw a 1 pixel line\n          this.brush.move(this.root, [scale(val0), scale(val0) + 1]);\n        } else {\n          this.brush.move(this.root, [scale(val0), scale(val1)]);\n\n          this.handle\n            .attr('display', null)\n            .attr('transform', (d, i) => `translate(${[i === 0 ? scale(val0) : scale(val1), 0]})`);\n        }\n      }\n    }\n\n    _brushed = evt => {\n      // Ignore brush events which don't have an underlying sourceEvent\n      if (!evt.sourceEvent) return;\n      const [sel0, sel1] = evt.selection;\n      const right = moveRight(this._startSel, evt.selection);\n\n      const {\n        range: [min, max],\n        step,\n        width,\n        marks,\n        isRanged\n      } = this.props;\n      const invert = x => (x * (max - min)) / width + min;\n      let d0 = invert(sel0);\n      let d1 = invert(sel1);\n\n      d0 = normalizeSliderValue(d0, min, step, marks);\n      d1 = normalizeSliderValue(d1, min, step, marks);\n\n      if (isRanged) this._move(d0, d1);\n      else this._move(...(right ? [d1, d1] : [d0, d0]));\n\n      if (isRanged) this._onBrush(d0, d1);\n      else this._onBrush(right ? d1 : d0);\n    };\n\n    _onBrush(val0, val1) {\n      const {\n        isRanged,\n        value: [currentVal0, currentVal1]\n      } = this.props;\n\n      if (currentVal0 === val0 && currentVal1 === val1) {\n        return;\n      }\n\n      if (isRanged) {\n        this.props.onBrush(val0, val1);\n      } else {\n        this.props.onBrush(val0, val0);\n      }\n    }\n\n    render() {\n      const {isRanged} = this.props;\n      return (\n        <StyledG className=\"kg-range-slider__brush\" isRanged={isRanged} ref={this.rootContainer} />\n      );\n    }\n  }\n  return withTheme(RangeBrush);\n}\n\nexport default RangeBrushFactory;\n"]}

package/dist/components/common/range-plot.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = RangePlotFactory;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _rangeBrush = _interopRequireDefault(require("./range-brush"));
+
+var _histogramPlot = _interopRequireDefault(require("./histogram-plot"));
+
+var _lineChart = _interopRequireDefault(require("./line-chart"));
+
+var _utils = require("../../utils/utils");
+
+var _templateObject;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var StyledRangePlot = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: ", "px;\n  display: flex;\n  position: 'relative';\n"])), function (props) {
+  return props.theme.sliderBarHeight;
+});
+
+RangePlotFactory.deps = [_rangeBrush["default"], _histogramPlot["default"], _lineChart["default"]];
+
+function RangePlotFactory(RangeBrush, HistogramPlot, LineChart) {
+  var RangePlot = function RangePlot(_ref) {
+    var onBrush = _ref.onBrush,
+        range = _ref.range,
+        value = _ref.value,
+        width = _ref.width,
+        plotType = _ref.plotType,
+        lineChart = _ref.lineChart,
+        histogram = _ref.histogram,
+        isEnlarged = _ref.isEnlarged,
+        isRanged = _ref.isRanged,
+        theme = _ref.theme,
+        chartProps = (0, _objectWithoutProperties2["default"])(_ref, ["onBrush", "range", "value", "width", "plotType", "lineChart", "histogram", "isEnlarged", "isRanged", "theme"]);
+
+    var _useState = (0, _react.useState)(false),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        brushing = _useState2[0],
+        setBrushing = _useState2[1];
+
+    var _useState3 = (0, _react.useState)(null),
+        _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+        hoveredDP = _useState4[0],
+        onMouseMove = _useState4[1];
+
+    var _useState5 = (0, _react.useState)(false),
+        _useState6 = (0, _slicedToArray2["default"])(_useState5, 2),
+        enableChartHover = _useState6[0],
+        setEnableChartHover = _useState6[1];
+
+    var height = isEnlarged ? theme.rangePlotHLarge : theme.rangePlotH;
+    var onBrushStart = (0, _react.useCallback)(function () {
+      setBrushing(true);
+      onMouseMove(null);
+      setEnableChartHover(false);
+    }, [setBrushing, onMouseMove, setEnableChartHover]);
+    var onBrushEnd = (0, _react.useCallback)(function () {
+      setBrushing(false);
+      setEnableChartHover(true);
+    }, [setBrushing, setEnableChartHover]);
+    var onMouseoverHandle = (0, _react.useCallback)(function () {
+      onMouseMove(null);
+      setEnableChartHover(false);
+    }, [onMouseMove, setEnableChartHover]);
+    var onMouseoutHandle = (0, _react.useCallback)(function () {
+      setEnableChartHover(true);
+    }, [setEnableChartHover]); // JsDom have limited support for SVG, d3 will fail
+
+    var brushComponent = (0, _utils.isTest)() ? null : /*#__PURE__*/_react["default"].createElement(RangeBrush, (0, _extends2["default"])({
+      onBrush: onBrush,
+      onBrushStart: onBrushStart,
+      onBrushEnd: onBrushEnd,
+      range: range,
+      value: value,
+      width: width,
+      height: height,
+      isRanged: isRanged,
+      onMouseoverHandle: onMouseoverHandle,
+      onMouseoutHandle: onMouseoutHandle
+    }, chartProps));
+
+    var commonProps = _objectSpread({
+      width: width,
+      value: value,
+      height: height,
+      margin: isEnlarged ? theme.rangePlotMarginLarge : theme.rangePlotMargin,
+      brushComponent: brushComponent,
+      brushing: brushing,
+      isEnlarged: isEnlarged,
+      enableChartHover: enableChartHover,
+      onMouseMove: onMouseMove,
+      hoveredDP: hoveredDP,
+      isRanged: isRanged
+    }, chartProps);
+
+    return /*#__PURE__*/_react["default"].createElement(StyledRangePlot, {
+      style: {
+        height: "".concat(isEnlarged ? theme.rangePlotContainerHLarge : theme.rangePlotContainerH, "px")
+      },
+      className: "kg-range-slider__plot"
+    }, plotType === 'lineChart' && lineChart ? /*#__PURE__*/_react["default"].createElement(LineChart, (0, _extends2["default"])({
+      lineChart: lineChart
+    }, commonProps)) : /*#__PURE__*/_react["default"].createElement(HistogramPlot, (0, _extends2["default"])({
+      histogram: histogram
+    }, commonProps)));
+  };
+
+  RangePlot.propTypes = {
+    value: _propTypes["default"].arrayOf(_propTypes["default"].number).isRequired,
+    histogram: _propTypes["default"].arrayOf(_propTypes["default"].shape({
+      x0: _propTypes["default"].number,
+      x1: _propTypes["default"].number
+    })),
+    lineChart: _propTypes["default"].object,
+    plotType: _propTypes["default"].string,
+    isEnlarged: _propTypes["default"].bool,
+    onBlur: _propTypes["default"].func,
+    width: _propTypes["default"].number.isRequired
+  };
+  return (0, _styledComponents.withTheme)(RangePlot);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/common/range-plot.js"],"names":["StyledRangePlot","styled","div","props","theme","sliderBarHeight","RangePlotFactory","deps","RangeBrushFactory","HistogramPlotFactory","LineChartFactory","RangeBrush","HistogramPlot","LineChart","RangePlot","onBrush","range","value","width","plotType","lineChart","histogram","isEnlarged","isRanged","chartProps","brushing","setBrushing","hoveredDP","onMouseMove","enableChartHover","setEnableChartHover","height","rangePlotHLarge","rangePlotH","onBrushStart","onBrushEnd","onMouseoverHandle","onMouseoutHandle","brushComponent","commonProps","margin","rangePlotMarginLarge","rangePlotMargin","rangePlotContainerHLarge","rangePlotContainerH","propTypes","PropTypes","arrayOf","number","isRequired","shape","x0","x1","object","string","bool","onBlur","func"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {useState, useCallback} from 'react';\nimport PropTypes from 'prop-types';\nimport styled, {withTheme} from 'styled-components';\nimport RangeBrushFactory from './range-brush';\nimport HistogramPlotFactory from './histogram-plot';\nimport LineChartFactory from './line-chart';\nimport {isTest} from 'utils/utils';\n\nconst StyledRangePlot = styled.div`\n  margin-bottom: ${props => props.theme.sliderBarHeight}px;\n  display: flex;\n  position: 'relative';\n`;\n\nRangePlotFactory.deps = [RangeBrushFactory, HistogramPlotFactory, LineChartFactory];\n\nexport default function RangePlotFactory(RangeBrush, HistogramPlot, LineChart) {\n  const RangePlot = ({\n    onBrush,\n    range,\n    value,\n    width,\n    plotType,\n    lineChart,\n    histogram,\n    isEnlarged,\n    isRanged,\n    theme,\n    ...chartProps\n  }) => {\n    const [brushing, setBrushing] = useState(false);\n    const [hoveredDP, onMouseMove] = useState(null);\n    const [enableChartHover, setEnableChartHover] = useState(false);\n    const height = isEnlarged ? theme.rangePlotHLarge : theme.rangePlotH;\n\n    const onBrushStart = useCallback(() => {\n      setBrushing(true);\n      onMouseMove(null);\n      setEnableChartHover(false);\n    }, [setBrushing, onMouseMove, setEnableChartHover]);\n\n    const onBrushEnd = useCallback(() => {\n      setBrushing(false);\n      setEnableChartHover(true);\n    }, [setBrushing, setEnableChartHover]);\n\n    const onMouseoverHandle = useCallback(() => {\n      onMouseMove(null);\n      setEnableChartHover(false);\n    }, [onMouseMove, setEnableChartHover]);\n\n    const onMouseoutHandle = useCallback(() => {\n      setEnableChartHover(true);\n    }, [setEnableChartHover]);\n\n    // JsDom have limited support for SVG, d3 will fail\n    const brushComponent = isTest() ? null : (\n      <RangeBrush\n        onBrush={onBrush}\n        onBrushStart={onBrushStart}\n        onBrushEnd={onBrushEnd}\n        range={range}\n        value={value}\n        width={width}\n        height={height}\n        isRanged={isRanged}\n        onMouseoverHandle={onMouseoverHandle}\n        onMouseoutHandle={onMouseoutHandle}\n        {...chartProps}\n      />\n    );\n\n    const commonProps = {\n      width,\n      value,\n      height,\n      margin: isEnlarged ? theme.rangePlotMarginLarge : theme.rangePlotMargin,\n      brushComponent,\n      brushing,\n      isEnlarged,\n      enableChartHover,\n      onMouseMove,\n      hoveredDP,\n      isRanged,\n      ...chartProps\n    };\n\n    return (\n      <StyledRangePlot\n        style={{\n          height: `${isEnlarged ? theme.rangePlotContainerHLarge : theme.rangePlotContainerH}px`\n        }}\n        className=\"kg-range-slider__plot\"\n      >\n        {plotType === 'lineChart' && lineChart ? (\n          <LineChart lineChart={lineChart} {...commonProps} />\n        ) : (\n          <HistogramPlot histogram={histogram} {...commonProps} />\n        )}\n      </StyledRangePlot>\n    );\n  };\n\n  RangePlot.propTypes = {\n    value: PropTypes.arrayOf(PropTypes.number).isRequired,\n    histogram: PropTypes.arrayOf(\n      PropTypes.shape({\n        x0: PropTypes.number,\n        x1: PropTypes.number\n      })\n    ),\n    lineChart: PropTypes.object,\n    plotType: PropTypes.string,\n    isEnlarged: PropTypes.bool,\n    onBlur: PropTypes.func,\n    width: PropTypes.number.isRequired\n  };\n  return withTheme(RangePlot);\n}\n"]}