@kepler.gl/components 3.0.0-alpha.0 → 3.0.0-alpha.1

package/dist/effects/effect-time-configurator.js

@@ -0,0 +1,191 @@
+// Copyright (c) 2023 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"] = EffectTimeConfiguratorFactory;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _utils = require("@kepler.gl/utils");
+
+var _styledComponents2 = require("../common/styled-components");
+
+var _rangeSlider = _interopRequireDefault(require("../common/range-slider"));
+
+var _checkbox = _interopRequireDefault(require("../common/checkbox"));
+
+var _button = _interopRequireDefault(require("../common/data-table/button"));
+
+var _icons = require("../common/icons");
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6;
+
+var DAY_SLIDER_RANGE = 1000 * 60 * 60 * 24;
+
+var StyledWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  padding-left: 5px;\n  padding-right: 5px;\n  margin-bottom: 9px;\n  opacity: ", ";\n  ", "\n"])), function (props) {
+  return props.disabled ? 0.3 : 1;
+}, function (props) {
+  return props.disabled ? 'pointer-events: none;' : '';
+});
+
+var SliderWrapper = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-top: 13px;\n  margin-right: 8px;\n  margin-bottom: 17px;\n\n  opacity: ", ";\n  ", "\n"])), function (props) {
+  return props.disabled ? 0.3 : 1;
+}, function (props) {
+  return props.disabled ? 'pointer-events: none;' : '';
+});
+
+var StyledButton = (0, _styledComponents["default"])(_button["default"])(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  background-color: ", ";\n  height: 31px;\n  padding: 5px;\n  border-radius: 2px;\n  :hover {\n    background-color: ", ";\n  }\n"])), function (props) {
+  return props.theme.textColor;
+}, function (props) {
+  return props.theme.inputBgd;
+}, function (props) {
+  return props.theme.inputBgdHover;
+});
+var StyledRadio = (0, _styledComponents["default"])(_checkbox["default"])(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  .kg-checkbox__label {\n    font-family: ", ";\n    font-size: ", ";\n  }\n  .kg-checkbox__label:before {\n    background-color: ", ";\n  }\n"])), function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.inputFontSize;
+}, function (props) {
+  return props.theme.inputBgdHover;
+});
+
+var StyledLabelWrapper = _styledComponents["default"].div(_templateObject5 || (_templateObject5 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  margin-right: 10px;\n"])), function (props) {
+  return props.theme.textColor;
+});
+
+var StyledEffectTimeConfigurator = _styledComponents["default"].div(_templateObject6 || (_templateObject6 = (0, _taggedTemplateLiteral2["default"])(["\n  border-left: 3px solid ", ";\n  margin-bottom: 8px;\n  margin-top: 3px;\n  margin-left: 3px;\n"])), function (props) {
+  return props.theme.panelBorderColor;
+});
+
+EffectTimeConfiguratorFactory.deps = [_rangeSlider["default"]];
+
+function EffectTimeConfiguratorFactory(RangeSlider) {
+  var EffectTimeConfigurator = function EffectTimeConfigurator(_ref) {
+    var timestamp = _ref.timestamp,
+        useCurrentTime = _ref.useCurrentTime,
+        onDateTimeChange = _ref.onDateTimeChange,
+        onUseCurrentTimeChange = _ref.onUseCurrentTimeChange;
+
+    var _useMemo = (0, _react.useMemo)(function () {
+      var date = new Date(timestamp);
+      var h = date.getHours();
+      var m = date.getMinutes();
+      var timeString = "".concat(h < 10 ? "0".concat(h) : "".concat(h), ":").concat(m < 10 ? "0".concat(m) : "".concat(m));
+      return [date, timeString];
+    }, [timestamp]),
+        _useMemo2 = (0, _slicedToArray2["default"])(_useMemo, 2),
+        selectedDate = _useMemo2[0],
+        selectedTimeString = _useMemo2[1];
+
+    var timeSliderValue = (0, _react.useMemo)(function () {
+      var base = new Date(timestamp).setHours(0, 0, 0).valueOf();
+      return (0, _utils.clamp)([0, 1], (parseInt(timestamp) - base) / DAY_SLIDER_RANGE);
+    }, [timestamp, selectedDate]);
+    var timeSliderProps = (0, _react.useMemo)(function () {
+      return {
+        label: 'value',
+        value1: timeSliderValue,
+        step: 0.001,
+        range: [0, 1],
+        value0: 0,
+        onChange: function onChange(value) {
+          var start = new Date(timestamp).setHours(0, 0, 0).valueOf();
+          onDateTimeChange(Math.floor(start + DAY_SLIDER_RANGE * (0, _utils.clamp)([0, 0.9999], value[1])));
+        },
+        showInput: false,
+        isRanged: false
+      };
+    }, [timeSliderValue, timestamp, onDateTimeChange]);
+    var setDate = (0, _react.useCallback)(function (newDate) {
+      onDateTimeChange(Math.floor(newDate.valueOf() + DAY_SLIDER_RANGE * timeSliderValue));
+    }, [timeSliderValue, onDateTimeChange]);
+    var setTime = (0, _react.useCallback)(function (time) {
+      var conf = time.split(':');
+      var start = new Date(timestamp).setHours(conf[0], conf[1]).valueOf();
+      onDateTimeChange(start);
+    }, [timestamp, onDateTimeChange]);
+    var setCurrentDateTime = (0, _react.useCallback)(function () {
+      onDateTimeChange(new Date().valueOf());
+    }, [onDateTimeChange]);
+    return /*#__PURE__*/_react["default"].createElement(StyledEffectTimeConfigurator, null, /*#__PURE__*/_react["default"].createElement(StyledWrapper, null, /*#__PURE__*/_react["default"].createElement(StyledRadio, {
+      type: "radio",
+      checked: !useCurrentTime,
+      id: "effect-time-toggle-use-pick",
+      label: 'Pick date/time',
+      onChange: function onChange() {
+        onUseCurrentTimeChange(false);
+      }
+    })), /*#__PURE__*/_react["default"].createElement(StyledWrapper, {
+      disabled: useCurrentTime
+    }, /*#__PURE__*/_react["default"].createElement(StyledButton, {
+      onClick: setCurrentDateTime,
+      "data-for": "pick-time-button",
+      "data-tip": true
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Pin, {
+      height: "15px"
+    }), /*#__PURE__*/_react["default"].createElement(_styledComponents2.Tooltip, {
+      id: "pick-time-button",
+      effect: "solid",
+      place: "top",
+      delayShow: 500
+    }, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'Pick current time'
+    }))), /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledDatePicker, {
+      value: selectedDate,
+      onChange: setDate
+    }), /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledTimePicker, {
+      value: selectedTimeString,
+      onChange: setTime,
+      disableClock: true,
+      format: 'hh:mm a'
+    }), /*#__PURE__*/_react["default"].createElement(StyledLabelWrapper, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'UTC'
+    }))), /*#__PURE__*/_react["default"].createElement(SliderWrapper, {
+      disabled: useCurrentTime
+    }, /*#__PURE__*/_react["default"].createElement(RangeSlider, timeSliderProps)), /*#__PURE__*/_react["default"].createElement(StyledWrapper, null, /*#__PURE__*/_react["default"].createElement(StyledRadio, {
+      type: "radio",
+      checked: useCurrentTime,
+      id: "effect-time-toggle-use-current",
+      label: 'Current time',
+      onChange: function onChange() {
+        onUseCurrentTimeChange(true);
+      }
+    })));
+  };
+
+  return EffectTimeConfigurator;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/effects/effect-time-configurator.tsx"],"names":["DAY_SLIDER_RANGE","StyledWrapper","styled","div","props","disabled","SliderWrapper","StyledButton","Button","theme","textColor","inputBgd","inputBgdHover","StyledRadio","Checkbox","fontFamily","inputFontSize","StyledLabelWrapper","StyledEffectTimeConfigurator","panelBorderColor","EffectTimeConfiguratorFactory","deps","RangeSliderFactory","RangeSlider","EffectTimeConfigurator","timestamp","useCurrentTime","onDateTimeChange","onUseCurrentTimeChange","date","Date","h","getHours","m","getMinutes","timeString","selectedDate","selectedTimeString","timeSliderValue","base","setHours","valueOf","parseInt","timeSliderProps","label","value1","step","range","value0","onChange","value","start","Math","floor","showInput","isRanged","setDate","newDate","setTime","time","conf","split","setCurrentDateTime"],"mappings":"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","sourcesContent":["import React, {useCallback, useMemo} from 'react';\nimport styled from 'styled-components';\n\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {clamp} from '@kepler.gl/utils';\n\nimport {StyledTimePicker, StyledDatePicker, Tooltip} from '../common/styled-components';\nimport RangeSliderFactory from '../common/range-slider';\nimport Checkbox from '../common/checkbox';\nimport Button from '../common/data-table/button';\nimport {Pin} from '../common/icons';\n\nconst DAY_SLIDER_RANGE = 1000 * 60 * 60 * 24;\n\nexport type EffectTimeConfiguratorProps = {\n  timestamp: string;\n  onDateTimeChange: (time: number) => void;\n  useCurrentTime: boolean;\n  onUseCurrentTimeChange: (value: boolean) => void;\n};\n\ntype StyledWrapperProps = {disabled?: boolean};\nconst StyledWrapper = styled.div<StyledWrapperProps>`\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  padding-left: 5px;\n  padding-right: 5px;\n  margin-bottom: 9px;\n  opacity: ${props => (props.disabled ? 0.3 : 1)};\n  ${props => (props.disabled ? 'pointer-events: none;' : '')}\n`;\n\ntype SliderWrapperProps = {disabled?: boolean};\nconst SliderWrapper = styled.div<SliderWrapperProps>`\n  margin-top: 13px;\n  margin-right: 8px;\n  margin-bottom: 17px;\n\n  opacity: ${props => (props.disabled ? 0.3 : 1)};\n  ${props => (props.disabled ? 'pointer-events: none;' : '')}\n`;\n\nconst StyledButton = styled(Button)`\n  color: ${props => props.theme.textColor};\n  background-color: ${props => props.theme.inputBgd};\n  height: 31px;\n  padding: 5px;\n  border-radius: 2px;\n  :hover {\n    background-color: ${props => props.theme.inputBgdHover};\n  }\n`;\n\nconst StyledRadio = styled(Checkbox)`\n  .kg-checkbox__label {\n    font-family: ${props => props.theme.fontFamily};\n    font-size: ${props => props.theme.inputFontSize};\n  }\n  .kg-checkbox__label:before {\n    background-color: ${props => props.theme.inputBgdHover};\n  }\n`;\n\nconst StyledLabelWrapper = styled.div`\n  color: ${props => props.theme.textColor};\n  margin-right: 10px;\n`;\n\nconst StyledEffectTimeConfigurator = styled.div`\n  border-left: 3px solid ${props => props.theme.panelBorderColor};\n  margin-bottom: 8px;\n  margin-top: 3px;\n  margin-left: 3px;\n`;\n\nEffectTimeConfiguratorFactory.deps = [RangeSliderFactory];\n\nexport default function EffectTimeConfiguratorFactory(\n  RangeSlider: ReturnType<typeof RangeSliderFactory>\n): React.FC<EffectTimeConfiguratorProps> {\n  const EffectTimeConfigurator = ({\n    timestamp,\n    useCurrentTime,\n    onDateTimeChange,\n    onUseCurrentTimeChange\n  }: EffectTimeConfiguratorProps) => {\n    const [selectedDate, selectedTimeString] = useMemo(() => {\n      const date = new Date(timestamp);\n\n      const h = date.getHours();\n      const m = date.getMinutes();\n      const timeString = `${h < 10 ? `0${h}` : `${h}`}:${m < 10 ? `0${m}` : `${m}`}`;\n\n      return [date, timeString];\n    }, [timestamp]);\n\n    const timeSliderValue = useMemo(() => {\n      const base = new Date(timestamp).setHours(0, 0, 0).valueOf();\n      return clamp([0, 1], (parseInt(timestamp) - base) / DAY_SLIDER_RANGE);\n    }, [timestamp, selectedDate]);\n\n    const timeSliderProps = useMemo(() => {\n      return {\n        label: 'value',\n        value1: timeSliderValue,\n        step: 0.001,\n        range: [0, 1],\n        value0: 0,\n        onChange: value => {\n          const start = new Date(timestamp).setHours(0, 0, 0).valueOf();\n          onDateTimeChange(Math.floor(start + DAY_SLIDER_RANGE * clamp([0, 0.9999], value[1])));\n        },\n        showInput: false,\n        isRanged: false\n      };\n    }, [timeSliderValue, timestamp, onDateTimeChange]);\n\n    const setDate = useCallback(\n      newDate => {\n        onDateTimeChange(Math.floor(newDate.valueOf() + DAY_SLIDER_RANGE * timeSliderValue));\n      },\n      [timeSliderValue, onDateTimeChange]\n    );\n\n    const setTime = useCallback(\n      time => {\n        const conf = time.split(':');\n        const start = new Date(timestamp).setHours(conf[0], conf[1]).valueOf();\n        onDateTimeChange(start);\n      },\n      [timestamp, onDateTimeChange]\n    );\n\n    const setCurrentDateTime = useCallback(() => {\n      onDateTimeChange(new Date().valueOf());\n    }, [onDateTimeChange]);\n\n    return (\n      <StyledEffectTimeConfigurator>\n        <StyledWrapper>\n          <StyledRadio\n            type=\"radio\"\n            checked={!useCurrentTime}\n            id={`effect-time-toggle-use-pick`}\n            label={'Pick date/time'}\n            onChange={() => {\n              onUseCurrentTimeChange(false);\n            }}\n          />\n        </StyledWrapper>\n        <StyledWrapper disabled={useCurrentTime}>\n          <StyledButton onClick={setCurrentDateTime} data-for=\"pick-time-button\" data-tip>\n            <Pin height=\"15px\" />\n            <Tooltip id=\"pick-time-button\" effect=\"solid\" place=\"top\" delayShow={500}>\n              <FormattedMessage id={'Pick current time'} />\n            </Tooltip>\n          </StyledButton>\n          <StyledDatePicker value={selectedDate} onChange={setDate} />\n          <StyledTimePicker\n            value={selectedTimeString}\n            onChange={setTime}\n            disableClock={true}\n            format={'hh:mm a'}\n          />\n          <StyledLabelWrapper>\n            <FormattedMessage id={'UTC'} />\n          </StyledLabelWrapper>\n        </StyledWrapper>\n\n        <SliderWrapper disabled={useCurrentTime}>\n          <RangeSlider {...timeSliderProps} />\n        </SliderWrapper>\n\n        <StyledWrapper>\n          <StyledRadio\n            type=\"radio\"\n            checked={useCurrentTime}\n            id={`effect-time-toggle-use-current`}\n            label={'Current time'}\n            onChange={() => {\n              onUseCurrentTimeChange(true);\n            }}\n          />\n        </StyledWrapper>\n      </StyledEffectTimeConfigurator>\n    );\n  };\n\n  return EffectTimeConfigurator;\n}\n"]}

package/dist/effects/effect-type-selector.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { addEffect } from '@kepler.gl/actions';
+export declare type EffectTypeSelectorProps = {
+    options: {
+        type: string;
+        name: string;
+    }[];
+    onSelect: typeof addEffect;
+};
+declare function EffectTypeSelectorFactory(): React.FC<EffectTypeSelectorProps>;
+export default EffectTypeSelectorFactory;

package/dist/effects/effect-type-selector.js

@@ -0,0 +1,117 @@
+// Copyright (c) 2023 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 _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _styledComponents2 = require("../common/styled-components");
+
+var _icons = require("../common/icons");
+
+var _tippyTooltip = _interopRequireDefault(require("../common/tippy-tooltip"));
+
+var _templateObject;
+
+var StyledTippyTooltipContentContainer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  background-color: ", ";\n  display: flex;\n  flex-direction: column;\n  align-items: start;\n  margin: -7px -18px; /* compensate for kepler tippy parent padding */\n  border-radius: 2px;\n  .button {\n    width: 100%;\n    justify-content: start;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.panelBackgroundHover;
+}, function (props) {
+  return props.theme.WHITE;
+});
+/** @type [number, number] */
+
+
+var TIPPY_DURATION = [300, 0];
+/** @type [number, number] */
+
+var TIPPY_OFFSET = [0, 4];
+
+function EffectTypeSelectorFactory() {
+  var EffectTypeSelector = function EffectTypeSelector(_ref) {
+    var onSelect = _ref.onSelect,
+        options = _ref.options;
+
+    /** @type any */
+    var tippyInstance = (0, _react.useRef)(null);
+    var render = (0, _react.useCallback)(function () {
+      return /*#__PURE__*/_react["default"].createElement(StyledTippyTooltipContentContainer, null, options.map(function (effectDesc, idx) {
+        return /*#__PURE__*/_react["default"].createElement(_styledComponents2.Button, {
+          key: "".concat(effectDesc.type, "-").concat(idx),
+          onClick: function onClick() {
+            var _tippyInstance$curren;
+
+            onSelect({
+              config: {
+                type: effectDesc.type
+              }
+            }); // @ts-expect-error type current
+
+            (_tippyInstance$curren = tippyInstance.current) === null || _tippyInstance$curren === void 0 ? void 0 : _tippyInstance$curren.hide();
+          },
+          secondary: true
+        }, effectDesc.name);
+      }));
+    }, [options, tippyInstance, tippyInstance.current, onSelect]);
+    return /*#__PURE__*/_react["default"].createElement(_tippyTooltip["default"], {
+      placement: "bottom-start",
+      offset: TIPPY_OFFSET,
+      duration: TIPPY_DURATION,
+      trigger: "click",
+      interactive: true,
+      arrow: false,
+      hideOnClick: true,
+      onTrigger: function onTrigger(instance) {
+        // @ts-expect-error type current
+        tippyInstance.current = instance;
+      },
+      zIndex: 999 // defaults to 9999; keep it below modals (1000)
+      ,
+      render: render
+    }, /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.Button, {
+      className: "add-effect-button",
+      secondary: true
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+      height: "12px"
+    }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'effectManager.addEffect'
+    }))));
+  };
+
+  return EffectTypeSelector;
+}
+
+var _default = EffectTypeSelectorFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/effects/side-panel-title.d.ts

@@ -0,0 +1,7 @@
+import React, { PropsWithChildren } from 'react';
+export declare type PanelTitleProps = PropsWithChildren<{
+    title: string;
+    className?: string;
+}>;
+declare const SidePanelTitleFactory: () => React.FC<PanelTitleProps>;
+export default SidePanelTitleFactory;

package/dist/effects/side-panel-title.js

@@ -0,0 +1,67 @@
+// Copyright (c) 2023 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");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _templateObject, _templateObject2;
+
+var StyledSidePanelTitle = _styledComponents["default"].div.attrs({
+  className: 'panel-title'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  font-size: ", ";\n  line-height: ", ";\n  font-weight: 400;\n  letter-spacing: 1.25px;\n"])), function (props) {
+  return props.theme.titleTextColor;
+}, function (props) {
+  return props.theme.sidePanelTitleFontsize;
+}, function (props) {
+  return props.theme.sidePanelTitleLineHeight;
+});
+
+var PanelHeaderRow = _styledComponents["default"].div.attrs({
+  className: 'side-panel-header-row'
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 0px;\n  margin-bottom: 8px;\n"])));
+
+var SidePanelTitleFactory = function SidePanelTitleFactory() {
+  var SidePanelTitle = function SidePanelTitle(_ref) {
+    var title = _ref.title,
+        className = _ref.className,
+        children = _ref.children;
+    return /*#__PURE__*/_react["default"].createElement(PanelHeaderRow, null, /*#__PURE__*/_react["default"].createElement(StyledSidePanelTitle, {
+      className: className || 'side-panel-title'
+    }, title), children);
+  };
+
+  return SidePanelTitle;
+};
+
+var _default = SidePanelTitleFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/filter-animation-controller.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { TimeRangeFilter } from '@kepler.gl/types';
+import AnimationControllerFactory from './common/animation-control/animation-controller';
+import { Timeline } from '@kepler.gl/types';
+interface FilterAnimationControllerProps {
+    filter: TimeRangeFilter & {
+        animationWindow?: string;
+    };
+    filterIdx: number;
+    setFilterAnimationTime: (idx: number, value: string, a: any[]) => void;
+    children?: (isAnimating: boolean | undefined, startAnimation: () => void, pauseAnimation: () => void, resetAnimation: () => void, timeline: Timeline | undefined, setTimelineValue: (x: any) => void) => React.ReactElement | null;
+}
+declare function FilterAnimationControllerFactory(AnimationController: ReturnType<typeof AnimationControllerFactory>): React.FC<FilterAnimationControllerProps>;
+declare namespace FilterAnimationControllerFactory {
+    var deps: (typeof AnimationControllerFactory)[];
+}
+export default FilterAnimationControllerFactory;

package/dist/filter-animation-controller.js

@@ -0,0 +1,91 @@
+// Copyright (c) 2023 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 _react = _interopRequireWildcard(require("react"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _constants = require("@kepler.gl/constants");
+
+var _animationController = _interopRequireDefault(require("./common/animation-control/animation-controller"));
+
+FilterAnimationControllerFactory.deps = [_animationController["default"]];
+
+function FilterAnimationControllerFactory(AnimationController) {
+  var FilterAnimationController = function FilterAnimationController(_ref) {
+    var filter = _ref.filter,
+        filterIdx = _ref.filterIdx,
+        setFilterAnimationTime = _ref.setFilterAnimationTime,
+        children = _ref.children;
+    var intervalBins = (0, _react.useMemo)(function () {
+      return (0, _utils.getIntervalBins)(filter);
+    }, [filter]);
+    var steps = (0, _react.useMemo)(function () {
+      return intervalBins ? intervalBins.map(function (x) {
+        return x.x0;
+      }) : null;
+    }, [intervalBins]);
+    var updateAnimation = (0, _react.useCallback)(function (value) {
+      switch (filter.animationWindow) {
+        case _constants.ANIMATION_WINDOW.interval:
+          var _idx = value[1];
+          setFilterAnimationTime(filterIdx, 'value', [intervalBins[_idx].x0, intervalBins[_idx].x1 - 1]);
+          break;
+
+        default:
+          setFilterAnimationTime(filterIdx, 'value', value);
+          break;
+      }
+    }, [filterIdx, intervalBins, filter.animationWindow, setFilterAnimationTime]); // if filter is synced merge the filter and animation config
+
+    var timeline = (0, _utils.getTimelineFromFilter)(filter);
+    return /*#__PURE__*/_react["default"].createElement(AnimationController, {
+      key: "filter-control",
+      value: filter.value,
+      domain: filter.domain,
+      speed: filter.speed,
+      isAnimating: filter.isAnimating,
+      animationWindow: filter.animationWindow,
+      steps: steps,
+      updateAnimation: updateAnimation // @ts-expect-error different function type, goes to TimeWidget setFilterAnimationTime()
+      ,
+      setTimelineValue: setFilterAnimationTime,
+      timeline: timeline,
+      children: children
+    });
+  };
+
+  return FilterAnimationController;
+}
+
+var _default = FilterAnimationControllerFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/filters/components.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
+// Copyright (c) 2023 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
@@ -37,4 +37,4 @@ var _templateObject;
 
 var StyledFilterPanel = (0, _styledComponents["default"])(_styledComponents2.PanelLabel)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  font-weight: 500;\n  color: white;\n  flex: 1;\n"])));
 exports.StyledFilterPanel = StyledFilterPanel;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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