@kepler.gl/components 3.0.0-alpha.0

package/dist/common/range-brush.js

@@ -0,0 +1,346 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"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 _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _d3Selection = require("d3-selection");
+
+var _d3Brush = require("d3-brush");
+
+var _utils = require("@kepler.gl/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), "brushing", false);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "moving", false);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "root", _this.rootContainer.current ? (0, _d3Selection.select)(_this.rootContainer.current) : undefined);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "brush", void 0);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_startSel", void 0);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_lastSel", void 0);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handle", void 0);
+      (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],
+            _this$props$step = _this$props.step,
+            step = _this$props$step === void 0 ? 0 : _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, _utils.normalizeSliderValue)(d0, min, step, marks);
+        d1 = (0, _utils.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,
+            _this$root,
+            _this$root2;
+
+        // 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.root = this.rootContainer.current ? (0, _d3Selection.select)(this.rootContainer.current) : undefined;
+        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 = this.root) === null || _this$root === void 0 ? void 0 : _this$root.call(this.brush);
+        var brushResizePath = getHandlePath(this.props);
+        this.handle = (_this$root2 = this.root) === null || _this$root2 === void 0 ? void 0 : _this$root2.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) {
+          var _this$root3;
+
+          // width change should not trigger this._brushed
+          this.moving = true;
+          if (this.brush) (_this$root3 = this.root) === null || _this$root3 === void 0 ? void 0 : _this$root3.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) {
+          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() {
+        var val0 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+        var val1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+        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 && this.brush && this.handle) {
+          var scale = function scale(x) {
+            return (x - min) * width / (max - min);
+          };
+
+          if (!isRanged) {
+            // only draw a 1 pixel line
+            if (this.root) this.brush.move(this.root, [scale(val0), scale(val0) + 1]);
+          } else {
+            if (this.root) 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() {
+        var val0 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+        var val1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+        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, "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/common/range-brush.tsx"],"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","rootContainer","current","undefined","evt","sourceEvent","sel1","right","_startSel","range","min","max","step","width","marks","invert","d0","d1","_move","_onBrush","onMouseoverHandle","onMouseoutHandle","root","brush","handleSize","on","event","onBrushStart","moving","_lastSel","brushing","_brushed","_click","onBrushEnd","call","handle","selectAll","data","enter","append","attr","sliderHandleColor","value","val0","val1","prevProps","prevVal0","prevVal1","scale","move","i","currentVal0","currentVal1","onBrush","Component"],"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 styled, {withTheme} from 'styled-components';\nimport {select, Selection} from 'd3-selection';\nimport {BrushBehavior, brushX} from 'd3-brush';\nimport {normalizeSliderValue} from '@kepler.gl/utils';\n\ninterface StyledGProps {\n  isRanged?: boolean;\n}\n\nconst StyledG = styled.g<StyledGProps>`\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: RangeBrushProps) => {\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\nexport type OnBrush = (val0: number, val1: number) => void;\n\nexport interface RangeBrushProps {\n  isRanged?: boolean;\n  theme?: any;\n  range: number[];\n  value: number[];\n  onBrushStart: () => void;\n  onBrushEnd: () => void;\n  width: number;\n  height: number;\n  onBrush: OnBrush;\n  step?: number;\n  marks?: number[];\n  onMouseoverHandle: () => void;\n  onMouseoutHandle: () => void;\n}\n\nfunction RangeBrushFactory(): React.ComponentType<RangeBrushProps> {\n  class RangeBrush extends Component<RangeBrushProps> {\n    static defaultProps = {\n      isRanged: true\n    };\n\n    rootContainer = createRef<SVGGElement>();\n\n    brushing: boolean = false;\n    moving: boolean = false;\n\n    root = this.rootContainer.current ? select(this.rootContainer.current) : undefined;\n    brush: BrushBehavior<any> | undefined;\n    _startSel: number[] | undefined;\n    _lastSel: number[] | undefined;\n\n    handle: Selection<SVGPathElement, {type: string}, SVGGElement | null, unknown> | undefined;\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.root = this.rootContainer.current ? select(this.rootContainer.current) : undefined;\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        if (this.brush) 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 && this.handle) {\n        this.handle.attr('display', 'none');\n      }\n    }\n\n    _click(selection) {\n      // fake brush\n      this.brushing = true;\n      this._brushed({sourceEvent: {}, selection});\n    }\n\n    _move(val0: number = 0, val1: number = 0) {\n      const {\n        range: [min, max],\n        width,\n        isRanged\n      } = this.props;\n\n      if (width && max - min && this.brush && this.handle) {\n        const scale = (x: number) => ((x - min) * width) / (max - min);\n        if (!isRanged) {\n          // only draw a 1 pixel line\n          if (this.root) this.brush.move(this.root, [scale(val0), scale(val0) + 1]);\n        } else {\n          if (this.root) 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: {sourceEvent: any; selection: number[]}) => {\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 = 0,\n        width,\n        marks,\n        isRanged\n      } = this.props;\n      const invert = (x: number) => (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: number = 0, val1: number = 0) {\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/common/range-plot.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+import RangeBrushFactory, { OnBrush } from './range-brush';
+import HistogramPlotFactory from './histogram-plot';
+import LineChartFactory from './line-chart';
+import { LineChart } from '@kepler.gl/types';
+declare function RangePlotFactory(RangeBrush: ReturnType<typeof RangeBrushFactory>, HistogramPlot: ReturnType<typeof HistogramPlotFactory>, LineChartPlot: ReturnType<typeof LineChartFactory>): React.ForwardRefExoticComponent<{
+    height?: number | undefined;
+    width: number;
+    value: number[];
+    step?: number | undefined;
+    isRanged?: boolean | undefined;
+    range: number[];
+    onBrushStart?: (() => void) | undefined;
+    onBrushEnd?: (() => void) | undefined;
+    onBrush: OnBrush;
+    marks?: number[] | undefined;
+    onMouseoverHandle?: (() => void) | undefined;
+    onMouseoutHandle?: (() => void) | undefined;
+    histogram?: {
+        x0: number;
+        x1: number;
+    }[] | undefined;
+    isEnlarged?: boolean | undefined;
+    lineChart?: LineChart | undefined;
+    timezone?: string | null | undefined;
+    timeFormat?: string | undefined;
+    plotType?: string | undefined;
+    playbackControlWidth?: number | undefined;
+} & {
+    theme?: any;
+}>;
+declare namespace RangePlotFactory {
+    var deps: (typeof RangeBrushFactory | typeof HistogramPlotFactory | typeof LineChartFactory)[];
+}
+export default RangePlotFactory;

package/dist/common/range-plot.js

@@ -0,0 +1,156 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"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 _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("@kepler.gl/utils");
+
+var _styles = require("@kepler.gl/styles");
+
+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, LineChartPlot) {
+  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 ? (0, _utils.hasMobileWidth)(_styles.breakPointValues) ? theme.rangePlotHLargePalm : 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 ? (0, _utils.hasMobileWidth)(_styles.breakPointValues) ? theme.rangePlotContainerHLargePalm : theme.rangePlotContainerHLarge : theme.rangePlotContainerH, "px")
+      },
+      className: "kg-range-slider__plot"
+    }, plotType === 'lineChart' && lineChart ? /*#__PURE__*/_react["default"].createElement(LineChartPlot, (0, _extends2["default"])({
+      lineChart: lineChart
+    }, commonProps)) : /*#__PURE__*/_react["default"].createElement(HistogramPlot, (0, _extends2["default"])({
+      histogram: histogram
+    }, commonProps)));
+  };
+
+  return (0, _styledComponents.withTheme)(RangePlot);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/common/range-plot.tsx"],"names":["StyledRangePlot","styled","div","props","theme","sliderBarHeight","RangePlotFactory","deps","RangeBrushFactory","HistogramPlotFactory","LineChartFactory","RangeBrush","HistogramPlot","LineChartPlot","RangePlot","onBrush","range","value","width","plotType","lineChart","histogram","isEnlarged","isRanged","chartProps","brushing","setBrushing","hoveredDP","onMouseMove","enableChartHover","setEnableChartHover","height","breakPointValues","rangePlotHLargePalm","rangePlotHLarge","rangePlotH","onBrushStart","onBrushEnd","onMouseoverHandle","onMouseoutHandle","brushComponent","commonProps","margin","rangePlotMarginLarge","rangePlotMargin","rangePlotContainerHLargePalm","rangePlotContainerHLarge","rangePlotContainerH"],"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 styled, {withTheme} from 'styled-components';\nimport RangeBrushFactory, {OnBrush, RangeBrushProps} from './range-brush';\nimport HistogramPlotFactory from './histogram-plot';\nimport LineChartFactory, {HoverDP} from './line-chart';\nimport {isTest, hasMobileWidth} from '@kepler.gl/utils';\nimport {breakPointValues} from '@kepler.gl/styles';\nimport {LineChart} from '@kepler.gl/types';\n\nconst StyledRangePlot = styled.div`\n  margin-bottom: ${props => props.theme.sliderBarHeight}px;\n  display: flex;\n  position: 'relative';\n`;\n\ninterface RangePlotProps {\n  onBrush: OnBrush;\n  range: number[];\n  value: number[];\n  width: number;\n  plotType?: string;\n  lineChart?: LineChart;\n  histogram?: {x0: number; x1: number}[];\n  isEnlarged?: boolean;\n  isRanged?: boolean;\n  theme: any;\n  timeFormat?: string;\n  timezone?: string | null;\n  playbackControlWidth?: number;\n}\n\nRangePlotFactory.deps = [RangeBrushFactory, HistogramPlotFactory, LineChartFactory];\n\nexport default function RangePlotFactory(\n  RangeBrush: ReturnType<typeof RangeBrushFactory>,\n  HistogramPlot: ReturnType<typeof HistogramPlotFactory>,\n  LineChartPlot: ReturnType<typeof LineChartFactory>\n) {\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  }: RangePlotProps & Partial<RangeBrushProps>) => {\n    const [brushing, setBrushing] = useState(false);\n    const [hoveredDP, onMouseMove] = useState<HoverDP | null>(null);\n    const [enableChartHover, setEnableChartHover] = useState(false);\n    const height = isEnlarged\n      ? hasMobileWidth(breakPointValues)\n        ? theme.rangePlotHLargePalm\n        : theme.rangePlotHLarge\n      : 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: `${\n            isEnlarged\n              ? hasMobileWidth(breakPointValues)\n                ? theme.rangePlotContainerHLargePalm\n                : theme.rangePlotContainerHLarge\n              : theme.rangePlotContainerH\n          }px`\n        }}\n        className=\"kg-range-slider__plot\"\n      >\n        {plotType === 'lineChart' && lineChart ? (\n          <LineChartPlot lineChart={lineChart} {...commonProps} />\n        ) : (\n          <HistogramPlot histogram={histogram} {...commonProps} />\n        )}\n      </StyledRangePlot>\n    );\n  };\n\n  return withTheme(RangePlot);\n}\n"]}

package/dist/common/range-slider.d.ts

@@ -0,0 +1,30 @@
+import { ComponentType, ElementType } from 'react';
+import RangePlotFactory from './range-plot';
+import { LineChart } from '@kepler.gl/types';
+interface RangeSliderProps {
+    range?: number[];
+    value0: number;
+    value1: number;
+    onChange?: (val: number[]) => void;
+    histogram?: any[];
+    isRanged?: boolean;
+    isEnlarged?: boolean;
+    showInput?: boolean;
+    inputTheme?: string;
+    inputSize?: string;
+    step?: number;
+    sliderHandleWidth?: number;
+    xAxis?: ElementType;
+    timezone?: string | null;
+    timeFormat?: string;
+    playbackControlWidth?: number;
+    lineChart?: LineChart;
+    marks?: number[];
+    plotType?: string;
+    plotValue?: number[];
+}
+declare function RangeSliderFactory(RangePlot: ReturnType<typeof RangePlotFactory>): ComponentType<RangeSliderProps>;
+declare namespace RangeSliderFactory {
+    var deps: (typeof RangePlotFactory)[];
+}
+export default RangeSliderFactory;