@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

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

@@ -0,0 +1,199 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import { useIntl } from 'react-intl';
+import { SidePanelDivider, SidePanelSection } from '../common/styled-components';
+import SourceDataCatalogFactory from './common/source-data-catalog';
+import FilterPanelFactory from './filter-panel/filter-panel';
+import { FILTER_VIEW_TYPES, PANEL_VIEW_TOGGLES } from '@kepler.gl/constants';
+import { isSideFilter } from '@kepler.gl/utils';
+import PanelViewListToggleFactory from './panel-view-list-toggle';
+import PanelTitleFactory from './panel-title';
+import AddFilterButtonFactory from './filter-panel/add-filter-button';
+import DatasetSectionFactory from './layer-panel/dataset-section';
+FilterManagerFactory.deps = [DatasetSectionFactory, FilterPanelFactory, PanelTitleFactory, AddFilterButtonFactory, PanelViewListToggleFactory, SourceDataCatalogFactory];
+function FilterManagerFactory(DatasetSection, FilterPanel, PanelTitle, AddFilterButton, PanelViewListToggle, SourceDataCatalog) {
+  var FilterList = function FilterList(_ref) {
+    var filtersByIndex = _ref.filtersByIndex,
+      filters = _ref.filters,
+      datasets = _ref.datasets,
+      layers = _ref.layers,
+      isAnyFilterAnimating = _ref.isAnyFilterAnimating,
+      visStateActions = _ref.visStateActions;
+    var _removeFilter = visStateActions.removeFilter,
+      setFilter = visStateActions.setFilter,
+      setFilterPlot = visStateActions.setFilterPlot,
+      toggleFilterAnimation = visStateActions.toggleFilterAnimation,
+      _toggleFilterFeature = visStateActions.toggleFilterFeature,
+      setFilterView = visStateActions.setFilterView,
+      syncTimeFilterWithLayerTimeline = visStateActions.syncTimeFilterWithLayerTimeline;
+    var filterPanelCallbacks = useMemo(function () {
+      return filtersByIndex.reduce(function (accu, _ref2) {
+        var filter = _ref2.filter,
+          idx = _ref2.idx;
+        return _objectSpread(_objectSpread({}, accu), {}, _defineProperty({}, filter.id, {
+          removeFilter: function removeFilter() {
+            return _removeFilter(idx);
+          },
+          toggleFilterView: function toggleFilterView() {
+            return setFilterView(idx, isSideFilter(filter) ? FILTER_VIEW_TYPES.enlarged : FILTER_VIEW_TYPES.side);
+          },
+          toggleAnimation: function toggleAnimation() {
+            return toggleFilterAnimation(idx);
+          },
+          toggleFilterFeature: function toggleFilterFeature() {
+            return _toggleFilterFeature(idx);
+          }
+        }));
+      }, {});
+    }, [filtersByIndex, _removeFilter, setFilterView, toggleFilterAnimation, _toggleFilterFeature]);
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, _toConsumableArray(filtersByIndex).reverse().map(function (_ref3) {
+      var filter = _ref3.filter,
+        idx = _ref3.idx;
+      return /*#__PURE__*/React.createElement(FilterPanel, {
+        key: "".concat(filter.id, "-").concat(idx),
+        idx: idx,
+        filters: filters,
+        filter: filter,
+        datasets: datasets,
+        layers: layers,
+        isAnyFilterAnimating: isAnyFilterAnimating,
+        removeFilter: filterPanelCallbacks[filter.id].removeFilter,
+        enlargeFilter: filterPanelCallbacks[filter.id].toggleFilterView,
+        toggleAnimation: filterPanelCallbacks[filter.id].toggleAnimation,
+        toggleFilterFeature: filterPanelCallbacks[filter.id].toggleFilterFeature,
+        setFilter: setFilter,
+        setFilterPlot: setFilterPlot,
+        syncTimeFilterWithLayerTimeline: syncTimeFilterWithLayerTimeline
+      });
+    }));
+  };
+  var DatasetFilterSection = function DatasetFilterSection(_ref4) {
+    var filtersByIndex = _ref4.filtersByIndex,
+      filters = _ref4.filters,
+      dataset = _ref4.dataset,
+      datasets = _ref4.datasets,
+      layers = _ref4.layers,
+      isAnyFilterAnimating = _ref4.isAnyFilterAnimating,
+      visStateActions = _ref4.visStateActions,
+      showDatasetTable = _ref4.showDatasetTable,
+      updateTableColor = _ref4.updateTableColor,
+      removeDataset = _ref4.removeDataset,
+      showDeleteDataset = _ref4.showDeleteDataset;
+    var datasetCatalog = useMemo(function () {
+      return _defineProperty({}, dataset.id, dataset);
+    }, [dataset]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(SourceDataCatalog, {
+      datasets: datasetCatalog,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset,
+      refreshDataset: visStateActions.refreshDataset,
+      updateDatasetProps: visStateActions.updateDatasetProps
+    }), /*#__PURE__*/React.createElement(FilterList, {
+      filtersByIndex: filtersByIndex,
+      filters: filters,
+      datasets: datasets,
+      layers: layers,
+      isAnyFilterAnimating: isAnyFilterAnimating,
+      visStateActions: visStateActions
+    }));
+  };
+  var FilterManager = function FilterManager(_ref6) {
+    var _ref6$filters = _ref6.filters,
+      filters = _ref6$filters === void 0 ? [] : _ref6$filters,
+      datasets = _ref6.datasets,
+      layers = _ref6.layers,
+      showDatasetTable = _ref6.showDatasetTable,
+      updateTableColor = _ref6.updateTableColor,
+      removeDataset = _ref6.removeDataset,
+      showAddDataModal = _ref6.showAddDataModal,
+      panelMetadata = _ref6.panelMetadata,
+      panelListView = _ref6.panelListView,
+      visStateActions = _ref6.visStateActions,
+      uiStateActions = _ref6.uiStateActions;
+    var addFilter = visStateActions.addFilter;
+    var togglePanelListView = uiStateActions.togglePanelListView;
+    var isAnyFilterAnimating = filters.some(function (f) {
+      return f.isAnimating;
+    });
+    var onClickAddFilter = useCallback(function (dataset) {
+      return addFilter(dataset);
+    }, [addFilter]);
+    var isSortByDatasetMode = panelListView === PANEL_VIEW_TOGGLES.byDataset;
+    var filtersByIndex = useMemo(function () {
+      return filters.map(function (f, idx) {
+        return {
+          filter: f,
+          idx: idx
+        };
+      });
+    }, [filters]);
+    var filtersByDatasets = useMemo(function () {
+      return Object.keys(datasets).reduce(function (accu, dataId) {
+        return _objectSpread(_objectSpread({}, accu), {}, _defineProperty({}, dataId, filtersByIndex.filter(function (fidx) {
+          return fidx.filter.dataId && fidx.filter.dataId[0] === dataId;
+        })));
+      }, {});
+    }, [datasets, filtersByIndex]);
+    var _TogglePanelListView = useCallback(function (listView) {
+      togglePanelListView({
+        panelId: 'filter',
+        listView: listView
+      });
+    }, [togglePanelListView]);
+    var intl = useIntl();
+    var filterListProps = {
+      datasets: datasets,
+      filters: filters,
+      layers: layers,
+      isAnyFilterAnimating: isAnyFilterAnimating,
+      visStateActions: visStateActions
+    };
+    var sourceDataCatalogProps = {
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: true,
+      refreshDataset: visStateActions.refreshDataset,
+      updateDatasetProps: visStateActions.updateDatasetProps
+    };
+    return /*#__PURE__*/React.createElement("div", {
+      className: "filter-manager"
+    }, /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelViewListToggle, {
+      togglePanelListView: _TogglePanelListView,
+      mode: panelListView
+    })), /*#__PURE__*/React.createElement(DatasetSection, _extends({
+      datasets: datasets
+    }, sourceDataCatalogProps, {
+      showDatasetList: !isSortByDatasetMode,
+      showAddDataModal: showAddDataModal
+    })), /*#__PURE__*/React.createElement(SidePanelDivider, null), /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelTitle, {
+      className: "filter-manager-title",
+      title: intl.formatMessage({
+        id: panelMetadata.label
+      })
+    }, /*#__PURE__*/React.createElement(AddFilterButton, {
+      datasets: datasets,
+      onAdd: onClickAddFilter
+    }))), /*#__PURE__*/React.createElement(SidePanelSection, null, isSortByDatasetMode ? Object.keys(filtersByDatasets).map(function (dataId) {
+      return /*#__PURE__*/React.createElement(DatasetFilterSection, _extends({
+        key: dataId,
+        filtersByIndex: filtersByDatasets[dataId],
+        dataset: datasets[dataId]
+      }, filterListProps, sourceDataCatalogProps));
+    }) : /*#__PURE__*/React.createElement(FilterList, _extends({
+      filtersByIndex: filtersByIndex
+    }, filterListProps))));
+  };
+  return FilterManager;
+}
+export default FilterManagerFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","useIntl","SidePanelDivider","SidePanelSection","SourceDataCatalogFactory","FilterPanelFactory","FILTER_VIEW_TYPES","PANEL_VIEW_TOGGLES","isSideFilter","PanelViewListToggleFactory","PanelTitleFactory","AddFilterButtonFactory","DatasetSectionFactory","FilterManagerFactory","deps","DatasetSection","FilterPanel","PanelTitle","AddFilterButton","PanelViewListToggle","SourceDataCatalog","FilterList","_ref","filtersByIndex","filters","datasets","layers","isAnyFilterAnimating","visStateActions","removeFilter","setFilter","setFilterPlot","toggleFilterAnimation","toggleFilterFeature","setFilterView","syncTimeFilterWithLayerTimeline","filterPanelCallbacks","reduce","accu","_ref2","filter","idx","_objectSpread","_defineProperty","id","toggleFilterView","enlarged","side","toggleAnimation","createElement","_toConsumableArray","reverse","map","_ref3","key","concat","enlargeFilter","DatasetFilterSection","_ref4","dataset","showDatasetTable","updateTableColor","removeDataset","showDeleteDataset","datasetCatalog","Fragment","refreshDataset","updateDatasetProps","FilterManager","_ref6","_ref6$filters","showAddDataModal","panelMetadata","panelListView","uiStateActions","addFilter","togglePanelListView","some","f","isAnimating","onClickAddFilter","isSortByDatasetMode","byDataset","filtersByDatasets","Object","keys","dataId","fidx","_TogglePanelListView","listView","panelId","intl","filterListProps","sourceDataCatalogProps","className","mode","_extends","showDatasetList","title","formatMessage","label","onAdd"],"sources":["../../../src/side-panel/filter-manager.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo} from 'react';\nimport {useIntl} from 'react-intl';\nimport {SidePanelDivider, SidePanelSection} from '../common/styled-components';\nimport SourceDataCatalogFactory from './common/source-data-catalog';\nimport FilterPanelFactory from './filter-panel/filter-panel';\nimport {FILTER_VIEW_TYPES, PANEL_VIEW_TOGGLES} from '@kepler.gl/constants';\nimport {Filter} from '@kepler.gl/types';\nimport {Layer} from '@kepler.gl/layers';\nimport {isSideFilter} from '@kepler.gl/utils';\nimport {VisStateActions, ActionHandler, UIStateActions, ActionHandlers} from '@kepler.gl/actions';\nimport {Datasets} from '@kepler.gl/table';\n\nimport PanelViewListToggleFactory from './panel-view-list-toggle';\nimport PanelTitleFactory from './panel-title';\nimport AddFilterButtonFactory from './filter-panel/add-filter-button';\nimport DatasetSectionFactory from './layer-panel/dataset-section';\nimport {PanelMeta} from './common/types';\n\nexport type VisStateActionHandlers = ActionHandlers<typeof VisStateActions>;\nexport type UiStateActionHandlers = ActionHandlers<typeof UIStateActions>;\n\nexport type FilterManagerProps = {\n  filters: Filter[];\n  datasets: Datasets;\n  layers: Layer[];\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  removeDataset: ActionHandler<typeof VisStateActions.removeDataset>;\n  showAddDataModal: () => void;\n\n  panelMetadata: PanelMeta;\n  panelListView: string;\n  visStateActions: VisStateActionHandlers;\n  uiStateActions: UiStateActionHandlers;\n};\n\ntype FilterListProps = {\n  filters: Filter[];\n  datasets: Datasets;\n  layers: Layer[];\n  filtersByIndex: {\n    filter: Filter;\n    idx: number;\n  }[];\n  isAnyFilterAnimating: boolean;\n  visStateActions: VisStateActionHandlers;\n};\n\nFilterManagerFactory.deps = [\n  DatasetSectionFactory,\n  FilterPanelFactory,\n  PanelTitleFactory,\n  AddFilterButtonFactory,\n  PanelViewListToggleFactory,\n  SourceDataCatalogFactory\n];\n\nfunction FilterManagerFactory(\n  DatasetSection: ReturnType<typeof DatasetSectionFactory>,\n  FilterPanel: ReturnType<typeof FilterPanelFactory>,\n  PanelTitle: ReturnType<typeof PanelTitleFactory>,\n  AddFilterButton: ReturnType<typeof AddFilterButtonFactory>,\n  PanelViewListToggle: ReturnType<typeof PanelViewListToggleFactory>,\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>\n) {\n  const FilterList = ({\n    filtersByIndex,\n    filters,\n    datasets,\n    layers,\n    isAnyFilterAnimating,\n    visStateActions\n  }: FilterListProps) => {\n    const {\n      removeFilter,\n      setFilter,\n      setFilterPlot,\n      toggleFilterAnimation,\n      toggleFilterFeature,\n      setFilterView,\n      syncTimeFilterWithLayerTimeline\n    } = visStateActions;\n\n    const filterPanelCallbacks = useMemo(() => {\n      return filtersByIndex.reduce(\n        (accu, {filter, idx}) => ({\n          ...accu,\n          [filter.id]: {\n            removeFilter: () => removeFilter(idx),\n            toggleFilterView: () =>\n              setFilterView(\n                idx,\n                isSideFilter(filter) ? FILTER_VIEW_TYPES.enlarged : FILTER_VIEW_TYPES.side\n              ),\n            toggleAnimation: () => toggleFilterAnimation(idx),\n            toggleFilterFeature: () => toggleFilterFeature(idx)\n          }\n        }),\n        {}\n      );\n    }, [filtersByIndex, removeFilter, setFilterView, toggleFilterAnimation, toggleFilterFeature]);\n\n    return (\n      <SidePanelSection>\n        {[...filtersByIndex].reverse().map(({filter, idx}) => (\n          <FilterPanel\n            key={`${filter.id}-${idx}`}\n            idx={idx}\n            filters={filters}\n            filter={filter}\n            datasets={datasets}\n            layers={layers}\n            isAnyFilterAnimating={isAnyFilterAnimating}\n            removeFilter={filterPanelCallbacks[filter.id].removeFilter}\n            enlargeFilter={filterPanelCallbacks[filter.id].toggleFilterView}\n            toggleAnimation={filterPanelCallbacks[filter.id].toggleAnimation}\n            toggleFilterFeature={filterPanelCallbacks[filter.id].toggleFilterFeature}\n            setFilter={setFilter}\n            setFilterPlot={setFilterPlot}\n            syncTimeFilterWithLayerTimeline={syncTimeFilterWithLayerTimeline}\n          />\n        ))}\n      </SidePanelSection>\n    );\n  };\n\n  const DatasetFilterSection = ({\n    filtersByIndex,\n    filters,\n    dataset,\n    datasets,\n    layers,\n    isAnyFilterAnimating,\n    visStateActions,\n    showDatasetTable,\n    updateTableColor,\n    removeDataset,\n    showDeleteDataset\n  }) => {\n    const datasetCatalog = useMemo(() => {\n      return {[dataset.id]: dataset};\n    }, [dataset]);\n\n    return (\n      <>\n        <SourceDataCatalog\n          datasets={datasetCatalog}\n          showDatasetTable={showDatasetTable}\n          updateTableColor={updateTableColor}\n          removeDataset={removeDataset}\n          showDeleteDataset={showDeleteDataset}\n          refreshDataset={visStateActions.refreshDataset}\n          updateDatasetProps={visStateActions.updateDatasetProps}\n        />\n        <FilterList\n          filtersByIndex={filtersByIndex}\n          filters={filters}\n          datasets={datasets}\n          layers={layers}\n          isAnyFilterAnimating={isAnyFilterAnimating}\n          visStateActions={visStateActions}\n        />\n      </>\n    );\n  };\n\n  const FilterManager: React.FC<FilterManagerProps> = ({\n    filters = [],\n    datasets,\n    layers,\n    showDatasetTable,\n    updateTableColor,\n    removeDataset,\n    showAddDataModal,\n    panelMetadata,\n    panelListView,\n    visStateActions,\n    uiStateActions\n  }) => {\n    const {addFilter} = visStateActions;\n    const {togglePanelListView} = uiStateActions;\n    const isAnyFilterAnimating = filters.some(f => f.isAnimating);\n    const onClickAddFilter = useCallback(dataset => addFilter(dataset), [addFilter]);\n    const isSortByDatasetMode = panelListView === PANEL_VIEW_TOGGLES.byDataset;\n    const filtersByIndex = useMemo(\n      () =>\n        filters.map((f, idx) => ({\n          filter: f,\n          idx\n        })),\n      [filters]\n    );\n    const filtersByDatasets = useMemo(\n      () =>\n        Object.keys(datasets).reduce(\n          (accu, dataId) => ({\n            ...accu,\n            // if synced filter, show it unfder its the first dataset\n            [dataId]: filtersByIndex.filter(\n              fidx => fidx.filter.dataId && fidx.filter.dataId[0] === dataId\n            )\n          }),\n          {}\n        ),\n      [datasets, filtersByIndex]\n    );\n    const _TogglePanelListView = useCallback(\n      listView => {\n        togglePanelListView({panelId: 'filter', listView});\n      },\n      [togglePanelListView]\n    );\n\n    const intl = useIntl();\n    const filterListProps = {\n      datasets,\n      filters,\n      layers,\n      isAnyFilterAnimating,\n      visStateActions\n    };\n\n    const sourceDataCatalogProps = {\n      showDatasetTable,\n      updateTableColor,\n      removeDataset,\n      showDeleteDataset: true,\n      refreshDataset: visStateActions.refreshDataset,\n      updateDatasetProps: visStateActions.updateDatasetProps\n    };\n\n    return (\n      <div className=\"filter-manager\">\n        <SidePanelSection>\n          <PanelViewListToggle togglePanelListView={_TogglePanelListView} mode={panelListView} />\n        </SidePanelSection>\n        <DatasetSection\n          datasets={datasets}\n          {...sourceDataCatalogProps}\n          showDatasetList={!isSortByDatasetMode}\n          showAddDataModal={showAddDataModal}\n        />\n        <SidePanelDivider />\n        <SidePanelSection>\n          <PanelTitle\n            className=\"filter-manager-title\"\n            title={intl.formatMessage({id: panelMetadata.label})}\n          >\n            <AddFilterButton datasets={datasets} onAdd={onClickAddFilter} />\n          </PanelTitle>\n        </SidePanelSection>\n        <SidePanelSection>\n          {isSortByDatasetMode ? (\n            Object.keys(filtersByDatasets).map(dataId => (\n              <DatasetFilterSection\n                key={dataId}\n                filtersByIndex={filtersByDatasets[dataId]}\n                dataset={datasets[dataId]}\n                {...filterListProps}\n                {...sourceDataCatalogProps}\n              />\n            ))\n          ) : (\n            <FilterList filtersByIndex={filtersByIndex} {...filterListProps} />\n          )}\n        </SidePanelSection>\n      </div>\n    );\n  };\n\n  return FilterManager;\n}\n\nexport default FilterManagerFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/side-panel/filter-panel/add-filter-button.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import AddByDatasetButton from '../add-by-dataset-button';
+function AddFilterButtonFactory() {
+  var AddFilterButton = function AddFilterButton(_ref) {
+    var datasets = _ref.datasets,
+      onAdd = _ref.onAdd;
+    return /*#__PURE__*/React.createElement(AddByDatasetButton, {
+      datasets: datasets,
+      className: "add-filter-button",
+      onAdd: onAdd,
+      buttonIntlId: "filterManager.addFilter"
+    });
+  };
+  return AddFilterButton;
+}
+export default AddFilterButtonFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkFkZEJ5RGF0YXNldEJ1dHRvbiIsIkFkZEZpbHRlckJ1dHRvbkZhY3RvcnkiLCJBZGRGaWx0ZXJCdXR0b24iLCJfcmVmIiwiZGF0YXNldHMiLCJvbkFkZCIsImNyZWF0ZUVsZW1lbnQiLCJjbGFzc05hbWUiLCJidXR0b25JbnRsSWQiXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2lkZS1wYW5lbC9maWx0ZXItcGFuZWwvYWRkLWZpbHRlci1idXR0b24udHN4Il0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQge0RhdGFzZXRzfSBmcm9tICdAa2VwbGVyLmdsL3RhYmxlJztcbmltcG9ydCBBZGRCeURhdGFzZXRCdXR0b24gZnJvbSAnLi4vYWRkLWJ5LWRhdGFzZXQtYnV0dG9uJztcblxuZXhwb3J0IHR5cGUgQWRkRmlsdGVyQnV0dG9uUHJvcHMgPSB7XG4gIGRhdGFzZXRzOiBEYXRhc2V0cztcbiAgb25BZGQ6IChkYXRhSWQ6IHN0cmluZykgPT4gdm9pZDtcbn07XG5cbmZ1bmN0aW9uIEFkZEZpbHRlckJ1dHRvbkZhY3RvcnkoKSB7XG4gIGNvbnN0IEFkZEZpbHRlckJ1dHRvbjogUmVhY3QuRkM8QWRkRmlsdGVyQnV0dG9uUHJvcHM+ID0gKHtkYXRhc2V0cywgb25BZGR9KSA9PiB7XG4gICAgcmV0dXJuIChcbiAgICAgIDxBZGRCeURhdGFzZXRCdXR0b25cbiAgICAgICAgZGF0YXNldHM9e2RhdGFzZXRzfVxuICAgICAgICBjbGFzc05hbWU9XCJhZGQtZmlsdGVyLWJ1dHRvblwiXG4gICAgICAgIG9uQWRkPXtvbkFkZH1cbiAgICAgICAgYnV0dG9uSW50bElkPVwiZmlsdGVyTWFuYWdlci5hZGRGaWx0ZXJcIlxuICAgICAgLz5cbiAgICApO1xuICB9O1xuXG4gIHJldHVybiBBZGRGaWx0ZXJCdXR0b247XG59XG5cbmV4cG9ydCBkZWZhdWx0IEFkZEZpbHRlckJ1dHRvbkZhY3Rvcnk7XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7O0FBRUEsT0FBT0EsS0FBSyxNQUFNLE9BQU87QUFFekIsT0FBT0Msa0JBQWtCLE1BQU0sMEJBQTBCO0FBT3pELFNBQVNDLHNCQUFzQkEsQ0FBQSxFQUFHO0VBQ2hDLElBQU1DLGVBQStDLEdBQUcsU0FBbERBLGVBQStDQSxDQUFBQyxJQUFBLEVBQTBCO0lBQUEsSUFBckJDLFFBQVEsR0FBQUQsSUFBQSxDQUFSQyxRQUFRO01BQUVDLEtBQUssR0FBQUYsSUFBQSxDQUFMRSxLQUFLO0lBQ3ZFLG9CQUNFTixLQUFBLENBQUFPLGFBQUEsQ0FBQ04sa0JBQWtCO01BQ2pCSSxRQUFRLEVBQUVBLFFBQVM7TUFDbkJHLFNBQVMsRUFBQyxtQkFBbUI7TUFDN0JGLEtBQUssRUFBRUEsS0FBTTtNQUNiRyxZQUFZLEVBQUM7SUFBeUIsQ0FDdkMsQ0FBQztFQUVOLENBQUM7RUFFRCxPQUFPTixlQUFlO0FBQ3hCO0FBRUEsZUFBZUQsc0JBQXNCIiwiaWdub3JlTGlzdCI6W119

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

@@ -0,0 +1,60 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import classnames from 'classnames';
+import PanelHeaderActionFactory from '../../side-panel/panel-header-action';
+import { Trash } from '../../common/icons';
+import { createLinearGradient } from '@kepler.gl/utils';
+import { StyledPanelHeader } from '../../common/styled-components';
+export var StyledFilterHeader = styled(StyledPanelHeader)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  cursor: pointer;\n  padding: 10px 12px;\n\n  .field-selector {\n    width: 100%;\n    flex: 2;\n  }\n\n  border-left: 3px solid;\n  ", ";\n"])), function (props) {
+  return props.$labelRCGColorValues && props.$labelRCGColorValues.length > 0 ? "border-image: ".concat(createLinearGradient('bottom', props.$labelRCGColorValues), " 3;") : 'border-color: transparent;';
+});
+var StyledChildrenContainer = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex: 1;\n  overflow: hidden;\n"])));
+FilterPanelHeaderFactory.deps = [PanelHeaderActionFactory];
+function FilterPanelHeaderFactory(PanelHeaderAction) {
+  var defaultActionIcons = {
+    "delete": Trash
+  };
+  var FilterPanelHeader = function FilterPanelHeader(_ref) {
+    var children = _ref.children,
+      _ref$className = _ref.className,
+      className = _ref$className === void 0 ? '' : _ref$className,
+      datasets = _ref.datasets,
+      filter = _ref.filter,
+      removeFilter = _ref.removeFilter,
+      actionItems = _ref.actionItems,
+      _ref$actionIcons = _ref.actionIcons,
+      actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    var items = useMemo(function () {
+      return actionItems !== null && actionItems !== void 0 ? actionItems : [{
+        key: 'delete',
+        tooltip: 'tooltip.delete',
+        onClick: removeFilter,
+        icon: actionIcons["delete"]
+      }];
+    }, [removeFilter, actionIcons, actionItems]);
+    return /*#__PURE__*/React.createElement(StyledFilterHeader, {
+      className: classnames('filter-panel__header', className),
+      $labelRCGColorValues: datasets.map(function (d) {
+        return d.color;
+      })
+    }, /*#__PURE__*/React.createElement(StyledChildrenContainer, null, children), items.map(function (item) {
+      return /*#__PURE__*/React.createElement(PanelHeaderAction, {
+        key: item.key,
+        id: filter.id,
+        tooltip: item.tooltip,
+        tooltipType: "error",
+        onClick: item.onClick,
+        hoverColor: 'errorColor',
+        IconComponent: item.icon
+      });
+    }));
+  };
+  return FilterPanelHeader;
+}
+export default FilterPanelHeaderFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,85 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component } from 'react';
+import { createSelector } from 'reselect';
+import styled from 'styled-components';
+import get from 'es-toolkit/compat/get';
+import { ALL_FIELD_TYPES, FILTER_TYPES } from '@kepler.gl/constants';
+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';
+var StyledFilterPanel = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  margin-bottom: 12px;\n  border-radius: 1px;\n"])));
+FilterPanelFactory.deps = [NewFilterPanelFactory, TimeRangeFilterPanelFactory, SingleSelectFilterPanelFactory, MultiSelectFilterPanelFactory, RangeFilterPanelFactory, PolygonFilterPanelFactory];
+function FilterPanelFactory(NewFilterPanel, TimeRangeFilterPanel, SingleSelectFilterPanel, MultiSelectFilterPanel, RangeFilterPanel, PolygonFilterPanel) {
+  var FilterPanelComponents = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
+    "default": NewFilterPanel
+  }, FILTER_TYPES.timeRange, TimeRangeFilterPanel), FILTER_TYPES.select, SingleSelectFilterPanel), FILTER_TYPES.multiSelect, MultiSelectFilterPanel), FILTER_TYPES.range, RangeFilterPanel), FILTER_TYPES.polygon, PolygonFilterPanel);
+  return /*#__PURE__*/function (_Component) {
+    function FilterPanel() {
+      var _this;
+      _classCallCheck(this, FilterPanel);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, FilterPanel, [].concat(args));
+      /* selectors */
+      _defineProperty(_this, "fieldsSelector", function (props) {
+        var datasetId = props.filter.dataId[0];
+        if (!datasetId) {
+          return [];
+        }
+        return get(props, ['datasets', datasetId, 'fields'], []);
+      });
+      _defineProperty(_this, "filterSelector", function (props) {
+        return props.filters;
+      });
+      _defineProperty(_this, "nameSelector", function (props) {
+        return props.filter.name;
+      });
+      _defineProperty(_this, "dataIdSelector", function (props) {
+        return props.filter.dataId[0];
+      });
+      // only show current field and field that's not already been used as a filter
+      _defineProperty(_this, "availableFieldsSelector", createSelector(_this.fieldsSelector, _this.filterSelector, _this.nameSelector, _this.dataIdSelector, function (fields, filters, name, dataId) {
+        return fields.filter(function (f) {
+          return f.type && f.type !== ALL_FIELD_TYPES.geojson && (name.includes(f.name) || !filters.find(function (d) {
+            return d.name.includes(f.name) && d.dataId.includes(dataId);
+          }));
+        });
+      }));
+      return _this;
+    }
+    _inherits(FilterPanel, _Component);
+    return _createClass(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.createElement(StyledFilterPanel, {
+          className: "filter-panel"
+        }, /*#__PURE__*/React.createElement(FilterFilterComponent, _extends({
+          allAvailableFields: allAvailableFields
+        }, this.props)));
+      }
+    }]);
+  }(Component);
+}
+export default FilterPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createSelector","styled","get","ALL_FIELD_TYPES","FILTER_TYPES","NewFilterPanelFactory","TimeRangeFilterPanelFactory","SingleSelectFilterPanelFactory","MultiSelectFilterPanelFactory","RangeFilterPanelFactory","PolygonFilterPanelFactory","StyledFilterPanel","div","_templateObject","_taggedTemplateLiteral","FilterPanelFactory","deps","NewFilterPanel","TimeRangeFilterPanel","SingleSelectFilterPanel","MultiSelectFilterPanel","RangeFilterPanel","PolygonFilterPanel","FilterPanelComponents","_defineProperty","timeRange","select","multiSelect","range","polygon","_Component","FilterPanel","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","props","datasetId","filter","dataId","filters","name","fieldsSelector","filterSelector","nameSelector","dataIdSelector","fields","f","type","geojson","includes","find","d","_inherits","_createClass","key","value","render","FilterFilterComponent","allAvailableFields","availableFieldsSelector","createElement","className","_extends"],"sources":["../../../../src/side-panel/filter-panel/filter-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component} from 'react';\nimport {createSelector} from 'reselect';\nimport styled from 'styled-components';\nimport get from 'es-toolkit/compat/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  toggleAnimation: () => void;\n  enlargeFilter: () => 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"],"mappings":";;;;;;;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,SAAS,QAAO,OAAO;AACtC,SAAQC,cAAc,QAAO,UAAU;AACvC,OAAOC,MAAM,MAAM,mBAAmB;AACtC,OAAOC,GAAG,MAAM,uBAAuB;AACvC,SAAQC,eAAe,EAAEC,YAAY,QAAO,sBAAsB;AAElE,OAAOC,qBAAqB,MAAM,8CAA8C;AAChF,OAAOC,2BAA2B,MAAM,qDAAqD;AAC7F,OAAOC,8BAA8B,MAAM,wDAAwD;AACnG,OAAOC,6BAA6B,MAAM,uDAAuD;AACjG,OAAOC,uBAAuB,MAAM,gDAAgD;AACpF,OAAOC,yBAAyB,MAAM,kDAAkD;AAKxF,IAAMC,iBAAiB,GAAGV,MAAM,CAACW,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,yDAGnC;AAWDC,kBAAkB,CAACC,IAAI,GAAG,CACxBX,qBAAqB,EACrBC,2BAA2B,EAC3BC,8BAA8B,EAC9BC,6BAA6B,EAC7BC,uBAAuB,EACvBC,yBAAyB,CAC1B;AAED,SAASK,kBAAkBA,CACzBE,cAAwD,EACxDC,oBAAoE,EACpEC,uBAA0E,EAC1EC,sBAAwE,EACxEC,gBAA4D,EAC5DC,kBAAgE,EACrB;EAC3C,IAAMC,qBAAqB,GAAAC,eAAA,CAAAA,eAAA,CAAAA,eAAA,CAAAA,eAAA,CAAAA,eAAA;IACzB,WAASP;EAAc,GACtBb,YAAY,CAACqB,SAAS,EAAGP,oBAAoB,GAC7Cd,YAAY,CAACsB,MAAM,EAAGP,uBAAuB,GAC7Cf,YAAY,CAACuB,WAAW,EAAGP,sBAAsB,GACjDhB,YAAY,CAACwB,KAAK,EAAGP,gBAAgB,GACrCjB,YAAY,CAACyB,OAAO,EAAGP,kBAAkB,CAC3C;EAED,8BAAAQ,UAAA;IAAA,SAAAC,YAAA;MAAA,IAAAC,KAAA;MAAAC,eAAA,OAAAF,WAAA;MAAA,SAAAG,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAC,IAAA,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;QAAAF,IAAA,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;MAAA;MAAAP,KAAA,GAAAQ,UAAA,OAAAT,WAAA,KAAAU,MAAA,CAAAJ,IAAA;MACE;MAAAb,eAAA,CAAAQ,KAAA,oBACiB,UAACU,KAA2B,EAAK;QAChD,IAAMC,SAAS,GAAGD,KAAK,CAACE,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC;QACxC,IAAI,CAACF,SAAS,EAAE;UACd,OAAO,EAAE;QACX;QACA,OAAOzC,GAAG,CAACwC,KAAK,EAAE,CAAC,UAAU,EAAEC,SAAS,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC;MAC1D,CAAC;MAAAnB,eAAA,CAAAQ,KAAA,oBAEgB,UAACU,KAA2B;QAAA,OAAKA,KAAK,CAACI,OAAO;MAAA;MAAAtB,eAAA,CAAAQ,KAAA,kBAChD,UAACU,KAA2B;QAAA,OAAKA,KAAK,CAACE,MAAM,CAACG,IAAI;MAAA;MAAAvB,eAAA,CAAAQ,KAAA,oBAChD,UAACU,KAA2B;QAAA,OAAKA,KAAK,CAACE,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC;MAAA;MAExE;MAAArB,eAAA,CAAAQ,KAAA,6BAC0BhC,cAAc,CACtCgC,KAAA,CAAKgB,cAAc,EACnBhB,KAAA,CAAKiB,cAAc,EACnBjB,KAAA,CAAKkB,YAAY,EACjBlB,KAAA,CAAKmB,cAAc,EACnB,UAACC,MAAM,EAAEN,OAAO,EAAEC,IAAI,EAAEF,MAAM;QAAA,OAC5BO,MAAM,CAACR,MAAM,CACX,UAACS,CAAQ;UAAA,OACPA,CAAC,CAACC,IAAI,IACND,CAAC,CAACC,IAAI,KAAKnD,eAAe,CAACoD,OAAO,KACjCR,IAAI,CAACS,QAAQ,CAACH,CAAC,CAACN,IAAI,CAAC,IACpB,CAACD,OAAO,CAACW,IAAI,CAAC,UAAAC,CAAC;YAAA,OAAIA,CAAC,CAACX,IAAI,CAACS,QAAQ,CAACH,CAAC,CAACN,IAAI,CAAC,IAAIW,CAAC,CAACb,MAAM,CAACW,QAAQ,CAACX,MAAM,CAAC;UAAA,EAAC,CAAC;QAAA,CAC/E,CAAC;MAAA,CACL,CAAC;MAAA,OAAAb,KAAA;IAAA;IAAA2B,SAAA,CAAA5B,WAAA,EAAAD,UAAA;IAAA,OAAA8B,YAAA,CAAA7B,WAAA;MAAA8B,GAAA;MAAAC,KAAA,EAED,SAAAC,MAAMA,CAAA,EAAG;QACP,IAAOnB,MAAM,GAAI,IAAI,CAACF,KAAK,CAApBE,MAAM;QAEb,IAAOU,IAAI,GAAIV,MAAM,CAAdU,IAAI;QACX,IAAMU,qBAAqB,GACxBV,IAAI,IAAI/B,qBAAqB,CAAC+B,IAAI,CAAC,IAAK/B,qBAAqB,WAAQ;QACxE,IAAM0C,kBAAkB,GAAG,IAAI,CAACC,uBAAuB,CAAC,IAAI,CAACxB,KAAK,CAAC;QAEnE,oBACE5C,KAAA,CAAAqE,aAAA,CAACxD,iBAAiB;UAACyD,SAAS,EAAC;QAAc,gBACzCtE,KAAA,CAAAqE,aAAA,CAACH,qBAAqB,EAAAK,QAAA;UAACJ,kBAAkB,EAAEA;QAAmB,GAAK,IAAI,CAACvB,KAAK,CAAG,CAC/D,CAAC;MAExB;IAAC;EAAA,EA3C8B3C,SAAS;AA6C5C;AAEA,eAAegB,kBAAkB","ignoreList":[]}

package/dist/esm/side-panel/interaction-manager.js

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import { useIntl } from 'react-intl';
+import InteractionPanelFactory from './interaction-panel/interaction-panel';
+import PanelTitleFactory from './panel-title';
+InteractionManagerFactory.deps = [InteractionPanelFactory, PanelTitleFactory];
+function InteractionManagerFactory(InteractionPanel, PanelTitle) {
+  var InteractionManager = function InteractionManager(_ref) {
+    var interactionConfig = _ref.interactionConfig,
+      datasets = _ref.datasets,
+      visStateActions = _ref.visStateActions,
+      panelMetadata = _ref.panelMetadata;
+    var onConfigChange = visStateActions.interactionConfigChange,
+      setColumnDisplayFormat = visStateActions.setColumnDisplayFormat;
+    var intl = useIntl();
+    return /*#__PURE__*/React.createElement("div", {
+      className: "interaction-manager"
+    }, /*#__PURE__*/React.createElement(PanelTitle, {
+      className: "interaction-manager-title",
+      title: intl.formatMessage({
+        id: panelMetadata.label
+      })
+    }), Object.keys(interactionConfig).map(function (key) {
+      return /*#__PURE__*/React.createElement(InteractionPanel, {
+        datasets: datasets,
+        config: interactionConfig[key],
+        key: key,
+        onConfigChange: onConfigChange,
+        setColumnDisplayFormat: setColumnDisplayFormat
+      });
+    }));
+  };
+  return InteractionManager;
+}
+export default InteractionManagerFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/side-panel/interaction-panel/brush-config.js

@@ -0,0 +1,36 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import RangeSliderFactory from '../../common/range-slider';
+import { PanelLabel, SidePanelSection } from '../../common/styled-components';
+import { BRUSH_CONFIG } from '@kepler.gl/reducers';
+import { FormattedMessage } from '@kepler.gl/localization';
+BrushConfigFactory.deps = [RangeSliderFactory];
+function BrushConfigFactory(RangeSlider) {
+  var BrushConfig = function BrushConfig(_ref) {
+    var config = _ref.config,
+      _onChange = _ref.onChange;
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'misc.brushRadius'
+    })), /*#__PURE__*/React.createElement(RangeSlider, {
+      range: BRUSH_CONFIG.range,
+      value0: 0,
+      value1: config.size || 10 / 2,
+      step: 0.1,
+      isRanged: false,
+      onChange: function onChange(value) {
+        return _onChange(_objectSpread(_objectSpread({}, config), {}, {
+          size: value[1]
+        }));
+      },
+      inputTheme: "secondary"
+    }));
+  };
+  return BrushConfig;
+}
+export default BrushConfigFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/side-panel/interaction-panel/geocoder-config.js

@@ -0,0 +1,40 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import Switch from '../../common/switch';
+import { SidePanelSection } from '../../common/styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+var LimitSwitchWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  color: ", ";\n  display: flex;\n  font-size: ", ";\n  justify-content: space-between;\n  line-height: 11px;\n  margin-bottom: 8px;\n"])), function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.theme.inputFontSize;
+});
+function GeocoderConfigFactory() {
+  var GeocoderConfig = function GeocoderConfig(_ref) {
+    var _config$limitSearch;
+    var config = _ref.config,
+      _onChange = _ref.onChange;
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(LimitSwitchWrapper, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "geocoder.limitSearch"
+    }), /*#__PURE__*/React.createElement(Switch, {
+      checked: (_config$limitSearch = config === null || config === void 0 ? void 0 : config.limitSearch) !== null && _config$limitSearch !== void 0 ? _config$limitSearch : false,
+      id: "limit-search-toggle",
+      onChange: function onChange() {
+        _onChange(_objectSpread(_objectSpread({}, config), {}, {
+          limitSearch: !(config !== null && config !== void 0 && config.limitSearch)
+        }));
+      },
+      secondary: true
+    })));
+  };
+  return GeocoderConfig;
+}
+export default GeocoderConfigFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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