@kepler.gl/components 3.0.0-alpha.0

package/dist/filters/filter-panels/new-filter-panel.js

@@ -0,0 +1,94 @@
+// 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.getSupportedFilterFields = getSupportedFilterFields;
+exports["default"] = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = require("../../common/styled-components");
+
+var _filterPanelHeader = _interopRequireDefault(require("../../side-panel/filter-panel/filter-panel-header"));
+
+var _sourceDataSelector = _interopRequireDefault(require("../../side-panel/common/source-data-selector"));
+
+var _fieldSelector = _interopRequireDefault(require("../../common/field-selector"));NewFilterPanelFactory.deps = [_filterPanelHeader["default"], _sourceDataSelector["default"], _fieldSelector["default"]];
+
+function getSupportedFilterFields(supportedFilterTypes, fields) {
+  return supportedFilterTypes ? fields.filter(function (field) {
+    return supportedFilterTypes.includes(field.type);
+  }) : fields;
+}
+
+function NewFilterPanelFactory(FilterPanelHeader, SourceDataSelector, FieldSelector) {
+  var NewFilterPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var idx = _ref.idx,
+        filter = _ref.filter,
+        datasets = _ref.datasets,
+        allAvailableFields = _ref.allAvailableFields,
+        setFilter = _ref.setFilter,
+        removeFilter = _ref.removeFilter;
+    var onFieldSelector = (0, _react.useCallback)(function (field) {
+      return setFilter(idx, 'name', field.name);
+    }, [idx, setFilter]);
+    var onSourceDataSelector = (0, _react.useCallback)(function (value) {
+      return setFilter(idx, 'dataId', value);
+    }, [idx, setFilter]);
+    var dataset = datasets[filter.dataId[0]];
+    var supportedFields = (0, _react.useMemo)(function () {
+      return getSupportedFilterFields(dataset.supportedFilterTypes, allAvailableFields);
+    }, [dataset.supportedFilterTypes, allAvailableFields]);
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(FilterPanelHeader, {
+      datasets: [dataset],
+      filter: filter,
+      removeFilter: removeFilter
+    }, /*#__PURE__*/_react["default"].createElement(FieldSelector, {
+      inputTheme: "secondary",
+      fields: supportedFields,
+      value: Array.isArray(filter.name) ? filter.name[0] : filter.name,
+      erasable: false,
+      onSelect: onFieldSelector
+    })), /*#__PURE__*/_react["default"].createElement(_styledComponents.StyledFilterContent, {
+      className: "filter-panel__content"
+    }, Object.keys(datasets).length > 1 && /*#__PURE__*/_react["default"].createElement(SourceDataSelector, {
+      inputTheme: "secondary",
+      datasets: datasets,
+      disabled: filter.freeze,
+      dataId: filter.dataId,
+      onSelect: onSourceDataSelector
+    })));
+  });
+
+  NewFilterPanel.displayName = 'NewFilterPanel';
+  return NewFilterPanel;
+}
+
+var _default = NewFilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/filters/filter-panels/new-filter-panel.tsx"],"names":["NewFilterPanelFactory","deps","FilterPanelHeaderFactory","SourceDataSelectorFactory","FieldSelectorFactory","getSupportedFilterFields","supportedFilterTypes","fields","filter","field","includes","type","FilterPanelHeader","SourceDataSelector","FieldSelector","NewFilterPanel","React","memo","idx","datasets","allAvailableFields","setFilter","removeFilter","onFieldSelector","name","onSourceDataSelector","value","dataset","dataId","supportedFields","Array","isArray","Object","keys","length","freeze","displayName"],"mappings":";;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AAxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAWAA,qBAAqB,CAACC,IAAtB,GAA6B,CAC3BC,6BAD2B,EAE3BC,8BAF2B,EAG3BC,yBAH2B,CAA7B;;AAMO,SAASC,wBAAT,CACLC,oBADK,EAELC,MAFK,EAGL;AACA,SAAOD,oBAAoB,GACvBC,MAAM,CAACC,MAAP,CAAc,UAAAC,KAAK;AAAA,WAAIH,oBAAoB,CAACI,QAArB,CAA8BD,KAAK,CAACE,IAApC,CAAJ;AAAA,GAAnB,CADuB,GAEvBJ,MAFJ;AAGD;;AAED,SAASP,qBAAT,CACEY,iBADF,EAEEC,kBAFF,EAGEC,aAHF,EAIE;AACA,MAAMC,cAA2D,gBAAGC,kBAAMC,IAAN,CAClE,gBAA0E;AAAA,QAAxEC,GAAwE,QAAxEA,GAAwE;AAAA,QAAnEV,MAAmE,QAAnEA,MAAmE;AAAA,QAA3DW,QAA2D,QAA3DA,QAA2D;AAAA,QAAjDC,kBAAiD,QAAjDA,kBAAiD;AAAA,QAA7BC,SAA6B,QAA7BA,SAA6B;AAAA,QAAlBC,YAAkB,QAAlBA,YAAkB;AACxE,QAAMC,eAAe,GAAG,wBAAY,UAAAd,KAAK;AAAA,aAAIY,SAAS,CAACH,GAAD,EAAM,MAAN,EAAcT,KAAK,CAACe,IAApB,CAAb;AAAA,KAAjB,EAAyD,CAC/EN,GAD+E,EAE/EG,SAF+E,CAAzD,CAAxB;AAKA,QAAMI,oBAAoB,GAAG,wBAAY,UAAAC,KAAK;AAAA,aAAIL,SAAS,CAACH,GAAD,EAAM,QAAN,EAAgBQ,KAAhB,CAAb;AAAA,KAAjB,EAAsD,CACjFR,GADiF,EAEjFG,SAFiF,CAAtD,CAA7B;AAKA,QAAMM,OAAoB,GAAGR,QAAQ,CAACX,MAAM,CAACoB,MAAP,CAAc,CAAd,CAAD,CAArC;AACA,QAAMC,eAAe,GAAG,oBACtB;AAAA,aAAMxB,wBAAwB,CAACsB,OAAO,CAACrB,oBAAT,EAA+Bc,kBAA/B,CAA9B;AAAA,KADsB,EAEtB,CAACO,OAAO,CAACrB,oBAAT,EAA+Bc,kBAA/B,CAFsB,CAAxB;AAKA,wBACE,+EACE,gCAAC,iBAAD;AAAmB,MAAA,QAAQ,EAAE,CAACO,OAAD,CAA7B;AAAwC,MAAA,MAAM,EAAEnB,MAAhD;AAAwD,MAAA,YAAY,EAAEc;AAAtE,oBACE,gCAAC,aAAD;AACE,MAAA,UAAU,EAAC,WADb;AAEE,MAAA,MAAM,EAAEO,eAFV;AAGE,MAAA,KAAK,EAAEC,KAAK,CAACC,OAAN,CAAcvB,MAAM,CAACgB,IAArB,IAA6BhB,MAAM,CAACgB,IAAP,CAAY,CAAZ,CAA7B,GAA8ChB,MAAM,CAACgB,IAH9D;AAIE,MAAA,QAAQ,EAAE,KAJZ;AAKE,MAAA,QAAQ,EAAED;AALZ,MADF,CADF,eAUE,gCAAC,qCAAD;AAAqB,MAAA,SAAS,EAAC;AAA/B,OACGS,MAAM,CAACC,IAAP,CAAYd,QAAZ,EAAsBe,MAAtB,GAA+B,CAA/B,iBACC,gCAAC,kBAAD;AACE,MAAA,UAAU,EAAC,WADb;AAEE,MAAA,QAAQ,EAAEf,QAFZ;AAGE,MAAA,QAAQ,EAAEX,MAAM,CAAC2B,MAHnB;AAIE,MAAA,MAAM,EAAE3B,MAAM,CAACoB,MAJjB;AAKE,MAAA,QAAQ,EAAEH;AALZ,MAFJ,CAVF,CADF;AAwBD,GA1CiE,CAApE;;AA6CAV,EAAAA,cAAc,CAACqB,WAAf,GAA6B,gBAA7B;AAEA,SAAOrB,cAAP;AACD;;eAEcf,qB","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, {useCallback, useMemo} from 'react';\nimport {StyledFilterContent} from '../../common/styled-components';\nimport FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';\nimport SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';\nimport FieldSelectorFactory from '../../common/field-selector';\nimport {FilterPanelComponent} from './types';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {Field, FilterBase, LineChart} from '@kepler.gl/types';\n\nNewFilterPanelFactory.deps = [\n  FilterPanelHeaderFactory,\n  SourceDataSelectorFactory,\n  FieldSelectorFactory\n];\n\nexport function getSupportedFilterFields(\n  supportedFilterTypes: KeplerTable['supportedFilterTypes'],\n  fields: Field[]\n) {\n  return supportedFilterTypes\n    ? fields.filter(field => supportedFilterTypes.includes(field.type))\n    : fields;\n}\n\nfunction NewFilterPanelFactory(\n  FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>,\n  SourceDataSelector: ReturnType<typeof SourceDataSelectorFactory>,\n  FieldSelector: ReturnType<typeof FieldSelectorFactory>\n) {\n  const NewFilterPanel: FilterPanelComponent<FilterBase<LineChart>> = React.memo(\n    ({idx, filter, datasets, allAvailableFields, setFilter, removeFilter}) => {\n      const onFieldSelector = useCallback(field => setFilter(idx, 'name', field.name), [\n        idx,\n        setFilter\n      ]);\n\n      const onSourceDataSelector = useCallback(value => setFilter(idx, 'dataId', value), [\n        idx,\n        setFilter\n      ]);\n\n      const dataset: KeplerTable = datasets[filter.dataId[0]];\n      const supportedFields = useMemo(\n        () => getSupportedFilterFields(dataset.supportedFilterTypes, allAvailableFields),\n        [dataset.supportedFilterTypes, allAvailableFields]\n      );\n\n      return (\n        <>\n          <FilterPanelHeader datasets={[dataset]} filter={filter} removeFilter={removeFilter}>\n            <FieldSelector\n              inputTheme=\"secondary\"\n              fields={supportedFields}\n              value={Array.isArray(filter.name) ? filter.name[0] : filter.name}\n              erasable={false}\n              onSelect={onFieldSelector}\n            />\n          </FilterPanelHeader>\n          <StyledFilterContent className=\"filter-panel__content\">\n            {Object.keys(datasets).length > 1 && (\n              <SourceDataSelector\n                inputTheme=\"secondary\"\n                datasets={datasets}\n                disabled={filter.freeze}\n                dataId={filter.dataId}\n                onSelect={onSourceDataSelector}\n              />\n            )}\n          </StyledFilterContent>\n        </>\n      );\n    }\n  );\n\n  NewFilterPanel.displayName = 'NewFilterPanel';\n\n  return NewFilterPanel;\n}\n\nexport default NewFilterPanelFactory;\n"]}

package/dist/filters/filter-panels/polygon-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import PolygonFilterFactory from '../polygon-filter';
+import PanelHeaderActionFactory from '../../side-panel/panel-header-action';
+import FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';
+import { PolygonFilterPanelComponent } from './types';
+declare function PolygonFilterPanelFactory(FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>, PolygonFilter: ReturnType<typeof PolygonFilterFactory>, PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): PolygonFilterPanelComponent;
+declare namespace PolygonFilterPanelFactory {
+    var deps: (typeof PanelHeaderActionFactory | typeof FilterPanelHeaderFactory | typeof PolygonFilterFactory)[];
+}
+export default PolygonFilterPanelFactory;

package/dist/filters/filter-panels/polygon-filter-panel.js

@@ -0,0 +1,96 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = require("../../common/styled-components");
+
+var _polygonFilter = _interopRequireDefault(require("../polygon-filter"));
+
+var _panelHeaderAction = _interopRequireDefault(require("../../side-panel/panel-header-action"));
+
+var _icons = require("../../common/icons");
+
+var _filterPanelHeader = _interopRequireDefault(require("../../side-panel/filter-panel/filter-panel-header"));
+
+var _components = require("../components");
+
+var _lodash = _interopRequireDefault(require("lodash.get"));PolygonFilterPanelFactory.deps = [_filterPanelHeader["default"], _polygonFilter["default"], _panelHeaderAction["default"]];
+
+function PolygonFilterPanelFactory(FilterPanelHeader, PolygonFilter, PanelHeaderAction) {
+  var PolygonFilterPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var idx = _ref.idx,
+        datasets = _ref.datasets,
+        layers = _ref.layers,
+        filter = _ref.filter,
+        removeFilter = _ref.removeFilter,
+        setFilter = _ref.setFilter,
+        toggleFilterFeature = _ref.toggleFilterFeature;
+    var filterDatasets = (0, _react.useMemo)(function () {
+      return filter.dataId.map(function (d) {
+        return datasets[d];
+      });
+    }, [filter, datasets]);
+    var onSetLayers = (0, _react.useCallback)(function (value) {
+      return setFilter(idx, 'layerId', value);
+    }, [setFilter, idx]);
+    var isVisible = (0, _lodash["default"])(filter, ['value', 'properties', 'isVisible'], true);
+    var featureType = (0, _lodash["default"])(filter, ['value', 'properties', 'renderType'], true);
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "polygon-filter-panel"
+    }, /*#__PURE__*/_react["default"].createElement(FilterPanelHeader, {
+      datasets: filterDatasets,
+      filter: filter,
+      removeFilter: removeFilter
+    }, /*#__PURE__*/_react["default"].createElement(_components.StyledFilterPanel, null, "Geo - ", featureType), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      id: filter.id,
+      onClick: toggleFilterFeature,
+      tooltip: isVisible ? 'tooltip.hideFeature' : 'tooltip.showFeature',
+      IconComponent: isVisible ? _icons.EyeSeen : _icons.EyeUnseen,
+      active: isVisible
+    })), /*#__PURE__*/_react["default"].createElement(_styledComponents.StyledFilterContent, {
+      className: "filter-panel__content"
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/_react["default"].createElement(PolygonFilter, {
+      filter: filter,
+      layers: layers,
+      setLayers: onSetLayers
+    }))));
+  });
+
+  PolygonFilterPanel.displayName = 'PolygonFilterPanel';
+  return PolygonFilterPanel;
+}
+
+var _default = PolygonFilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/filters/filter-panels/polygon-filter-panel.tsx"],"names":["PolygonFilterPanelFactory","deps","FilterPanelHeaderFactory","PolygonFilterFactory","PanelHeaderActionFactory","FilterPanelHeader","PolygonFilter","PanelHeaderAction","PolygonFilterPanel","React","memo","idx","datasets","layers","filter","removeFilter","setFilter","toggleFilterFeature","filterDatasets","dataId","map","d","onSetLayers","value","isVisible","featureType","id","EyeSeen","EyeUnseen","displayName"],"mappings":";;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;AAEA;;AA7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAeAA,yBAAyB,CAACC,IAA1B,GAAiC,CAC/BC,6BAD+B,EAE/BC,yBAF+B,EAG/BC,6BAH+B,CAAjC;;AAMA,SAASJ,yBAAT,CACEK,iBADF,EAEEC,aAFF,EAGEC,iBAHF,EAIE;AACA,MAAMC,kBAA+C,gBAAGC,kBAAMC,IAAN,CACtD,gBAAmF;AAAA,QAAjFC,GAAiF,QAAjFA,GAAiF;AAAA,QAA5EC,QAA4E,QAA5EA,QAA4E;AAAA,QAAlEC,MAAkE,QAAlEA,MAAkE;AAAA,QAA1DC,MAA0D,QAA1DA,MAA0D;AAAA,QAAlDC,YAAkD,QAAlDA,YAAkD;AAAA,QAApCC,SAAoC,QAApCA,SAAoC;AAAA,QAAzBC,mBAAyB,QAAzBA,mBAAyB;AACjF,QAAMC,cAA6B,GAAG,oBAAQ;AAAA,aAAMJ,MAAM,CAACK,MAAP,CAAcC,GAAd,CAAkB,UAAAC,CAAC;AAAA,eAAIT,QAAQ,CAACS,CAAD,CAAZ;AAAA,OAAnB,CAAN;AAAA,KAAR,EAAmD,CACvFP,MADuF,EAEvFF,QAFuF,CAAnD,CAAtC;AAKA,QAAMU,WAAW,GAAG,wBAAY,UAAAC,KAAK;AAAA,aAAIP,SAAS,CAACL,GAAD,EAAM,SAAN,EAAiBY,KAAjB,CAAb;AAAA,KAAjB,EAAuD,CAACP,SAAD,EAAYL,GAAZ,CAAvD,CAApB;AAEA,QAAMa,SAAS,GAAG,wBAAIV,MAAJ,EAAY,CAAC,OAAD,EAAU,YAAV,EAAwB,WAAxB,CAAZ,EAAkD,IAAlD,CAAlB;AACA,QAAMW,WAAW,GAAG,wBAAIX,MAAJ,EAAY,CAAC,OAAD,EAAU,YAAV,EAAwB,YAAxB,CAAZ,EAAmD,IAAnD,CAApB;AAEA,wBACE;AAAK,MAAA,SAAS,EAAC;AAAf,oBACE,gCAAC,iBAAD;AAAmB,MAAA,QAAQ,EAAEI,cAA7B;AAA6C,MAAA,MAAM,EAAEJ,MAArD;AAA6D,MAAA,YAAY,EAAEC;AAA3E,oBACE,gCAAC,6BAAD,kBAA0BU,WAA1B,CADF,eAEE,gCAAC,iBAAD;AACE,MAAA,EAAE,EAAEX,MAAM,CAACY,EADb;AAEE,MAAA,OAAO,EAAET,mBAFX;AAGE,MAAA,OAAO,EAAEO,SAAS,GAAG,qBAAH,GAA2B,qBAH/C;AAIE,MAAA,aAAa,EAAEA,SAAS,GAAGG,cAAH,GAAaC,gBAJvC;AAKE,MAAA,MAAM,EAAEJ;AALV,MAFF,CADF,eAWE,gCAAC,qCAAD;AAAqB,MAAA,SAAS,EAAC;AAA/B,oBACE;AAAK,MAAA,SAAS,EAAC;AAAf,oBACE,gCAAC,aAAD;AAAe,MAAA,MAAM,EAAEV,MAAvB;AAA+B,MAAA,MAAM,EAAED,MAAvC;AAA+C,MAAA,SAAS,EAAES;AAA1D,MADF,CADF,CAXF,CADF;AAmBD,GA/BqD,CAAxD;;AAkCAd,EAAAA,kBAAkB,CAACqB,WAAnB,GAAiC,oBAAjC;AAEA,SAAOrB,kBAAP;AACD;;eAEcR,yB","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, {useMemo, useCallback} from 'react';\nimport {StyledFilterContent} from '../../common/styled-components';\nimport PolygonFilterFactory from '../polygon-filter';\nimport PanelHeaderActionFactory from '../../side-panel/panel-header-action';\nimport {EyeSeen, EyeUnseen} from '../../common/icons';\n\nimport FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';\nimport {StyledFilterPanel} from '../components';\n\nimport get from 'lodash.get';\nimport {PolygonFilterPanelComponent} from './types';\nimport {KeplerTable} from '@kepler.gl/table';\n\nPolygonFilterPanelFactory.deps = [\n  FilterPanelHeaderFactory,\n  PolygonFilterFactory,\n  PanelHeaderActionFactory\n];\n\nfunction PolygonFilterPanelFactory(\n  FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>,\n  PolygonFilter: ReturnType<typeof PolygonFilterFactory>,\n  PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>\n) {\n  const PolygonFilterPanel: PolygonFilterPanelComponent = React.memo(\n    ({idx, datasets, layers, filter, removeFilter, setFilter, toggleFilterFeature}) => {\n      const filterDatasets: KeplerTable[] = useMemo(() => filter.dataId.map(d => datasets[d]), [\n        filter,\n        datasets\n      ]);\n\n      const onSetLayers = useCallback(value => setFilter(idx, 'layerId', value), [setFilter, idx]);\n\n      const isVisible = get(filter, ['value', 'properties', 'isVisible'], true);\n      const featureType = get(filter, ['value', 'properties', 'renderType'], true);\n\n      return (\n        <div className=\"polygon-filter-panel\">\n          <FilterPanelHeader datasets={filterDatasets} filter={filter} removeFilter={removeFilter}>\n            <StyledFilterPanel>Geo - {featureType}</StyledFilterPanel>\n            <PanelHeaderAction\n              id={filter.id}\n              onClick={toggleFilterFeature}\n              tooltip={isVisible ? 'tooltip.hideFeature' : 'tooltip.showFeature'}\n              IconComponent={isVisible ? EyeSeen : EyeUnseen}\n              active={isVisible}\n            />\n          </FilterPanelHeader>\n          <StyledFilterContent className=\"filter-panel__content\">\n            <div className=\"filter-panel__filter\">\n              <PolygonFilter filter={filter} layers={layers} setLayers={onSetLayers} />\n            </div>\n          </StyledFilterContent>\n        </div>\n      );\n    }\n  );\n\n  PolygonFilterPanel.displayName = 'PolygonFilterPanel';\n\n  return PolygonFilterPanel;\n}\n\nexport default PolygonFilterPanelFactory;\n"]}

package/dist/filters/filter-panels/range-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import RangeFilterFactory from '../range-filter';
+import { RangeFilter } from '@kepler.gl/types';
+import FieldPanelWithFieldSelectFactory from './filter-panel-with-field-select';
+import { FilterPanelComponent } from './types';
+declare function RangeFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, RangeFilterComponent: ReturnType<typeof RangeFilterFactory>): FilterPanelComponent<RangeFilter>;
+declare namespace RangeFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof RangeFilterFactory)[];
+}
+export default RangeFilterPanelFactory;

package/dist/filters/filter-panels/range-filter-panel.js

@@ -0,0 +1,72 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _rangeFilter = _interopRequireDefault(require("../range-filter"));
+
+var _filterPanelWithFieldSelect = _interopRequireDefault(require("./filter-panel-with-field-select"));RangeFilterPanelFactory.deps = [_filterPanelWithFieldSelect["default"], _rangeFilter["default"]];
+
+function RangeFilterPanelFactory(FieldPanelWithFieldSelect, RangeFilterComponent) {
+  var RangeFilterPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var idx = _ref.idx,
+        datasets = _ref.datasets,
+        allAvailableFields = _ref.allAvailableFields,
+        filter = _ref.filter,
+        removeFilter = _ref.removeFilter,
+        setFilter = _ref.setFilter;
+    var onSetFilter = (0, _react.useCallback)(function (value) {
+      return setFilter(idx, 'value', value);
+    }, [idx, setFilter]);
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "range-filter-panel"
+    }, /*#__PURE__*/_react["default"].createElement(FieldPanelWithFieldSelect, {
+      allAvailableFields: allAvailableFields,
+      datasets: datasets,
+      filter: filter,
+      idx: idx,
+      removeFilter: removeFilter,
+      setFilter: setFilter
+    }, filter.type && !filter.enlarged && /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/_react["default"].createElement(RangeFilterComponent, {
+      filter: filter,
+      setFilter: onSetFilter
+    }))));
+  });
+
+  RangeFilterPanel.displayName = 'RangeFilterPanel';
+  return RangeFilterPanel;
+}
+
+var _default = RangeFilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/filters/filter-panels/single-select-filter-panel.d.ts

@@ -0,0 +1,9 @@
+import SingleSelectFilterFactory from '../single-select-filter';
+import { SelectFilter } from '@kepler.gl/types';
+import FieldPanelWithFieldSelectFactory from './filter-panel-with-field-select';
+import { FilterPanelComponent } from './types';
+declare function SingleSelectFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, SingleSelectFilter: ReturnType<typeof SingleSelectFilterFactory>): FilterPanelComponent<SelectFilter>;
+declare namespace SingleSelectFilterPanelFactory {
+    var deps: (typeof FieldPanelWithFieldSelectFactory | typeof SingleSelectFilterFactory)[];
+}
+export default SingleSelectFilterPanelFactory;

package/dist/filters/filter-panels/single-select-filter-panel.js

@@ -0,0 +1,72 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _singleSelectFilter = _interopRequireDefault(require("../single-select-filter"));
+
+var _filterPanelWithFieldSelect = _interopRequireDefault(require("./filter-panel-with-field-select"));SingleSelectFilterPanelFactory.deps = [_filterPanelWithFieldSelect["default"], _singleSelectFilter["default"]];
+
+function SingleSelectFilterPanelFactory(FieldPanelWithFieldSelect, SingleSelectFilter) {
+  var SingleSelectFilterPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var idx = _ref.idx,
+        datasets = _ref.datasets,
+        allAvailableFields = _ref.allAvailableFields,
+        filter = _ref.filter,
+        setFilter = _ref.setFilter,
+        removeFilter = _ref.removeFilter;
+    var onSetFilter = (0, _react.useCallback)(function (value) {
+      return setFilter(idx, 'value', value);
+    }, [idx, setFilter]);
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "single-select-filter-panel"
+    }, /*#__PURE__*/_react["default"].createElement(FieldPanelWithFieldSelect, {
+      allAvailableFields: allAvailableFields,
+      datasets: datasets,
+      filter: filter,
+      idx: idx,
+      removeFilter: removeFilter,
+      setFilter: setFilter
+    }, filter.type && !filter.enlarged && /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/_react["default"].createElement(SingleSelectFilter, {
+      filter: filter,
+      setFilter: onSetFilter
+    }))));
+  });
+
+  SingleSelectFilterPanel.displayName = 'SingleSelectFilterPanel';
+  return SingleSelectFilterPanel;
+}
+
+var _default = SingleSelectFilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWx0ZXJzL2ZpbHRlci1wYW5lbHMvc2luZ2xlLXNlbGVjdC1maWx0ZXItcGFuZWwudHN4Il0sIm5hbWVzIjpbIlNpbmdsZVNlbGVjdEZpbHRlclBhbmVsRmFjdG9yeSIsImRlcHMiLCJGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0RmFjdG9yeSIsIlNpbmdsZVNlbGVjdEZpbHRlckZhY3RvcnkiLCJGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0IiwiU2luZ2xlU2VsZWN0RmlsdGVyIiwiU2luZ2xlU2VsZWN0RmlsdGVyUGFuZWwiLCJSZWFjdCIsIm1lbW8iLCJpZHgiLCJkYXRhc2V0cyIsImFsbEF2YWlsYWJsZUZpZWxkcyIsImZpbHRlciIsInNldEZpbHRlciIsInJlbW92ZUZpbHRlciIsIm9uU2V0RmlsdGVyIiwidmFsdWUiLCJ0eXBlIiwiZW5sYXJnZWQiLCJkaXNwbGF5TmFtZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFvQkE7O0FBQ0E7O0FBRUE7O0FBdkJBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBUUFBLDhCQUE4QixDQUFDQyxJQUEvQixHQUFzQyxDQUFDQyxzQ0FBRCxFQUFtQ0MsOEJBQW5DLENBQXRDOztBQUVBLFNBQVNILDhCQUFULENBQ0VJLHlCQURGLEVBRUVDLGtCQUZGLEVBR0U7QUFDQSxNQUFNQyx1QkFBMkQsZ0JBQUdDLGtCQUFNQyxJQUFOLENBQ2xFLGdCQUEwRTtBQUFBLFFBQXhFQyxHQUF3RSxRQUF4RUEsR0FBd0U7QUFBQSxRQUFuRUMsUUFBbUUsUUFBbkVBLFFBQW1FO0FBQUEsUUFBekRDLGtCQUF5RCxRQUF6REEsa0JBQXlEO0FBQUEsUUFBckNDLE1BQXFDLFFBQXJDQSxNQUFxQztBQUFBLFFBQTdCQyxTQUE2QixRQUE3QkEsU0FBNkI7QUFBQSxRQUFsQkMsWUFBa0IsUUFBbEJBLFlBQWtCO0FBQ3hFLFFBQU1DLFdBQVcsR0FBRyx3QkFBWSxVQUFBQyxLQUFLO0FBQUEsYUFBSUgsU0FBUyxDQUFDSixHQUFELEVBQU0sT0FBTixFQUFlTyxLQUFmLENBQWI7QUFBQSxLQUFqQixFQUFxRCxDQUFDUCxHQUFELEVBQU1JLFNBQU4sQ0FBckQsQ0FBcEI7QUFFQSx3QkFDRTtBQUFLLE1BQUEsU0FBUyxFQUFDO0FBQWYsb0JBQ0UsZ0NBQUMseUJBQUQ7QUFDRSxNQUFBLGtCQUFrQixFQUFFRixrQkFEdEI7QUFFRSxNQUFBLFFBQVEsRUFBRUQsUUFGWjtBQUdFLE1BQUEsTUFBTSxFQUFFRSxNQUhWO0FBSUUsTUFBQSxHQUFHLEVBQUVILEdBSlA7QUFLRSxNQUFBLFlBQVksRUFBRUssWUFMaEI7QUFNRSxNQUFBLFNBQVMsRUFBRUQ7QUFOYixPQVFHRCxNQUFNLENBQUNLLElBQVAsSUFBZSxDQUFDTCxNQUFNLENBQUNNLFFBQXZCLGlCQUNDO0FBQUssTUFBQSxTQUFTLEVBQUM7QUFBZixvQkFDRSxnQ0FBQyxrQkFBRDtBQUFvQixNQUFBLE1BQU0sRUFBRU4sTUFBNUI7QUFBb0MsTUFBQSxTQUFTLEVBQUVHO0FBQS9DLE1BREYsQ0FUSixDQURGLENBREY7QUFrQkQsR0F0QmlFLENBQXBFOztBQXlCQVQsRUFBQUEsdUJBQXVCLENBQUNhLFdBQXhCLEdBQXNDLHlCQUF0QztBQUVBLFNBQU9iLHVCQUFQO0FBQ0Q7O2VBRWNOLDhCIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuaW1wb3J0IFJlYWN0LCB7dXNlQ2FsbGJhY2t9IGZyb20gJ3JlYWN0JztcbmltcG9ydCBTaW5nbGVTZWxlY3RGaWx0ZXJGYWN0b3J5IGZyb20gJy4uL3NpbmdsZS1zZWxlY3QtZmlsdGVyJztcbmltcG9ydCB7U2VsZWN0RmlsdGVyfSBmcm9tICdAa2VwbGVyLmdsL3R5cGVzJztcbmltcG9ydCBGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0RmFjdG9yeSBmcm9tICcuL2ZpbHRlci1wYW5lbC13aXRoLWZpZWxkLXNlbGVjdCc7XG5pbXBvcnQge0ZpbHRlclBhbmVsQ29tcG9uZW50fSBmcm9tICcuL3R5cGVzJztcblxuU2luZ2xlU2VsZWN0RmlsdGVyUGFuZWxGYWN0b3J5LmRlcHMgPSBbRmllbGRQYW5lbFdpdGhGaWVsZFNlbGVjdEZhY3RvcnksIFNpbmdsZVNlbGVjdEZpbHRlckZhY3RvcnldO1xuXG5mdW5jdGlvbiBTaW5nbGVTZWxlY3RGaWx0ZXJQYW5lbEZhY3RvcnkoXG4gIEZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3Q6IFJldHVyblR5cGU8dHlwZW9mIEZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3RGYWN0b3J5PixcbiAgU2luZ2xlU2VsZWN0RmlsdGVyOiBSZXR1cm5UeXBlPHR5cGVvZiBTaW5nbGVTZWxlY3RGaWx0ZXJGYWN0b3J5PlxuKSB7XG4gIGNvbnN0IFNpbmdsZVNlbGVjdEZpbHRlclBhbmVsOiBGaWx0ZXJQYW5lbENvbXBvbmVudDxTZWxlY3RGaWx0ZXI+ID0gUmVhY3QubWVtbyhcbiAgICAoe2lkeCwgZGF0YXNldHMsIGFsbEF2YWlsYWJsZUZpZWxkcywgZmlsdGVyLCBzZXRGaWx0ZXIsIHJlbW92ZUZpbHRlcn0pID0+IHtcbiAgICAgIGNvbnN0IG9uU2V0RmlsdGVyID0gdXNlQ2FsbGJhY2sodmFsdWUgPT4gc2V0RmlsdGVyKGlkeCwgJ3ZhbHVlJywgdmFsdWUpLCBbaWR4LCBzZXRGaWx0ZXJdKTtcblxuICAgICAgcmV0dXJuIChcbiAgICAgICAgPGRpdiBjbGFzc05hbWU9XCJzaW5nbGUtc2VsZWN0LWZpbHRlci1wYW5lbFwiPlxuICAgICAgICAgIDxGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0XG4gICAgICAgICAgICBhbGxBdmFpbGFibGVGaWVsZHM9e2FsbEF2YWlsYWJsZUZpZWxkc31cbiAgICAgICAgICAgIGRhdGFzZXRzPXtkYXRhc2V0c31cbiAgICAgICAgICAgIGZpbHRlcj17ZmlsdGVyfVxuICAgICAgICAgICAgaWR4PXtpZHh9XG4gICAgICAgICAgICByZW1vdmVGaWx0ZXI9e3JlbW92ZUZpbHRlcn1cbiAgICAgICAgICAgIHNldEZpbHRlcj17c2V0RmlsdGVyfVxuICAgICAgICAgID5cbiAgICAgICAgICAgIHtmaWx0ZXIudHlwZSAmJiAhZmlsdGVyLmVubGFyZ2VkICYmIChcbiAgICAgICAgICAgICAgPGRpdiBjbGFzc05hbWU9XCJmaWx0ZXItcGFuZWxfX2ZpbHRlclwiPlxuICAgICAgICAgICAgICAgIDxTaW5nbGVTZWxlY3RGaWx0ZXIgZmlsdGVyPXtmaWx0ZXJ9IHNldEZpbHRlcj17b25TZXRGaWx0ZXJ9IC8+XG4gICAgICAgICAgICAgIDwvZGl2PlxuICAgICAgICAgICAgKX1cbiAgICAgICAgICA8L0ZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3Q+XG4gICAgICAgIDwvZGl2PlxuICAgICAgKTtcbiAgICB9XG4gICk7XG5cbiAgU2luZ2xlU2VsZWN0RmlsdGVyUGFuZWwuZGlzcGxheU5hbWUgPSAnU2luZ2xlU2VsZWN0RmlsdGVyUGFuZWwnO1xuXG4gIHJldHVybiBTaW5nbGVTZWxlY3RGaWx0ZXJQYW5lbDtcbn1cblxuZXhwb3J0IGRlZmF1bHQgU2luZ2xlU2VsZWN0RmlsdGVyUGFuZWxGYWN0b3J5O1xuIl19

package/dist/filters/filter-panels/time-range-filter-panel.d.ts

@@ -0,0 +1,8 @@
+import TimeRangeFilterFactory from '../time-range-filter';
+import FieldPanelWithFieldSelectFactory from './filter-panel-with-field-select';
+import { TimeRangeFilterPanelComponent } from './types';
+declare function TimeRangeFilterPanelFactory(FieldPanelWithFieldSelect: ReturnType<typeof FieldPanelWithFieldSelectFactory>, TimeRangeFilter: ReturnType<typeof TimeRangeFilterFactory>): TimeRangeFilterPanelComponent;
+declare namespace TimeRangeFilterPanelFactory {
+    var deps: (typeof TimeRangeFilterFactory | typeof FieldPanelWithFieldSelectFactory)[];
+}
+export default TimeRangeFilterPanelFactory;

package/dist/filters/filter-panels/time-range-filter-panel.js

@@ -0,0 +1,87 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _timeRangeFilter = _interopRequireDefault(require("../time-range-filter"));
+
+var _icons = require("../../common/icons");
+
+var _filterPanelWithFieldSelect = _interopRequireDefault(require("./filter-panel-with-field-select"));TimeRangeFilterPanelFactory.deps = [_filterPanelWithFieldSelect["default"], _timeRangeFilter["default"]];
+
+function TimeRangeFilterPanelFactory(FieldPanelWithFieldSelect, TimeRangeFilter) {
+  var TimeRangeFilterPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var idx = _ref.idx,
+        datasets = _ref.datasets,
+        allAvailableFields = _ref.allAvailableFields,
+        filter = _ref.filter,
+        enlargeFilter = _ref.enlargeFilter,
+        setFilter = _ref.setFilter,
+        removeFilter = _ref.removeFilter,
+        toggleAnimation = _ref.toggleAnimation;
+    var onSetFilter = (0, _react.useCallback)(function (value) {
+      return setFilter(idx, 'value', value);
+    }, [idx, setFilter]);
+    var panelActions = (0, _react.useMemo)(function () {
+      return [{
+        id: filter.id,
+        onClick: enlargeFilter,
+        tooltip: 'tooltip.timePlayback',
+        iconComponent: _icons.Clock,
+        active: filter.enlarged
+      }];
+    }, [filter.id, filter.enlarged, enlargeFilter]);
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(FieldPanelWithFieldSelect, {
+      allAvailableFields: allAvailableFields,
+      datasets: datasets,
+      filter: filter,
+      idx: idx,
+      removeFilter: removeFilter,
+      setFilter: setFilter,
+      panelActions: panelActions
+    }, filter.type && !filter.enlarged && /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/_react["default"].createElement(TimeRangeFilter, {
+      filter: filter,
+      toggleAnimation: toggleAnimation,
+      setFilter: onSetFilter,
+      isAnimatable: true,
+      hideTimeTitle: true
+    }))));
+  });
+
+  TimeRangeFilterPanel.displayName = 'TimeRangeFilterPanel';
+  return TimeRangeFilterPanel;
+}
+
+var _default = TimeRangeFilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWx0ZXJzL2ZpbHRlci1wYW5lbHMvdGltZS1yYW5nZS1maWx0ZXItcGFuZWwudHN4Il0sIm5hbWVzIjpbIlRpbWVSYW5nZUZpbHRlclBhbmVsRmFjdG9yeSIsImRlcHMiLCJGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0RmFjdG9yeSIsIlRpbWVSYW5nZUZpbHRlckZhY3RvcnkiLCJGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0IiwiVGltZVJhbmdlRmlsdGVyIiwiVGltZVJhbmdlRmlsdGVyUGFuZWwiLCJSZWFjdCIsIm1lbW8iLCJpZHgiLCJkYXRhc2V0cyIsImFsbEF2YWlsYWJsZUZpZWxkcyIsImZpbHRlciIsImVubGFyZ2VGaWx0ZXIiLCJzZXRGaWx0ZXIiLCJyZW1vdmVGaWx0ZXIiLCJ0b2dnbGVBbmltYXRpb24iLCJvblNldEZpbHRlciIsInZhbHVlIiwicGFuZWxBY3Rpb25zIiwiaWQiLCJvbkNsaWNrIiwidG9vbHRpcCIsImljb25Db21wb25lbnQiLCJDbG9jayIsImFjdGl2ZSIsImVubGFyZ2VkIiwidHlwZSIsImRpc3BsYXlOYW1lIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQW9CQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUF2QkE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFRQUEsMkJBQTJCLENBQUNDLElBQTVCLEdBQW1DLENBQUNDLHNDQUFELEVBQW1DQywyQkFBbkMsQ0FBbkM7O0FBRUEsU0FBU0gsMkJBQVQsQ0FDRUkseUJBREYsRUFFRUMsZUFGRixFQUdFO0FBQ0EsTUFBTUMsb0JBQW1ELGdCQUFHQyxrQkFBTUMsSUFBTixDQUMxRCxnQkFTTTtBQUFBLFFBUkpDLEdBUUksUUFSSkEsR0FRSTtBQUFBLFFBUEpDLFFBT0ksUUFQSkEsUUFPSTtBQUFBLFFBTkpDLGtCQU1JLFFBTkpBLGtCQU1JO0FBQUEsUUFMSkMsTUFLSSxRQUxKQSxNQUtJO0FBQUEsUUFKSkMsYUFJSSxRQUpKQSxhQUlJO0FBQUEsUUFISkMsU0FHSSxRQUhKQSxTQUdJO0FBQUEsUUFGSkMsWUFFSSxRQUZKQSxZQUVJO0FBQUEsUUFESkMsZUFDSSxRQURKQSxlQUNJO0FBQ0osUUFBTUMsV0FBVyxHQUFHLHdCQUFZLFVBQUFDLEtBQUs7QUFBQSxhQUFJSixTQUFTLENBQUNMLEdBQUQsRUFBTSxPQUFOLEVBQWVTLEtBQWYsQ0FBYjtBQUFBLEtBQWpCLEVBQXFELENBQUNULEdBQUQsRUFBTUssU0FBTixDQUFyRCxDQUFwQjtBQUVBLFFBQU1LLFlBQVksR0FBRyxvQkFDbkI7QUFBQSxhQUFNLENBQ0o7QUFDRUMsUUFBQUEsRUFBRSxFQUFFUixNQUFNLENBQUNRLEVBRGI7QUFFRUMsUUFBQUEsT0FBTyxFQUFFUixhQUZYO0FBR0VTLFFBQUFBLE9BQU8sRUFBRSxzQkFIWDtBQUlFQyxRQUFBQSxhQUFhLEVBQUVDLFlBSmpCO0FBS0VDLFFBQUFBLE1BQU0sRUFBRWIsTUFBTSxDQUFDYztBQUxqQixPQURJLENBQU47QUFBQSxLQURtQixFQVVuQixDQUFDZCxNQUFNLENBQUNRLEVBQVIsRUFBWVIsTUFBTSxDQUFDYyxRQUFuQixFQUE2QmIsYUFBN0IsQ0FWbUIsQ0FBckI7QUFhQSx3QkFDRSwrRUFDRSxnQ0FBQyx5QkFBRDtBQUNFLE1BQUEsa0JBQWtCLEVBQUVGLGtCQUR0QjtBQUVFLE1BQUEsUUFBUSxFQUFFRCxRQUZaO0FBR0UsTUFBQSxNQUFNLEVBQUVFLE1BSFY7QUFJRSxNQUFBLEdBQUcsRUFBRUgsR0FKUDtBQUtFLE1BQUEsWUFBWSxFQUFFTSxZQUxoQjtBQU1FLE1BQUEsU0FBUyxFQUFFRCxTQU5iO0FBT0UsTUFBQSxZQUFZLEVBQUVLO0FBUGhCLE9BU0dQLE1BQU0sQ0FBQ2UsSUFBUCxJQUFlLENBQUNmLE1BQU0sQ0FBQ2MsUUFBdkIsaUJBQ0M7QUFBSyxNQUFBLFNBQVMsRUFBQztBQUFmLG9CQUNFLGdDQUFDLGVBQUQ7QUFDRSxNQUFBLE1BQU0sRUFBRWQsTUFEVjtBQUVFLE1BQUEsZUFBZSxFQUFFSSxlQUZuQjtBQUdFLE1BQUEsU0FBUyxFQUFFQyxXQUhiO0FBSUUsTUFBQSxZQUFZLE1BSmQ7QUFLRSxNQUFBLGFBQWE7QUFMZixNQURGLENBVkosQ0FERixDQURGO0FBeUJELEdBbkR5RCxDQUE1RDs7QUFzREFYLEVBQUFBLG9CQUFvQixDQUFDc0IsV0FBckIsR0FBbUMsc0JBQW5DO0FBRUEsU0FBT3RCLG9CQUFQO0FBQ0Q7O2VBRWNOLDJCIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuaW1wb3J0IFJlYWN0LCB7dXNlQ2FsbGJhY2ssIHVzZU1lbW99IGZyb20gJ3JlYWN0JztcbmltcG9ydCBUaW1lUmFuZ2VGaWx0ZXJGYWN0b3J5IGZyb20gJy4uL3RpbWUtcmFuZ2UtZmlsdGVyJztcbmltcG9ydCB7Q2xvY2t9IGZyb20gJy4uLy4uL2NvbW1vbi9pY29ucyc7XG5pbXBvcnQgRmllbGRQYW5lbFdpdGhGaWVsZFNlbGVjdEZhY3RvcnkgZnJvbSAnLi9maWx0ZXItcGFuZWwtd2l0aC1maWVsZC1zZWxlY3QnO1xuaW1wb3J0IHtUaW1lUmFuZ2VGaWx0ZXJQYW5lbENvbXBvbmVudH0gZnJvbSAnLi90eXBlcyc7XG5cblRpbWVSYW5nZUZpbHRlclBhbmVsRmFjdG9yeS5kZXBzID0gW0ZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3RGYWN0b3J5LCBUaW1lUmFuZ2VGaWx0ZXJGYWN0b3J5XTtcblxuZnVuY3Rpb24gVGltZVJhbmdlRmlsdGVyUGFuZWxGYWN0b3J5KFxuICBGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0OiBSZXR1cm5UeXBlPHR5cGVvZiBGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0RmFjdG9yeT4sXG4gIFRpbWVSYW5nZUZpbHRlcjogUmV0dXJuVHlwZTx0eXBlb2YgVGltZVJhbmdlRmlsdGVyRmFjdG9yeT5cbikge1xuICBjb25zdCBUaW1lUmFuZ2VGaWx0ZXJQYW5lbDogVGltZVJhbmdlRmlsdGVyUGFuZWxDb21wb25lbnQgPSBSZWFjdC5tZW1vKFxuICAgICh7XG4gICAgICBpZHgsXG4gICAgICBkYXRhc2V0cyxcbiAgICAgIGFsbEF2YWlsYWJsZUZpZWxkcyxcbiAgICAgIGZpbHRlcixcbiAgICAgIGVubGFyZ2VGaWx0ZXIsXG4gICAgICBzZXRGaWx0ZXIsXG4gICAgICByZW1vdmVGaWx0ZXIsXG4gICAgICB0b2dnbGVBbmltYXRpb25cbiAgICB9KSA9PiB7XG4gICAgICBjb25zdCBvblNldEZpbHRlciA9IHVzZUNhbGxiYWNrKHZhbHVlID0+IHNldEZpbHRlcihpZHgsICd2YWx1ZScsIHZhbHVlKSwgW2lkeCwgc2V0RmlsdGVyXSk7XG5cbiAgICAgIGNvbnN0IHBhbmVsQWN0aW9ucyA9IHVzZU1lbW8oXG4gICAgICAgICgpID0+IFtcbiAgICAgICAgICB7XG4gICAgICAgICAgICBpZDogZmlsdGVyLmlkLFxuICAgICAgICAgICAgb25DbGljazogZW5sYXJnZUZpbHRlcixcbiAgICAgICAgICAgIHRvb2x0aXA6ICd0b29sdGlwLnRpbWVQbGF5YmFjaycsXG4gICAgICAgICAgICBpY29uQ29tcG9uZW50OiBDbG9jayxcbiAgICAgICAgICAgIGFjdGl2ZTogZmlsdGVyLmVubGFyZ2VkXG4gICAgICAgICAgfVxuICAgICAgICBdLFxuICAgICAgICBbZmlsdGVyLmlkLCBmaWx0ZXIuZW5sYXJnZWQsIGVubGFyZ2VGaWx0ZXJdXG4gICAgICApO1xuXG4gICAgICByZXR1cm4gKFxuICAgICAgICA8PlxuICAgICAgICAgIDxGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0XG4gICAgICAgICAgICBhbGxBdmFpbGFibGVGaWVsZHM9e2FsbEF2YWlsYWJsZUZpZWxkc31cbiAgICAgICAgICAgIGRhdGFzZXRzPXtkYXRhc2V0c31cbiAgICAgICAgICAgIGZpbHRlcj17ZmlsdGVyfVxuICAgICAgICAgICAgaWR4PXtpZHh9XG4gICAgICAgICAgICByZW1vdmVGaWx0ZXI9e3JlbW92ZUZpbHRlcn1cbiAgICAgICAgICAgIHNldEZpbHRlcj17c2V0RmlsdGVyfVxuICAgICAgICAgICAgcGFuZWxBY3Rpb25zPXtwYW5lbEFjdGlvbnN9XG4gICAgICAgICAgPlxuICAgICAgICAgICAge2ZpbHRlci50eXBlICYmICFmaWx0ZXIuZW5sYXJnZWQgJiYgKFxuICAgICAgICAgICAgICA8ZGl2IGNsYXNzTmFtZT1cImZpbHRlci1wYW5lbF9fZmlsdGVyXCI+XG4gICAgICAgICAgICAgICAgPFRpbWVSYW5nZUZpbHRlclxuICAgICAgICAgICAgICAgICAgZmlsdGVyPXtmaWx0ZXJ9XG4gICAgICAgICAgICAgICAgICB0b2dnbGVBbmltYXRpb249e3RvZ2dsZUFuaW1hdGlvbn1cbiAgICAgICAgICAgICAgICAgIHNldEZpbHRlcj17b25TZXRGaWx0ZXJ9XG4gICAgICAgICAgICAgICAgICBpc0FuaW1hdGFibGVcbiAgICAgICAgICAgICAgICAgIGhpZGVUaW1lVGl0bGVcbiAgICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgICA8L2Rpdj5cbiAgICAgICAgICAgICl9XG4gICAgICAgICAgPC9GaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0PlxuICAgICAgICA8Lz5cbiAgICAgICk7XG4gICAgfVxuICApO1xuXG4gIFRpbWVSYW5nZUZpbHRlclBhbmVsLmRpc3BsYXlOYW1lID0gJ1RpbWVSYW5nZUZpbHRlclBhbmVsJztcblxuICByZXR1cm4gVGltZVJhbmdlRmlsdGVyUGFuZWw7XG59XG5cbmV4cG9ydCBkZWZhdWx0IFRpbWVSYW5nZUZpbHRlclBhbmVsRmFjdG9yeTtcbiJdfQ==

package/dist/filters/filter-panels/types.d.ts

@@ -0,0 +1,35 @@
+import { FunctionComponent, ComponentType } from 'react';
+import { Filter, PolygonFilter, TimeRangeFilter, Field } from '@kepler.gl/types';
+import { Layer } from '@kepler.gl/layers';
+import { Datasets } from '@kepler.gl/table';
+interface PanelAction {
+    id: string;
+    tooltip: string;
+    onClick: () => void;
+    iconComponent: ComponentType;
+    active: boolean;
+}
+export interface FilterPanelProps<F = Filter> {
+    idx: number;
+    datasets: Datasets;
+    allAvailableFields: Field[];
+    filter: F;
+    removeFilter: () => void;
+    setFilter: (idx: number, field: string, value: any) => void;
+}
+export interface PolygonFilterPanelProps extends FilterPanelProps<PolygonFilter> {
+    layers: ReadonlyArray<Layer>;
+    toggleFilterFeature: () => void;
+}
+export interface TimeRangeFilterPanelProps extends FilterPanelProps<TimeRangeFilter> {
+    enlargeFilter: () => void;
+    toggleAnimation: () => void;
+}
+export interface FilterPanelWithFieldSelectProps extends FilterPanelProps {
+    panelActions?: ReadonlyArray<PanelAction>;
+}
+export declare type FilterPanelComponent<F> = FunctionComponent<FilterPanelProps<F>>;
+export declare type PolygonFilterPanelComponent = FunctionComponent<PolygonFilterPanelProps>;
+export declare type TimeRangeFilterPanelComponent = FunctionComponent<TimeRangeFilterPanelProps>;
+export declare type FilterPanelWithFieldSelectComponent = FunctionComponent<FilterPanelWithFieldSelectProps>;
+export {};

package/dist/filters/filter-panels/types.js

@@ -0,0 +1,26 @@
+// 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";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/filters/index.d.ts

@@ -0,0 +1,5 @@
+export { default as SingleSelectFilter } from './single-select-filter';
+export { default as MultiSelectFilter } from './multi-select-filter';
+export { default as TimeRangeFilter } from './time-range-filter';
+export { default as RangeFilter } from './range-filter';
+export { default as PolygonFilter } from './polygon-filter';