@kepler.gl/components 3.1.0-alpha.0 → 3.1.0-alpha.2

package/dist/common/slider/slider.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _sliderHandle = _interopRequireDefault(require("./slider-handle"));
+var _sliderBarHandle = _interopRequireDefault(require("./slider-bar-handle"));
+var _utils = require("@kepler.gl/utils");
+var _templateObject, _templateObject2; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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) { (0, _defineProperty2["default"])(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; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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 noop() {
+  return;
+}
+var StyledRangeSlider = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  position: relative;\n  background-color: ", ";\n  ", ";\n  ", ";\n"])), function (props) {
+  return props.theme.sliderBarBgd;
+}, function (props) {
+  return "".concat(props.vertical ? 'width' : 'height', ": ").concat(props.theme.sliderBarHeight, "px");
+}, function (props) {
+  return "".concat(props.vertical ? 'height' : 'width', ": 100%");
+});
+var SliderWrapper = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  flex-grow: 1;\n"])));
+var Slider = exports["default"] = /*#__PURE__*/function (_Component) {
+  function Slider(props) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, Slider);
+    _this = _callSuper(this, Slider, [props]);
+    (0, _defineProperty2["default"])(_this, "anchor", 0);
+    (0, _defineProperty2["default"])(_this, "ref", /*#__PURE__*/(0, _react.createRef)());
+    (0, _defineProperty2["default"])(_this, "track", /*#__PURE__*/(0, _react.createRef)());
+    (0, _defineProperty2["default"])(_this, "setAnchor", function (x) {
+      // used to calculate delta
+      _this.anchor = x;
+    });
+    (0, _defineProperty2["default"])(_this, "slide0Listener", function (x) {
+      var _this$props = _this.props,
+        value1 = _this$props.value1,
+        minValue = _this$props.minValue;
+      var val = _this.getValue(minValue, x);
+      _this.props.onSlider0Change((0, _utils.clamp)([minValue, value1], val));
+    });
+    (0, _defineProperty2["default"])(_this, "slide1Listener", function (x) {
+      var _this$props2 = _this.props,
+        minValue = _this$props2.minValue,
+        maxValue = _this$props2.maxValue,
+        value0 = _this$props2.value0;
+      var val = _this.getValue(minValue, x);
+      _this.props.onSlider1Change((0, _utils.clamp)([value0, maxValue], val));
+    });
+    (0, _defineProperty2["default"])(_this, "sliderBarListener", function (x) {
+      var _this$props3 = _this.props,
+        value0 = _this$props3.value0,
+        value1 = _this$props3.value1,
+        minValue = _this$props3.minValue,
+        maxValue = _this$props3.maxValue;
+      // for slider bar, we use distance delta
+      var anchor = _this.anchor;
+      var length = value1 - value0; // the length of the selected range shouldn't change when clamping
+      var val0 = (0, _utils.clamp)([minValue, maxValue - length], _this.getValue(value0, x - anchor));
+      var val1 = (0, _utils.clamp)([val0 + length, maxValue], _this.getValue(value1, x - anchor));
+      var deltaX = _this.getDeltaX(val0 - _this.props.value0);
+      _this.props.onSliderBarChange(val0, val1);
+      // update anchor
+      _this.anchor = _this.anchor + deltaX;
+    });
+    (0, _defineProperty2["default"])(_this, "calcHandleLeft0", function (w, l) {
+      return w === 0 ? "calc(".concat(l, "% - ").concat(_this.props.sliderHandleWidth / 2, "px)") : "calc(".concat(l, "% - ").concat(_this.props.sliderHandleWidth / 2, "px)");
+    });
+    (0, _defineProperty2["default"])(_this, "calcHandleLeft1", function (w, l) {
+      return _this.props.isRanged && w === 0 ? "".concat(l, "%") : "calc(".concat(l + w, "% - ").concat(_this.props.sliderHandleWidth / 2, "px)");
+    });
+    _this.props = props;
+    return _this;
+  }
+  (0, _inherits2["default"])(Slider, _Component);
+  return (0, _createClass2["default"])(Slider, [{
+    key: "getBaseDistance",
+    value: function getBaseDistance() {
+      if (!this.ref.current) {
+        return 0;
+      }
+      return this.props.vertical ? this.ref.current.offsetHeight : this.ref.current.offsetWidth;
+    }
+  }, {
+    key: "getDeltaVal",
+    value: function getDeltaVal(x) {
+      var percent = x / this.getBaseDistance();
+      var maxDelta = this.props.maxValue - this.props.minValue;
+      return percent * maxDelta;
+    }
+  }, {
+    key: "getDeltaX",
+    value: function getDeltaX(v) {
+      var percent = v / (this.props.maxValue - this.props.minValue);
+      var maxDelta = this.getBaseDistance();
+      return percent * maxDelta;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(baseV, offset) {
+      // offset is the distance between slider handle and track left
+      var rawValue = baseV + this.getDeltaVal(offset);
+      return this.normalizeValue(rawValue);
+    }
+  }, {
+    key: "normalizeValue",
+    value: function normalizeValue(val) {
+      var _this$props4 = this.props,
+        minValue = _this$props4.minValue,
+        step = _this$props4.step,
+        marks = _this$props4.marks;
+      return (0, _utils.normalizeSliderValue)(val, minValue, step, marks);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+        className = _this$props5.className,
+        classSet = _this$props5.classSet,
+        disabled = _this$props5.disabled,
+        isRanged = _this$props5.isRanged,
+        maxValue = _this$props5.maxValue,
+        minValue = _this$props5.minValue,
+        value1 = _this$props5.value1,
+        vertical = _this$props5.vertical,
+        sliderHandleWidth = _this$props5.sliderHandleWidth,
+        showTooltip = _this$props5.showTooltip,
+        style = _this$props5.style;
+      var value0 = !isRanged && minValue > 0 ? minValue : this.props.value0;
+      var currValDelta = value1 - value0;
+      var maxDelta = maxValue - minValue;
+      var width = currValDelta / maxDelta * 100;
+      var v0Left = (value0 - minValue) / maxDelta * 100;
+      return /*#__PURE__*/_react["default"].createElement(SliderWrapper, {
+        className: (0, _classnames["default"])('kg-slider', _objectSpread(_objectSpread({}, classSet), {}, {
+          disabled: disabled
+        }), className),
+        ref: this.ref,
+        isRanged: isRanged,
+        vertical: vertical,
+        style: style
+      }, /*#__PURE__*/_react["default"].createElement(StyledRangeSlider, {
+        className: "kg-range-slider",
+        vertical: vertical,
+        ref: this.track
+      }, /*#__PURE__*/_react["default"].createElement(_sliderHandle["default"], {
+        left: this.calcHandleLeft0(width, v0Left),
+        valueListener: this.slide0Listener,
+        sliderHandleWidth: sliderHandleWidth,
+        display: isRanged,
+        vertical: vertical,
+        showTooltip: showTooltip,
+        track: this.track
+      }), /*#__PURE__*/_react["default"].createElement(_sliderHandle["default"], {
+        left: this.calcHandleLeft1(width, v0Left),
+        valueListener: this.slide1Listener,
+        sliderHandleWidth: sliderHandleWidth,
+        vertical: vertical,
+        value: value1,
+        showTooltip: showTooltip,
+        track: this.track
+      }), /*#__PURE__*/_react["default"].createElement(_sliderBarHandle["default"], {
+        width: width,
+        v0Left: v0Left,
+        enableBarDrag: this.props.enableBarDrag,
+        sliderBarListener: this.sliderBarListener,
+        vertical: vertical,
+        track: this.track,
+        setAnchor: this.setAnchor
+      })));
+    }
+  }]);
+}(_react.Component);
+(0, _defineProperty2["default"])(Slider, "defaultProps", {
+  title: '',
+  isRanged: true,
+  value0: 0,
+  value1: 100,
+  minValue: 0,
+  maxValue: 100,
+  step: 1,
+  sliderHandleWidth: 12,
+  enableBarDrag: false,
+  onSlider0Change: noop,
+  onSlider1Change: noop,
+  onSliderBarChange: noop,
+  disabled: false,
+  vertical: false,
+  showTooltip: false
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_classnames","_interopRequireDefault","_styledComponents","_sliderHandle","_sliderBarHandle","_utils","_templateObject","_templateObject2","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","Boolean","prototype","valueOf","noop","StyledRangeSlider","styled","div","_taggedTemplateLiteral2","props","theme","sliderBarBgd","concat","vertical","sliderBarHeight","SliderWrapper","Slider","exports","_Component","_this","_classCallCheck2","createRef","x","anchor","_this$props","value1","minValue","val","getValue","onSlider0Change","clamp","_this$props2","maxValue","value0","onSlider1Change","_this$props3","val0","val1","deltaX","getDeltaX","onSliderBarChange","w","l","sliderHandleWidth","isRanged","_inherits2","_createClass2","key","value","getBaseDistance","ref","current","offsetHeight","offsetWidth","getDeltaVal","percent","maxDelta","v","baseV","offset","rawValue","normalizeValue","_this$props4","step","marks","normalizeSliderValue","render","_this$props5","className","classSet","disabled","showTooltip","style","currValDelta","width","v0Left","createElement","classnames","track","left","calcHandleLeft0","valueListener","slide0Listener","display","calcHandleLeft1","slide1Listener","enableBarDrag","sliderBarListener","setAnchor","Component","title"],"sources":["../../../src/common/slider/slider.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef, RefObject} from 'react';\nimport classnames from 'classnames';\nimport styled from 'styled-components';\n\nimport SliderHandle from './slider-handle';\nimport SliderBarHandle from './slider-bar-handle';\nimport {normalizeSliderValue, clamp} from '@kepler.gl/utils';\n\nfunction noop() {\n  return;\n}\n\ninterface StyledRangeSliderProps {\n  vertical?: boolean;\n}\n\nconst StyledRangeSlider = styled.div<StyledRangeSliderProps>`\n  position: relative;\n  background-color: ${props => props.theme.sliderBarBgd};\n  ${props => `${props.vertical ? 'width' : 'height'}: ${props.theme.sliderBarHeight}px`};\n  ${props => `${props.vertical ? 'height' : 'width'}: 100%`};\n`;\n\nexport type StyleRangeSliderType = typeof StyledRangeSlider & HTMLDivElement;\n\ninterface SliderWrapperProps {\n  isRanged?: boolean;\n  vertical?: boolean;\n}\n\nconst SliderWrapper = styled.div<SliderWrapperProps>`\n  flex-grow: 1;\n`;\n\ntype SliderProps = {\n  title: string;\n  isRanged: boolean;\n  value0: number;\n  value1: number;\n  minValue: number;\n  maxValue: number;\n  sliderHandleWidth: number;\n  onSlider0Change: (val: number) => any;\n  onSlider1Change: (val: number) => any;\n  onSliderBarChange: (val0: number, val1: number) => void;\n  step: number;\n  enableBarDrag: boolean;\n  showTooltip: boolean;\n  vertical: boolean;\n  marks?: number[] | null;\n  classSet?: {[key: string]: boolean};\n  disabled: boolean;\n  className?: string;\n  style?: object;\n};\n\nexport default class Slider extends Component<SliderProps> {\n  static defaultProps = {\n    title: '',\n    isRanged: true,\n    value0: 0,\n    value1: 100,\n    minValue: 0,\n    maxValue: 100,\n    step: 1,\n    sliderHandleWidth: 12,\n    enableBarDrag: false,\n    onSlider0Change: noop,\n    onSlider1Change: noop,\n    onSliderBarChange: noop,\n    disabled: false,\n    vertical: false,\n    showTooltip: false\n  };\n\n  private anchor = 0;\n\n  public ref: RefObject<typeof SliderWrapper & HTMLDivElement> = createRef<\n    typeof SliderWrapper & HTMLDivElement\n  >();\n  public track: RefObject<StyleRangeSliderType> = createRef<StyleRangeSliderType>();\n\n  constructor(public props: SliderProps) {\n    super(props);\n  }\n\n  private setAnchor = (x: number) => {\n    // used to calculate delta\n    this.anchor = x;\n  };\n\n  private getBaseDistance() {\n    if (!this.ref.current) {\n      return 0;\n    }\n    return this.props.vertical ? this.ref.current.offsetHeight : this.ref.current.offsetWidth;\n  }\n\n  private getDeltaVal(x: number) {\n    const percent = x / this.getBaseDistance();\n    const maxDelta = this.props.maxValue - this.props.minValue;\n    return percent * maxDelta;\n  }\n  private getDeltaX(v: number) {\n    const percent = v / (this.props.maxValue - this.props.minValue);\n    const maxDelta = this.getBaseDistance();\n    return percent * maxDelta;\n  }\n\n  private getValue(baseV: number, offset: number) {\n    // offset is the distance between slider handle and track left\n    const rawValue = baseV + this.getDeltaVal(offset);\n\n    return this.normalizeValue(rawValue);\n  }\n\n  private normalizeValue(val: number) {\n    const {minValue, step, marks} = this.props;\n    return normalizeSliderValue(val, minValue, step, marks);\n  }\n\n  slide0Listener = (x: number) => {\n    const {value1, minValue} = this.props;\n    const val = this.getValue(minValue, x);\n    this.props.onSlider0Change(clamp([minValue, value1], val));\n  };\n\n  slide1Listener = (x: number) => {\n    const {minValue, maxValue, value0} = this.props;\n    const val = this.getValue(minValue, x);\n    this.props.onSlider1Change(clamp([value0, maxValue], val));\n  };\n\n  sliderBarListener = (x: number) => {\n    const {value0, value1, minValue, maxValue} = this.props;\n    // for slider bar, we use distance delta\n    const anchor = this.anchor;\n    const length = value1 - value0; // the length of the selected range shouldn't change when clamping\n    const val0 = clamp([minValue, maxValue - length], this.getValue(value0, x - anchor));\n    const val1 = clamp([val0 + length, maxValue], this.getValue(value1, x - anchor));\n\n    const deltaX = this.getDeltaX(val0 - this.props.value0);\n    this.props.onSliderBarChange(val0, val1);\n    // update anchor\n    this.anchor = this.anchor + deltaX;\n  };\n\n  calcHandleLeft0 = (w: number, l: number) => {\n    return w === 0\n      ? `calc(${l}% - ${this.props.sliderHandleWidth / 2}px)`\n      : `calc(${l}% - ${this.props.sliderHandleWidth / 2}px)`;\n  };\n\n  calcHandleLeft1 = (w: number, l: number) => {\n    return this.props.isRanged && w === 0\n      ? `${l}%`\n      : `calc(${l + w}% - ${this.props.sliderHandleWidth / 2}px)`;\n  };\n\n  render() {\n    const {\n      className,\n      classSet,\n      disabled,\n      isRanged,\n      maxValue,\n      minValue,\n      value1,\n      vertical,\n      sliderHandleWidth,\n      showTooltip,\n      style\n    } = this.props;\n    const value0 = !isRanged && minValue > 0 ? minValue : this.props.value0;\n    const currValDelta = value1 - value0;\n    const maxDelta = maxValue - minValue;\n    const width = (currValDelta / maxDelta) * 100;\n\n    const v0Left = ((value0 - minValue) / maxDelta) * 100;\n\n    return (\n      <SliderWrapper\n        className={classnames('kg-slider', {...classSet, disabled}, className)}\n        ref={this.ref}\n        isRanged={isRanged}\n        vertical={vertical}\n        style={style}\n      >\n        <StyledRangeSlider className=\"kg-range-slider\" vertical={vertical} ref={this.track}>\n          <SliderHandle\n            left={this.calcHandleLeft0(width, v0Left)}\n            valueListener={this.slide0Listener}\n            sliderHandleWidth={sliderHandleWidth}\n            display={isRanged}\n            vertical={vertical}\n            showTooltip={showTooltip}\n            track={this.track}\n          />\n          <SliderHandle\n            left={this.calcHandleLeft1(width, v0Left)}\n            valueListener={this.slide1Listener}\n            sliderHandleWidth={sliderHandleWidth}\n            vertical={vertical}\n            value={value1}\n            showTooltip={showTooltip}\n            track={this.track}\n          />\n          <SliderBarHandle\n            width={width}\n            v0Left={v0Left}\n            enableBarDrag={this.props.enableBarDrag}\n            sliderBarListener={this.sliderBarListener}\n            vertical={vertical}\n            track={this.track}\n            setAnchor={this.setAnchor}\n          />\n        </StyledRangeSlider>\n      </SliderWrapper>\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/common/styled-components.d.ts

@@ -0,0 +1,159 @@
+/// <reference types="react" />
+import { RGBColor } from '@kepler.gl/types';
+import ReactTooltip from 'react-tooltip';
+export declare const SelectText: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const SelectTextBold: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const IconRoundSmall: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CenterFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CenterVerticalFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const EndHorizontalFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SpaceBetweenFlexbox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SBFlexboxItem: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SBFlexboxNoMargin: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const PanelLabel: import("styled-components").StyledComponent<"label", any, {
+    className: "side-panel-panel__label";
+}, "className">;
+export declare const PanelLabelWrapper: import("styled-components").StyledComponent<"div", any, {
+    className: "side-panel-panel__label-wrapper";
+}, "className">;
+export declare const PanelLabelBold: import("styled-components").StyledComponent<"label", any, {
+    className: "side-panel-panel__label";
+}, "className">;
+export declare const PanelHeaderTitle: import("styled-components").StyledComponent<"span", any, {
+    className: string;
+}, "className">;
+export declare const PanelHeaderContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const PanelContent: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+}, "className">;
+interface SidePanelSectionProps {
+    disabled?: boolean;
+}
+export declare const SidePanelSection: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+} & SidePanelSectionProps, "className">;
+export declare const SidePanelDivider: import("styled-components").StyledComponent<"div", any, {
+    className: "side-panel-divider";
+}, "className">;
+export declare const Tooltip: import("styled-components").StyledComponent<typeof ReactTooltip, any, {}, never>;
+export declare type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    className?: string;
+    ref?: React.ForwardedRef<HTMLElement>;
+    children?: React.ReactNode;
+    negative?: boolean;
+    secondary?: boolean;
+    link?: boolean;
+    floating?: boolean;
+    cta?: boolean;
+    large?: boolean;
+    small?: boolean;
+    disabled?: boolean;
+    width?: string;
+    inactive?: boolean;
+};
+export declare const Button: import("styled-components").StyledComponent<"button", any, {
+    className: string;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    className?: string | undefined;
+    ref?: import("react").ForwardedRef<HTMLElement> | undefined;
+    children?: React.ReactNode;
+    negative?: boolean | undefined;
+    secondary?: boolean | undefined;
+    link?: boolean | undefined;
+    floating?: boolean | undefined;
+    cta?: boolean | undefined;
+    large?: boolean | undefined;
+    small?: boolean | undefined;
+    disabled?: boolean | undefined;
+    width?: string | undefined;
+    inactive?: boolean | undefined;
+}, "className">;
+interface InputProps {
+    secondary?: boolean;
+}
+export declare const Input: import("styled-components").StyledComponent<"input", any, InputProps, never>;
+export declare const InputLight: import("styled-components").StyledComponent<"input", any, {}, never>;
+export declare const TextArea: import("styled-components").StyledComponent<"textarea", any, InputProps, never>;
+export declare const TextAreaLight: import("styled-components").StyledComponent<"textarea", any, {}, never>;
+export declare const InlineInput: import("styled-components").StyledComponent<"input", any, InputProps, never>;
+export interface StyledPanelHeaderProps {
+    active?: boolean;
+    labelRCGColorValues?: RGBColor | null;
+    warning?: boolean;
+    isValid?: boolean;
+}
+export declare const StyledPanelHeader: import("styled-components").StyledComponent<"div", any, StyledPanelHeaderProps, never>;
+interface StyledPanelDropdownProps {
+    type?: string;
+}
+export declare const StyledPanelDropdown: import("styled-components").StyledComponent<"div", any, StyledPanelDropdownProps, never>;
+export declare const ButtonGroup: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface DatasetSquareProps {
+    backgroundColor: RGBColor;
+}
+export declare const DatasetSquare: import("styled-components").StyledComponent<"div", any, DatasetSquareProps, never>;
+interface SelectionButtonProps {
+    selected?: boolean;
+}
+export declare const SelectionButton: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const StyledTable: import("styled-components").StyledComponent<"table", any, {}, never>;
+export declare const StyledModalContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledModalVerticalPanel: import("styled-components").StyledComponent<"div", any, {
+    className: "modal-vertical-panel";
+}, "className">;
+export declare const StyledModalSection: import("styled-components").StyledComponent<"div", any, {
+    className: string;
+}, "className">;
+interface StyledModalInputFootnoteProps {
+    error?: boolean;
+}
+export declare const StyledModalInputFootnote: import("styled-components").StyledComponent<"div", any, {
+    className: "modal-input__footnote";
+} & StyledModalInputFootnoteProps, "className">;
+/**
+ * Newer versions of mapbox.gl display an error message banner on top of the map by default
+ * which will cause the map to display points in the wrong locations
+ * This workaround will hide the error banner.
+ */
+export declare const StyledMapContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledAttrbution: import("styled-components").StyledComponent<"div", any, {
+    className: "maplibre-attribution-container";
+}, "className">;
+export interface StyledExportSectionProps {
+    disabled?: boolean;
+}
+export declare const StyledExportSection: import("styled-components").StyledComponent<"div", any, StyledExportSectionProps, never>;
+export declare const StyledFilteredOption: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const StyledType: import("styled-components").StyledComponent<"div", any, SelectionButtonProps, never>;
+export declare const WidgetContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const BottomWidgetInner: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface MapControlButtonProps {
+    active?: boolean;
+}
+export declare const MapControlButton: import("styled-components").StyledComponent<"button", any, {
+    className: string;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    className?: string | undefined;
+    ref?: import("react").ForwardedRef<HTMLElement> | undefined;
+    children?: React.ReactNode;
+    negative?: boolean | undefined;
+    secondary?: boolean | undefined;
+    link?: boolean | undefined;
+    floating?: boolean | undefined;
+    cta?: boolean | undefined;
+    large?: boolean | undefined;
+    small?: boolean | undefined;
+    disabled?: boolean | undefined;
+    width?: string | undefined;
+    inactive?: boolean | undefined;
+} & {
+    className: string;
+} & MapControlButtonProps, "className">;
+export declare const StyledFilterContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const TruncatedTitleText: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CheckMark: import("styled-components").StyledComponent<"span", any, {
+    className: "checkbox-inner";
+}, "className">;
+export declare const StyledTimePicker: import("styled-components").StyledComponent<import("react").FC<import("react-time-picker").TimePickerProps>, any, {}, never>;
+export declare const StyledDatePicker: import("styled-components").StyledComponent<import("react").FC<import("react-date-picker").DatePickerProps>, any, {}, never>;
+export {};