@kepler.gl/components 3.0.0-alpha.0

package/dist/side-panel/common/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/side-panel/custom-panel.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+declare function CustomPanelsFactory(): {
+    (props: any): JSX.Element;
+    defaultProps: {
+        panels: never[];
+        getProps: (sidePanelProps: any) => {};
+    };
+};
+export default CustomPanelsFactory;

package/dist/side-panel/custom-panel.js

@@ -0,0 +1,59 @@
+// 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");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));// This is a dummy component that can be replaced to inject more side panel sub panels into the side bar
+function CustomPanelsFactory() {
+  var CustomPanels = function CustomPanels(props) {
+    return /*#__PURE__*/_react["default"].createElement("div", null);
+  };
+
+  CustomPanels.defaultProps = {
+    // provide a list of additional panels
+    panels: [// {
+      //   id: 'rocket',
+      //   label: 'Rocket',
+      //   iconComponent: Icons.Rocket
+      // },
+      // {
+      //   id: 'chart',
+      //   label: 'Chart',
+      //   iconComponent: Icons.LineChart
+      // }
+    ],
+    // prop selector from side panel props
+    getProps: function getProps(sidePanelProps) {
+      return {};
+    }
+  };
+  return CustomPanels;
+}
+
+var _default = CustomPanelsFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zaWRlLXBhbmVsL2N1c3RvbS1wYW5lbC50c3giXSwibmFtZXMiOlsiQ3VzdG9tUGFuZWxzRmFjdG9yeSIsIkN1c3RvbVBhbmVscyIsInByb3BzIiwiZGVmYXVsdFByb3BzIiwicGFuZWxzIiwiZ2V0UHJvcHMiLCJzaWRlUGFuZWxQcm9wcyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBb0JBOztBQXBCQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUlBO0FBQ0EsU0FBU0EsbUJBQVQsR0FBK0I7QUFDN0IsTUFBTUMsWUFBWSxHQUFHLFNBQWZBLFlBQWUsQ0FBQUMsS0FBSyxFQUFJO0FBQzVCLHdCQUFPLDRDQUFQO0FBQ0QsR0FGRDs7QUFJQUQsRUFBQUEsWUFBWSxDQUFDRSxZQUFiLEdBQTRCO0FBQzFCO0FBQ0FDLElBQUFBLE1BQU0sRUFBRSxDQUNOO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBVk0sS0FGa0I7QUFjMUI7QUFDQUMsSUFBQUEsUUFBUSxFQUFFLGtCQUFBQyxjQUFjO0FBQUEsYUFBSyxFQUFMO0FBQUE7QUFmRSxHQUE1QjtBQWtCQSxTQUFPTCxZQUFQO0FBQ0Q7O2VBRWNELG1CIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcblxuLy8gVGhpcyBpcyBhIGR1bW15IGNvbXBvbmVudCB0aGF0IGNhbiBiZSByZXBsYWNlZCB0byBpbmplY3QgbW9yZSBzaWRlIHBhbmVsIHN1YiBwYW5lbHMgaW50byB0aGUgc2lkZSBiYXJcbmZ1bmN0aW9uIEN1c3RvbVBhbmVsc0ZhY3RvcnkoKSB7XG4gIGNvbnN0IEN1c3RvbVBhbmVscyA9IHByb3BzID0+IHtcbiAgICByZXR1cm4gPGRpdiAvPjtcbiAgfTtcblxuICBDdXN0b21QYW5lbHMuZGVmYXVsdFByb3BzID0ge1xuICAgIC8vIHByb3ZpZGUgYSBsaXN0IG9mIGFkZGl0aW9uYWwgcGFuZWxzXG4gICAgcGFuZWxzOiBbXG4gICAgICAvLyB7XG4gICAgICAvLyAgIGlkOiAncm9ja2V0JyxcbiAgICAgIC8vICAgbGFiZWw6ICdSb2NrZXQnLFxuICAgICAgLy8gICBpY29uQ29tcG9uZW50OiBJY29ucy5Sb2NrZXRcbiAgICAgIC8vIH0sXG4gICAgICAvLyB7XG4gICAgICAvLyAgIGlkOiAnY2hhcnQnLFxuICAgICAgLy8gICBsYWJlbDogJ0NoYXJ0JyxcbiAgICAgIC8vICAgaWNvbkNvbXBvbmVudDogSWNvbnMuTGluZUNoYXJ0XG4gICAgICAvLyB9XG4gICAgXSxcbiAgICAvLyBwcm9wIHNlbGVjdG9yIGZyb20gc2lkZSBwYW5lbCBwcm9wc1xuICAgIGdldFByb3BzOiBzaWRlUGFuZWxQcm9wcyA9PiAoe30pXG4gIH07XG5cbiAgcmV0dXJuIEN1c3RvbVBhbmVscztcbn1cblxuZXhwb3J0IGRlZmF1bHQgQ3VzdG9tUGFuZWxzRmFjdG9yeTtcbiJdfQ==

package/dist/side-panel/filter-manager.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import SourceDataCatalogFactory from './common/source-data-catalog';
+import FilterPanelFactory from './filter-panel/filter-panel';
+import { Filter } from '@kepler.gl/types';
+import { Layer } from '@kepler.gl/layers';
+import { VisStateActions, ActionHandler } from '@kepler.gl/actions';
+import { Datasets } from '@kepler.gl/table';
+declare type FilterManagerProps = {
+    filters: Filter[];
+    datasets: Datasets;
+    layers: Layer[];
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    visStateActions: typeof VisStateActions;
+};
+declare function FilterManagerFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, FilterPanel: ReturnType<typeof FilterPanelFactory>): ({ filters, datasets, layers, showDatasetTable, updateTableColor, visStateActions }: FilterManagerProps) => JSX.Element;
+declare namespace FilterManagerFactory {
+    var deps: (typeof SourceDataCatalogFactory | typeof FilterPanelFactory)[];
+}
+export default FilterManagerFactory;

package/dist/side-panel/filter-manager.js

@@ -0,0 +1,132 @@
+// 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 _localization = require("@kepler.gl/localization");
+
+var _styledComponents = require("../common/styled-components");
+
+var _icons = require("../common/icons");
+
+var _sourceDataCatalog = _interopRequireDefault(require("./common/source-data-catalog"));
+
+var _filterPanel = _interopRequireDefault(require("./filter-panel/filter-panel"));FilterManagerFactory.deps = [_sourceDataCatalog["default"], _filterPanel["default"]];
+
+function FilterManagerFactory(SourceDataCatalog, FilterPanel) {
+  var FilterManager = function FilterManager(_ref) {
+    var _ref$filters = _ref.filters,
+        filters = _ref$filters === void 0 ? [] : _ref$filters,
+        datasets = _ref.datasets,
+        layers = _ref.layers,
+        showDatasetTable = _ref.showDatasetTable,
+        updateTableColor = _ref.updateTableColor,
+        visStateActions = _ref.visStateActions;
+    var addFilter = visStateActions.addFilter,
+        _enlargeFilter = visStateActions.enlargeFilter,
+        _removeFilter = visStateActions.removeFilter,
+        setFilter = visStateActions.setFilter,
+        toggleFilterAnimation = visStateActions.toggleFilterAnimation,
+        _toggleFilterFeature = visStateActions.toggleFilterFeature;
+    var isAnyFilterAnimating = filters.some(function (f) {
+      return f.isAnimating;
+    });
+    var hadEmptyFilter = filters.some(function (f) {
+      return !f.name;
+    });
+    var hadDataset = Object.keys(datasets).length;
+    var onClickAddFilter = (0, _react.useCallback)(function () {
+      var defaultDataset = Object.keys(datasets).length && Object.keys(datasets)[0] || null;
+      addFilter(defaultDataset);
+    }, [datasets, addFilter]); // render last added filter first
+
+    var reversedIndex = (0, _react.useMemo)(function () {
+      return new Array(filters.length).fill(0).map(function (d, i) {
+        return i;
+      }).reverse();
+    }, [filters.length]);
+    var filterPanelCallbacks = (0, _react.useMemo)(function () {
+      return new Array(filters.length).fill(0).map(function (d, idx) {
+        return {
+          removeFilter: function removeFilter() {
+            return _removeFilter(idx);
+          },
+          enlargeFilter: function enlargeFilter() {
+            return _enlargeFilter(idx);
+          },
+          toggleAnimation: function toggleAnimation() {
+            return toggleFilterAnimation(idx);
+          },
+          toggleFilterFeature: function toggleFilterFeature() {
+            return _toggleFilterFeature(idx);
+          }
+        };
+      });
+    }, [filters.length, _removeFilter, _enlargeFilter, toggleFilterAnimation, _toggleFilterFeature]);
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-manager"
+    }, /*#__PURE__*/_react["default"].createElement(SourceDataCatalog, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor
+    }), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelDivider, null), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, reversedIndex.map(function (idx) {
+      return /*#__PURE__*/_react["default"].createElement(FilterPanel, {
+        key: "".concat(filters[idx].id, "-").concat(idx),
+        idx: idx,
+        filters: filters,
+        filter: filters[idx],
+        datasets: datasets,
+        layers: layers,
+        isAnyFilterAnimating: isAnyFilterAnimating,
+        removeFilter: filterPanelCallbacks[idx].removeFilter,
+        enlargeFilter: filterPanelCallbacks[idx].enlargeFilter,
+        toggleAnimation: filterPanelCallbacks[idx].toggleAnimation,
+        toggleFilterFeature: filterPanelCallbacks[idx].toggleFilterFeature,
+        setFilter: setFilter
+      });
+    })), /*#__PURE__*/_react["default"].createElement(_styledComponents.Button, {
+      className: "add-filter-button",
+      inactive: hadEmptyFilter || !hadDataset,
+      width: "105px",
+      onClick: onClickAddFilter
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+      height: "12px"
+    }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'filterManager.addFilter'
+    })));
+  };
+
+  return FilterManager;
+}
+
+var _default = FilterManagerFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/side-panel/filter-manager.tsx"],"names":["FilterManagerFactory","deps","SourceDataCatalogFactory","FilterPanelFactory","SourceDataCatalog","FilterPanel","FilterManager","filters","datasets","layers","showDatasetTable","updateTableColor","visStateActions","addFilter","enlargeFilter","removeFilter","setFilter","toggleFilterAnimation","toggleFilterFeature","isAnyFilterAnimating","some","f","isAnimating","hadEmptyFilter","name","hadDataset","Object","keys","length","onClickAddFilter","defaultDataset","reversedIndex","Array","fill","map","d","i","reverse","filterPanelCallbacks","idx","toggleAnimation","id"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {useCallback, useMemo} from 'react';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {Button, SidePanelDivider, SidePanelSection} from '../common/styled-components';\nimport {Add} from '../common/icons';\nimport SourceDataCatalogFactory from './common/source-data-catalog';\nimport FilterPanelFactory from './filter-panel/filter-panel';\nimport {Filter} from '@kepler.gl/types';\nimport {Layer} from '@kepler.gl/layers';\nimport {VisStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {Datasets} from '@kepler.gl/table';\n\ntype FilterManagerProps = {\n  filters: Filter[];\n  datasets: Datasets;\n  layers: Layer[];\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  visStateActions: typeof VisStateActions;\n};\n\nFilterManagerFactory.deps = [SourceDataCatalogFactory, FilterPanelFactory];\n\nfunction FilterManagerFactory(\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>,\n  FilterPanel: ReturnType<typeof FilterPanelFactory>\n) {\n  const FilterManager = ({\n    filters = [],\n    datasets,\n    layers,\n    showDatasetTable,\n    updateTableColor,\n    visStateActions\n  }: FilterManagerProps) => {\n    const {\n      addFilter,\n      enlargeFilter,\n      removeFilter,\n      setFilter,\n      toggleFilterAnimation,\n      toggleFilterFeature\n    } = visStateActions;\n    const isAnyFilterAnimating = filters.some(f => f.isAnimating);\n    const hadEmptyFilter = filters.some(f => !f.name);\n    const hadDataset = Object.keys(datasets).length;\n    const onClickAddFilter = useCallback(() => {\n      const defaultDataset = (Object.keys(datasets).length && Object.keys(datasets)[0]) || null;\n      addFilter(defaultDataset);\n    }, [datasets, addFilter]);\n    // render last added filter first\n    const reversedIndex = useMemo(() => {\n      return new Array(filters.length)\n        .fill(0)\n        .map((d, i) => i)\n        .reverse();\n    }, [filters.length]);\n\n    const filterPanelCallbacks = useMemo(() => {\n      return new Array(filters.length).fill(0).map((d, idx) => ({\n        removeFilter: () => removeFilter(idx),\n        enlargeFilter: () => enlargeFilter(idx),\n        toggleAnimation: () => toggleFilterAnimation(idx),\n        toggleFilterFeature: () => toggleFilterFeature(idx)\n      }));\n    }, [filters.length, removeFilter, enlargeFilter, toggleFilterAnimation, toggleFilterFeature]);\n\n    return (\n      <div className=\"filter-manager\">\n        <SourceDataCatalog\n          datasets={datasets}\n          showDatasetTable={showDatasetTable}\n          updateTableColor={updateTableColor}\n        />\n        <SidePanelDivider />\n        <SidePanelSection>\n          {reversedIndex.map(idx => (\n            <FilterPanel\n              key={`${filters[idx].id}-${idx}`}\n              idx={idx}\n              filters={filters}\n              filter={filters[idx]}\n              datasets={datasets}\n              layers={layers}\n              isAnyFilterAnimating={isAnyFilterAnimating}\n              removeFilter={filterPanelCallbacks[idx].removeFilter}\n              enlargeFilter={filterPanelCallbacks[idx].enlargeFilter}\n              toggleAnimation={filterPanelCallbacks[idx].toggleAnimation}\n              toggleFilterFeature={filterPanelCallbacks[idx].toggleFilterFeature}\n              setFilter={setFilter}\n            />\n          ))}\n        </SidePanelSection>\n        <Button\n          className=\"add-filter-button\"\n          inactive={hadEmptyFilter || !hadDataset}\n          width=\"105px\"\n          onClick={onClickAddFilter}\n        >\n          <Add height=\"12px\" />\n          <FormattedMessage id={'filterManager.addFilter'} />\n        </Button>\n      </div>\n    );\n  };\n\n  return FilterManager;\n}\n\nexport default FilterManagerFactory;\n"]}

package/dist/side-panel/filter-panel/filter-panel-header.d.ts

@@ -0,0 +1,21 @@
+import React, { ComponentType } from 'react';
+import PanelHeaderActionFactory from '../../side-panel/panel-header-action';
+import { StyledPanelHeaderProps } from '../../common/styled-components';
+import { RGBColor, Filter } from '@kepler.gl/types';
+import { KeplerTable } from '@kepler.gl/table';
+interface StyledFilterHeaderProps extends StyledPanelHeaderProps {
+    $labelRCGColorValues: RGBColor[];
+}
+export declare const StyledFilterHeader: import("styled-components").StyledComponent<"div", any, StyledPanelHeaderProps & StyledFilterHeaderProps, never>;
+declare type FilterPanelHeaderProps = {
+    children: React.ReactNode;
+    datasets: KeplerTable[];
+    filter: Filter;
+    removeFilter: () => void;
+    actionIcons?: Record<string, ComponentType>;
+};
+declare function FilterPanelHeaderFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.ComponentType<FilterPanelHeaderProps>;
+declare namespace FilterPanelHeaderFactory {
+    var deps: (typeof PanelHeaderActionFactory)[];
+}
+export default FilterPanelHeaderFactory;

package/dist/side-panel/filter-panel/filter-panel-header.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");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.StyledFilterHeader = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _panelHeaderAction = _interopRequireDefault(require("../../side-panel/panel-header-action"));
+
+var _icons = require("../../common/icons");
+
+var _utils = require("@kepler.gl/utils");
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _templateObject, _templateObject2;
+
+var StyledFilterHeader = (0, _styledComponents["default"])(_styledComponents2.StyledPanelHeader)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: pointer;\n  padding: 10px 12px;\n\n  .field-selector {\n    flex: 2;\n  }\n\n  border-left: 3px solid;\n  ", ";\n"])), function (props) {
+  return props.$labelRCGColorValues && props.$labelRCGColorValues.length > 0 ? "border-image: ".concat((0, _utils.createLinearGradient)('bottom', props.$labelRCGColorValues), " 3;") : 'border-color: transparent;';
+});
+exports.StyledFilterHeader = StyledFilterHeader;
+
+var StyledChildrenContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex: 2;\n"])));
+
+FilterPanelHeaderFactory.deps = [_panelHeaderAction["default"]];
+
+function FilterPanelHeaderFactory(PanelHeaderAction) {
+  var defaultActionIcons = {
+    "delete": _icons.Trash
+  };
+
+  var FilterPanelHeader = function FilterPanelHeader(_ref) {
+    var children = _ref.children,
+        datasets = _ref.datasets,
+        filter = _ref.filter,
+        removeFilter = _ref.removeFilter,
+        _ref$actionIcons = _ref.actionIcons,
+        actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    return /*#__PURE__*/_react["default"].createElement(StyledFilterHeader, {
+      className: "filter-panel__header",
+      $labelRCGColorValues: datasets.map(function (d) {
+        return d.color;
+      })
+    }, /*#__PURE__*/_react["default"].createElement(StyledChildrenContainer, null, children), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      id: filter.id,
+      tooltip: "tooltip.delete",
+      tooltipType: "error",
+      onClick: removeFilter,
+      hoverColor: 'errorColor',
+      IconComponent: actionIcons["delete"]
+    }));
+  };
+
+  return FilterPanelHeader;
+}
+
+var _default = FilterPanelHeaderFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/filter-panel/filter-panel.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import NewFilterPanelFactory from '../../filters/filter-panels/new-filter-panel';
+import TimeRangeFilterPanelFactory from '../../filters/filter-panels/time-range-filter-panel';
+import SingleSelectFilterPanelFactory from '../../filters/filter-panels/single-select-filter-panel';
+import MultiSelectFilterPanelFactory from '../../filters/filter-panels/multi-select-filter-panel';
+import RangeFilterPanelFactory from '../../filters/filter-panels/range-filter-panel';
+import PolygonFilterPanelFactory from '../../filters/filter-panels/polygon-filter-panel';
+import { Filter } from '@kepler.gl/types';
+import { FilterPanelProps } from '../../filters/filter-panels/types';
+import { Layer } from '@kepler.gl/layers';
+interface FilterPanelPropsImpl extends Omit<FilterPanelProps, 'allAvailableFields'> {
+    filters: Filter[];
+    layers: ReadonlyArray<Layer>;
+    isAnyFilterAnimating: boolean;
+    enlargeFilter: () => void;
+    toggleAnimation: () => void;
+    toggleFilterFeature: () => void;
+}
+declare function FilterPanelFactory(NewFilterPanel: ReturnType<typeof NewFilterPanelFactory>, TimeRangeFilterPanel: ReturnType<typeof TimeRangeFilterPanelFactory>, SingleSelectFilterPanel: ReturnType<typeof SingleSelectFilterPanelFactory>, MultiSelectFilterPanel: ReturnType<typeof MultiSelectFilterPanelFactory>, RangeFilterPanel: ReturnType<typeof RangeFilterPanelFactory>, PolygonFilterPanel: ReturnType<typeof PolygonFilterPanelFactory>): React.ComponentType<FilterPanelPropsImpl>;
+declare namespace FilterPanelFactory {
+    var deps: (typeof PolygonFilterPanelFactory | typeof NewFilterPanelFactory | typeof TimeRangeFilterPanelFactory | typeof SingleSelectFilterPanelFactory | typeof MultiSelectFilterPanelFactory | typeof RangeFilterPanelFactory)[];
+}
+export default FilterPanelFactory;

package/dist/side-panel/filter-panel/filter-panel.js

@@ -0,0 +1,151 @@
+// 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 _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reselect = require("reselect");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _newFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/new-filter-panel"));
+
+var _timeRangeFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/time-range-filter-panel"));
+
+var _singleSelectFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/single-select-filter-panel"));
+
+var _multiSelectFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/multi-select-filter-panel"));
+
+var _rangeFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/range-filter-panel"));
+
+var _polygonFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/polygon-filter-panel"));
+
+var _templateObject;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var StyledFilterPanel = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: 12px;\n  border-radius: 1px;\n"])));
+
+FilterPanelFactory.deps = [_newFilterPanel["default"], _timeRangeFilterPanel["default"], _singleSelectFilterPanel["default"], _multiSelectFilterPanel["default"], _rangeFilterPanel["default"], _polygonFilterPanel["default"]];
+
+function FilterPanelFactory(NewFilterPanel, TimeRangeFilterPanel, SingleSelectFilterPanel, MultiSelectFilterPanel, RangeFilterPanel, PolygonFilterPanel) {
+  var _FilterPanelComponent;
+
+  var FilterPanelComponents = (_FilterPanelComponent = {
+    "default": NewFilterPanel
+  }, (0, _defineProperty2["default"])(_FilterPanelComponent, _constants.FILTER_TYPES.timeRange, TimeRangeFilterPanel), (0, _defineProperty2["default"])(_FilterPanelComponent, _constants.FILTER_TYPES.select, SingleSelectFilterPanel), (0, _defineProperty2["default"])(_FilterPanelComponent, _constants.FILTER_TYPES.multiSelect, MultiSelectFilterPanel), (0, _defineProperty2["default"])(_FilterPanelComponent, _constants.FILTER_TYPES.range, RangeFilterPanel), (0, _defineProperty2["default"])(_FilterPanelComponent, _constants.FILTER_TYPES.polygon, PolygonFilterPanel), _FilterPanelComponent);
+  return /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(FilterPanel, _Component);
+
+    var _super = _createSuper(FilterPanel);
+
+    function FilterPanel() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, FilterPanel);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fieldsSelector", function (props) {
+        var datasetId = props.filter.dataId[0];
+
+        if (!datasetId) {
+          return [];
+        }
+
+        return (0, _lodash["default"])(props, ['datasets', datasetId, 'fields'], []);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filterSelector", function (props) {
+        return props.filters;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "nameSelector", function (props) {
+        return props.filter.name;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "dataIdSelector", function (props) {
+        return props.filter.dataId[0];
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "availableFieldsSelector", (0, _reselect.createSelector)(_this.fieldsSelector, _this.filterSelector, _this.nameSelector, _this.dataIdSelector, function (fields, filters, name, dataId) {
+        return fields.filter(function (f) {
+          return f.type && f.type !== _constants.ALL_FIELD_TYPES.geojson && (name.includes(f.name) || !filters.find(function (d) {
+            return d.name.includes(f.name) && d.dataId.includes(dataId);
+          }));
+        });
+      }));
+      return _this;
+    }
+
+    (0, _createClass2["default"])(FilterPanel, [{
+      key: "render",
+      value: function render() {
+        var filter = this.props.filter;
+        var type = filter.type;
+        var FilterFilterComponent = type && FilterPanelComponents[type] || FilterPanelComponents["default"];
+        var allAvailableFields = this.availableFieldsSelector(this.props);
+        return /*#__PURE__*/_react["default"].createElement(StyledFilterPanel, {
+          className: "filter-panel"
+        }, /*#__PURE__*/_react["default"].createElement(FilterFilterComponent, (0, _extends2["default"])({
+          allAvailableFields: allAvailableFields
+        }, this.props)));
+      }
+    }]);
+    return FilterPanel;
+  }(_react.Component);
+}
+
+var _default = FilterPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/filter-panel/filter-panel.tsx"],"names":["StyledFilterPanel","styled","div","FilterPanelFactory","deps","NewFilterPanelFactory","TimeRangeFilterPanelFactory","SingleSelectFilterPanelFactory","MultiSelectFilterPanelFactory","RangeFilterPanelFactory","PolygonFilterPanelFactory","NewFilterPanel","TimeRangeFilterPanel","SingleSelectFilterPanel","MultiSelectFilterPanel","RangeFilterPanel","PolygonFilterPanel","FilterPanelComponents","FILTER_TYPES","timeRange","select","multiSelect","range","polygon","props","datasetId","filter","dataId","filters","name","fieldsSelector","filterSelector","nameSelector","dataIdSelector","fields","f","type","ALL_FIELD_TYPES","geojson","includes","find","d","FilterFilterComponent","allAvailableFields","availableFieldsSelector","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component} from 'react';\nimport {createSelector} from 'reselect';\nimport styled from 'styled-components';\nimport get from 'lodash.get';\nimport {ALL_FIELD_TYPES, FILTER_TYPES} from '@kepler.gl/constants';\n\nimport NewFilterPanelFactory from '../../filters/filter-panels/new-filter-panel';\nimport TimeRangeFilterPanelFactory from '../../filters/filter-panels/time-range-filter-panel';\nimport SingleSelectFilterPanelFactory from '../../filters/filter-panels/single-select-filter-panel';\nimport MultiSelectFilterPanelFactory from '../../filters/filter-panels/multi-select-filter-panel';\nimport RangeFilterPanelFactory from '../../filters/filter-panels/range-filter-panel';\nimport PolygonFilterPanelFactory from '../../filters/filter-panels/polygon-filter-panel';\nimport {Field, Filter} from '@kepler.gl/types';\nimport {FilterPanelProps} from '../../filters/filter-panels/types';\nimport {Layer} from '@kepler.gl/layers';\n\nconst StyledFilterPanel = styled.div`\n  margin-bottom: 12px;\n  border-radius: 1px;\n`;\n\ninterface FilterPanelPropsImpl extends Omit<FilterPanelProps, 'allAvailableFields'> {\n  filters: Filter[];\n  layers: ReadonlyArray<Layer>;\n  isAnyFilterAnimating: boolean;\n  enlargeFilter: () => void;\n  toggleAnimation: () => void;\n  toggleFilterFeature: () => void;\n}\n\nFilterPanelFactory.deps = [\n  NewFilterPanelFactory,\n  TimeRangeFilterPanelFactory,\n  SingleSelectFilterPanelFactory,\n  MultiSelectFilterPanelFactory,\n  RangeFilterPanelFactory,\n  PolygonFilterPanelFactory\n];\n\nfunction FilterPanelFactory(\n  NewFilterPanel: ReturnType<typeof NewFilterPanelFactory>,\n  TimeRangeFilterPanel: ReturnType<typeof TimeRangeFilterPanelFactory>,\n  SingleSelectFilterPanel: ReturnType<typeof SingleSelectFilterPanelFactory>,\n  MultiSelectFilterPanel: ReturnType<typeof MultiSelectFilterPanelFactory>,\n  RangeFilterPanel: ReturnType<typeof RangeFilterPanelFactory>,\n  PolygonFilterPanel: ReturnType<typeof PolygonFilterPanelFactory>\n): React.ComponentType<FilterPanelPropsImpl> {\n  const FilterPanelComponents = {\n    default: NewFilterPanel,\n    [FILTER_TYPES.timeRange]: TimeRangeFilterPanel,\n    [FILTER_TYPES.select]: SingleSelectFilterPanel,\n    [FILTER_TYPES.multiSelect]: MultiSelectFilterPanel,\n    [FILTER_TYPES.range]: RangeFilterPanel,\n    [FILTER_TYPES.polygon]: PolygonFilterPanel\n  };\n\n  return class FilterPanel extends Component<FilterPanelPropsImpl> {\n    /* selectors */\n    fieldsSelector = (props: FilterPanelPropsImpl) => {\n      const datasetId = props.filter.dataId[0];\n      if (!datasetId) {\n        return [];\n      }\n      return get(props, ['datasets', datasetId, 'fields'], []);\n    };\n\n    filterSelector = (props: FilterPanelPropsImpl) => props.filters;\n    nameSelector = (props: FilterPanelPropsImpl) => props.filter.name;\n    dataIdSelector = (props: FilterPanelPropsImpl) => props.filter.dataId[0];\n\n    // only show current field and field that's not already been used as a filter\n    availableFieldsSelector = createSelector(\n      this.fieldsSelector,\n      this.filterSelector,\n      this.nameSelector,\n      this.dataIdSelector,\n      (fields, filters, name, dataId) =>\n        fields.filter(\n          (f: Field) =>\n            f.type &&\n            f.type !== ALL_FIELD_TYPES.geojson &&\n            (name.includes(f.name) ||\n              !filters.find(d => d.name.includes(f.name) && d.dataId.includes(dataId)))\n        )\n    );\n\n    render() {\n      const {filter} = this.props;\n\n      const {type} = filter;\n      const FilterFilterComponent =\n        (type && FilterPanelComponents[type]) || FilterPanelComponents.default;\n      const allAvailableFields = this.availableFieldsSelector(this.props);\n\n      return (\n        <StyledFilterPanel className=\"filter-panel\">\n          <FilterFilterComponent allAvailableFields={allAvailableFields} {...this.props} />\n        </StyledFilterPanel>\n      );\n    }\n  };\n}\n\nexport default FilterPanelFactory;\n"]}

package/dist/side-panel/interaction-manager.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { InteractionConfig } from '@kepler.gl/types';
+import InteractionPanelFactory from './interaction-panel/interaction-panel';
+import { VisStateActions } from '@kepler.gl/actions';
+import { Datasets } from '@kepler.gl/table';
+declare type InteractionManagerProps = {
+    interactionConfig: InteractionConfig;
+    datasets: Datasets;
+    visStateActions: typeof VisStateActions;
+};
+declare function InteractionManagerFactory(InteractionPanel: ReturnType<typeof InteractionPanelFactory>): React.FC<InteractionManagerProps>;
+declare namespace InteractionManagerFactory {
+    var deps: (typeof InteractionPanelFactory)[];
+}
+export default InteractionManagerFactory;