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

package/dist/esm/filters/filter-panels/filter-panel-with-field-select.js

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import { StyledFilterContent } from '../../common/styled-components';
+import FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';
+import PanelHeaderActionFactory from '../../side-panel/panel-header-action';
+import SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';
+import FieldSelectorFactory from '../../common/field-selector';
+import { getSupportedFilterFields } from './new-filter-panel';
+FieldPanelWithFieldSelectFactory.deps = [FilterPanelHeaderFactory, SourceDataSelectorFactory, FieldSelectorFactory, PanelHeaderActionFactory];
+function FieldPanelWithFieldSelectFactory(FilterPanelHeader, SourceDataSelector, FieldSelector, PanelHeaderAction) {
+  var FilterPanelWithFieldSelect = /*#__PURE__*/React.memo(function (_ref) {
+    var children = _ref.children,
+      allAvailableFields = _ref.allAvailableFields,
+      datasets = _ref.datasets,
+      filter = _ref.filter,
+      idx = _ref.idx,
+      removeFilter = _ref.removeFilter,
+      setFilter = _ref.setFilter,
+      _ref$panelActions = _ref.panelActions,
+      panelActions = _ref$panelActions === void 0 ? [] : _ref$panelActions;
+    var onFieldSelector = useCallback(function (field) {
+      return setFilter(idx, 'name', field.name);
+    }, [idx, setFilter]);
+    var onSourceDataSelector = useCallback(function (value) {
+      return setFilter(idx, 'dataId', value, 0);
+    }, [idx, setFilter]);
+    var fieldValue = useMemo(function () {
+      return Array.isArray(filter.name) ? filter.name[0] : filter.name;
+    }, [filter.name]);
+    var dataset = datasets[filter.dataId[0]];
+    var supportedFields = useMemo(function () {
+      return getSupportedFilterFields(dataset.supportedFilterTypes, allAvailableFields);
+    }, [dataset.supportedFilterTypes, allAvailableFields]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterPanelHeader, {
+      datasets: [dataset],
+      filter: filter,
+      removeFilter: removeFilter
+    }, /*#__PURE__*/React.createElement(FieldSelector, {
+      inputTheme: "secondary",
+      fields: supportedFields,
+      value: fieldValue,
+      erasable: false,
+      onSelect: onFieldSelector
+    }), panelActions.map(function (panelAction) {
+      return /*#__PURE__*/React.createElement(PanelHeaderAction, {
+        id: panelAction.id,
+        key: panelAction.id,
+        onClick: panelAction.onClick,
+        tooltip: panelAction.tooltip,
+        IconComponent: panelAction.iconComponent,
+        active: panelAction.active
+      });
+    })), /*#__PURE__*/React.createElement(StyledFilterContent, {
+      className: "filter-panel__content"
+    }, Object.keys(datasets).length > 1 && /*#__PURE__*/React.createElement(SourceDataSelector, {
+      inputTheme: "secondary",
+      datasets: datasets,
+      dataId: filter.dataId,
+      onSelect: onSourceDataSelector
+    }), children));
+  });
+  FilterPanelWithFieldSelect.displayName = 'FilterPanelWithFieldSelect';
+  return FilterPanelWithFieldSelect;
+}
+export default FieldPanelWithFieldSelectFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","StyledFilterContent","FilterPanelHeaderFactory","PanelHeaderActionFactory","SourceDataSelectorFactory","FieldSelectorFactory","getSupportedFilterFields","FieldPanelWithFieldSelectFactory","deps","FilterPanelHeader","SourceDataSelector","FieldSelector","PanelHeaderAction","FilterPanelWithFieldSelect","memo","_ref","children","allAvailableFields","datasets","filter","idx","removeFilter","setFilter","_ref$panelActions","panelActions","onFieldSelector","field","name","onSourceDataSelector","value","fieldValue","Array","isArray","dataset","dataId","supportedFields","supportedFilterTypes","createElement","Fragment","inputTheme","fields","erasable","onSelect","map","panelAction","id","key","onClick","tooltip","IconComponent","iconComponent","active","className","Object","keys","length","displayName"],"sources":["../../../../src/filters/filter-panels/filter-panel-with-field-select.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo} from 'react';\nimport {StyledFilterContent} from '../../common/styled-components';\nimport FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';\nimport PanelHeaderActionFactory from '../../side-panel/panel-header-action';\nimport SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';\nimport FieldSelectorFactory from '../../common/field-selector';\nimport {getSupportedFilterFields} from './new-filter-panel';\nimport {FilterPanelWithFieldSelectComponent} from './types';\nimport {KeplerTable} from '@kepler.gl/table';\n\nFieldPanelWithFieldSelectFactory.deps = [\n  FilterPanelHeaderFactory,\n  SourceDataSelectorFactory,\n  FieldSelectorFactory,\n  PanelHeaderActionFactory\n];\n\nfunction FieldPanelWithFieldSelectFactory(\n  FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>,\n  SourceDataSelector: ReturnType<typeof SourceDataSelectorFactory>,\n  FieldSelector: ReturnType<typeof FieldSelectorFactory>,\n  PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>\n) {\n  const FilterPanelWithFieldSelect: FilterPanelWithFieldSelectComponent = React.memo(\n    ({\n      children,\n      allAvailableFields,\n      datasets,\n      filter,\n      idx,\n      removeFilter,\n      setFilter,\n      panelActions = []\n    }) => {\n      const onFieldSelector = useCallback(\n        field => setFilter(idx, 'name', field.name),\n        [idx, setFilter]\n      );\n\n      const onSourceDataSelector = useCallback(\n        value => setFilter(idx, 'dataId', value, 0),\n        [idx, setFilter]\n      );\n\n      const fieldValue = useMemo(\n        () => (Array.isArray(filter.name) ? filter.name[0] : filter.name),\n        [filter.name]\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      return (\n        <>\n          <FilterPanelHeader datasets={[dataset]} filter={filter} removeFilter={removeFilter}>\n            <FieldSelector\n              inputTheme=\"secondary\"\n              fields={supportedFields}\n              value={fieldValue}\n              erasable={false}\n              onSelect={onFieldSelector}\n            />\n            {panelActions.map(panelAction => (\n              <PanelHeaderAction\n                id={panelAction.id}\n                key={panelAction.id}\n                onClick={panelAction.onClick}\n                tooltip={panelAction.tooltip}\n                IconComponent={panelAction.iconComponent}\n                active={panelAction.active}\n              />\n            ))}\n          </FilterPanelHeader>\n          <StyledFilterContent className=\"filter-panel__content\">\n            {Object.keys(datasets).length > 1 && (\n              <SourceDataSelector\n                inputTheme=\"secondary\"\n                datasets={datasets}\n                dataId={filter.dataId}\n                onSelect={onSourceDataSelector}\n              />\n            )}\n            {children}\n          </StyledFilterContent>\n        </>\n      );\n    }\n  );\n\n  FilterPanelWithFieldSelect.displayName = 'FilterPanelWithFieldSelect';\n\n  return FilterPanelWithFieldSelect;\n}\n\nexport default FieldPanelWithFieldSelectFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/filters/filter-panels/filter-synced-dataset-panel.js

@@ -0,0 +1,253 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject0;
+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 styled, { withTheme } from 'styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { ALL_FIELD_TYPES } from '@kepler.gl/constants';
+import { getAnimatableVisibleLayers } from '@kepler.gl/utils';
+import { Button } from '../../common/styled-components';
+import { Add, Trash } from '../../common/icons';
+import TippyTooltip from '../../common/tippy-tooltip';
+import FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';
+import SourceSelectorFactory from '../../side-panel/common/source-selector';
+import SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';
+import LayerTypeListItemFactory from '../../side-panel/layer-panel/layer-type-list-item';
+var TrashIcon = styled(Trash)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  cursor: pointer;\n  color: ", ";\n  margin-left: 8px;\n"])), function (props) {
+  return props.theme.fontWhiteColor;
+});
+var SyncedDatasetsArea = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  .side-panel-section {\n    margin-bottom: 0;\n  }\n"])));
+var StyledContentTitle = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  color: ", ";\n  margin-bottom: 8px;\n"])), function (props) {
+  return props.theme.subtextColor;
+});
+var StyledSeparator = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  border-left: 1px dashed ", ";\n  height: 16px;\n  margin: 4px 0 4px 8px;\n"])), function (props) {
+  return props.theme.subtextColor;
+});
+var StyledButton = styled(Button)(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  margin-top: 2px;\n  padding: 2px;\n"])));
+function getDatasetsWithTimeField(datasets) {
+  var rv = {};
+  for (var _i = 0, _Object$keys = Object.keys(datasets); _i < _Object$keys.length; _i++) {
+    var id = _Object$keys[_i];
+    // TODO: change to
+    if (datasets[id].fields.some(function (f) {
+      return f.type === ALL_FIELD_TYPES.timestamp;
+    })) {
+      rv[id] = datasets[id];
+    }
+  }
+  return rv;
+}
+function getTimeFields(dataset) {
+  return dataset.fields.filter(function (f) {
+    return f.type === ALL_FIELD_TYPES.timestamp;
+  });
+}
+function DatasetItemFactory(SourceSelector, FilterPanelHeader) {
+  var StyledFilterPanelHeader = styled(FilterPanelHeader)(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n    display: flex;\n    border: none;\n    height: unset;\n    padding: 2px 0;\n    background: none;\n    align-items: baseline;\n  "])));
+  var StyledSourceSelector = styled(SourceSelector)(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n    flex: 1;\n    -webkit-border-radius: 8px;\n    -moz-border-radius: 8px;\n    border-radius: 8px;\n    background-color: transparent;\n  "])));
+
+  // Check if this component already exists
+  var DatasetItem = function DatasetItem(_ref) {
+    var dataId = _ref.dataId,
+      datasets = _ref.datasets,
+      supportedFields = _ref.supportedFields,
+      idx = _ref.idx,
+      filter = _ref.filter,
+      index = _ref.index,
+      onRemoveSyncedFilter = _ref.onRemoveSyncedFilter,
+      filterDatasetsNum = _ref.filterDatasetsNum,
+      datasetsWithTimeNum = _ref.datasetsWithTimeNum,
+      onSelectSyncedDataset = _ref.onSelectSyncedDataset,
+      _onFieldSelector = _ref.onFieldSelector;
+    return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(StyledSeparator, null), /*#__PURE__*/React.createElement(StyledFilterPanelHeader, {
+      datasets: [datasets[dataId]],
+      allAvailableFields: supportedFields,
+      idx: idx,
+      filter: filter,
+      removeFilter: function removeFilter() {
+        return onRemoveSyncedFilter(index);
+      }
+    }, /*#__PURE__*/React.createElement(StyledSourceSelector, {
+      datasets: datasets,
+      disabled: filterDatasetsNum >= datasetsWithTimeNum,
+      dataId: dataId,
+      onSelectDataset: function onSelectDataset(datasetId) {
+        return onSelectSyncedDataset(datasetId, index);
+      },
+      fields: getTimeFields(datasets[dataId]),
+      fieldValue: filter.name[index],
+      onFieldSelector: function onFieldSelector(field) {
+        return _onFieldSelector(field, index);
+      }
+    })));
+  };
+  return DatasetItem;
+}
+DatasetItemFactory.deps = [SourceSelectorFactory, FilterPanelHeaderFactory];
+var StyledLayerTimeline = styled.div(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n"])));
+var StyledLayerList = styled.div(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n  flex: 1;\n"])));
+function LayerTimelineFactory(LayerTypeListItem) {
+  var StyledLayerTypeListItem = styled(LayerTypeListItem)(_templateObject0 || (_templateObject0 = _taggedTemplateLiteral(["\n    background-color: ", ";\n    padding: 4px;\n  "])), function (props) {
+    return props.theme.dropdownListHighlightBg;
+  });
+  var LayerTimeline = function LayerTimeline(_ref2) {
+    var layers = _ref2.layers,
+      theme = _ref2.theme,
+      onDelete = _ref2.onDelete;
+    return /*#__PURE__*/React.createElement(StyledLayerTimeline, null, /*#__PURE__*/React.createElement(StyledLayerList, null, layers.map(function (layer) {
+      return /*#__PURE__*/React.createElement(StyledLayerTypeListItem, {
+        key: layer.id,
+        value: {
+          icon: layer.layerIcon,
+          label: layer.name
+        },
+        theme: _objectSpread(_objectSpread({}, theme), {}, {
+          layerTypeIconSizeSM: 24
+        })
+      });
+    })), /*#__PURE__*/React.createElement(TrashIcon, {
+      height: "12px",
+      width: "12px",
+      onClick: onDelete
+    }));
+  };
+  return withTheme(LayerTimeline);
+}
+LayerTimelineFactory.deps = [LayerTypeListItemFactory];
+function SyncedDatasetButtonFactory() {
+  var SyncedDatasetButton = function SyncedDatasetButton(_ref3) {
+    var onAddSyncedFilter = _ref3.onAddSyncedFilter;
+    return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(StyledSeparator, null), /*#__PURE__*/React.createElement(TippyTooltip, {
+      delay: [500, 0],
+      placement: "top",
+      render: function render() {
+        return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'tooltip.timeFilterSync'
+        }));
+      }
+    }, /*#__PURE__*/React.createElement(StyledButton, {
+      className: "add-sync-dataset",
+      secondary: true,
+      onClick: onAddSyncedFilter
+    }, /*#__PURE__*/React.createElement(Add, {
+      height: "12px"
+    }), /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'filterManager.timeFilterSync'
+    }))));
+  };
+  return SyncedDatasetButton;
+}
+function SyncLayerTimelineButtonFactory() {
+  var SyncLayerTimelineButton = function SyncLayerTimelineButton(_ref4) {
+    var onSyncLayerTimeline = _ref4.onSyncLayerTimeline;
+    return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(StyledSeparator, null), /*#__PURE__*/React.createElement(TippyTooltip, {
+      delay: [500, 0],
+      placement: "top",
+      render: function render() {
+        return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'tooltip.timeLayerSync'
+        }));
+      }
+    }, /*#__PURE__*/React.createElement(StyledButton, {
+      className: "add-sync-dataset",
+      secondary: true,
+      onClick: onSyncLayerTimeline
+    }, /*#__PURE__*/React.createElement(Add, {
+      height: "12px"
+    }), /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'filterManager.timeLayerSync'
+    }))));
+  };
+  return SyncLayerTimelineButton;
+}
+function FilterSyncedDatasetPanelFactory(DatasetItem, LayerTimeline, SourceDataSelector, SyncedDatasetButton, SyncLayerTimelineButton) {
+  var FilterSyncedDatasetPanel = function FilterSyncedDatasetPanel(_ref5) {
+    var datasets = _ref5.datasets,
+      layers = _ref5.layers,
+      filter = _ref5.filter,
+      setFilter = _ref5.setFilter,
+      idx = _ref5.idx,
+      supportedFields = _ref5.supportedFields,
+      onFieldSelector = _ref5.onFieldSelector,
+      onSourceDataSelector = _ref5.onSourceDataSelector,
+      syncTimeFilterWithLayerTimeline = _ref5.syncTimeFilterWithLayerTimeline;
+    var datasetsWithTime = useMemo(function () {
+      return getDatasetsWithTimeField(datasets);
+    }, [datasets]);
+    var filterDatasetsNum = useMemo(function () {
+      return filter.dataId.length;
+    }, [filter.dataId]);
+    var datasetsWithTimeNum = useMemo(function () {
+      return Object.keys(datasetsWithTime).length;
+    }, [datasetsWithTime]);
+    var onRemoveSyncedFilter = useCallback(function (valueIndex) {
+      setFilter(idx, 'dataId', null, valueIndex);
+    }, [idx, setFilter]);
+    var onSelectSyncedDataset = useCallback(function (datasetId, valueIndex) {
+      setFilter(idx, 'dataId', datasetId, valueIndex);
+    }, [setFilter, idx]);
+    var onAddSyncedFilter = useCallback(function () {
+      var _getTimeFields;
+      var nextId = Object.keys(datasetsWithTime).find(function (id) {
+        return !filter.dataId.includes(id);
+      });
+      if (!nextId) return;
+      var timeFieldNames = (_getTimeFields = getTimeFields(datasets[nextId])) === null || _getTimeFields === void 0 ? void 0 : _getTimeFields.map(function (f) {
+        return f.name;
+      });
+      if (!timeFieldNames || timeFieldNames.length < 1) return;
+      var nextName = timeFieldNames.includes(filter.name[0]) ? filter.name[0] : timeFieldNames[0];
+      setFilter(idx, ['dataId', 'name'], [nextId, nextName], filter.dataId.length);
+    }, [setFilter, idx, datasetsWithTime, datasets, filter.dataId, filter.name]);
+    var onSyncLayerTimeline = useCallback(function () {
+      return syncTimeFilterWithLayerTimeline(idx, true);
+    }, [syncTimeFilterWithLayerTimeline, idx]);
+    var onRemoveSyncWithLayerTimeline = useCallback(function () {
+      return syncTimeFilterWithLayerTimeline(idx, false);
+    }, [syncTimeFilterWithLayerTimeline, idx]);
+    var animatableLayers = useMemo(function () {
+      return getAnimatableVisibleLayers(layers);
+    }, [layers]);
+    var isLinkedWithLayerTimeline = useMemo(function () {
+      return filter.syncedWithLayerTimeline;
+    }, [filter]);
+    return /*#__PURE__*/React.createElement(SyncedDatasetsArea, null, filter.dataId.length > 1 ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledContentTitle, null, "Datasets"), filter.dataId.map(function (dataId, index) {
+      return /*#__PURE__*/React.createElement(DatasetItem, {
+        key: dataId,
+        dataId: dataId,
+        index: index,
+        datasets: datasets,
+        supportedFields: supportedFields,
+        idx: idx,
+        filter: filter,
+        onRemoveSyncedFilter: onRemoveSyncedFilter,
+        filterDatasetsNum: filterDatasetsNum,
+        datasetsWithTimeNum: datasetsWithTimeNum,
+        onSelectSyncedDataset: onSelectSyncedDataset,
+        onFieldSelector: onFieldSelector
+      });
+    })) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(SourceDataSelector, {
+      inputTheme: "secondary",
+      datasets: datasets,
+      dataId: Array.isArray(filter.dataId) ? filter.dataId[0] : filter.dataId,
+      onSelect: onSourceDataSelector
+    })), isLinkedWithLayerTimeline ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledSeparator, null), /*#__PURE__*/React.createElement(LayerTimeline, {
+      layers: animatableLayers,
+      onDelete: onRemoveSyncWithLayerTimeline
+    })) : /*#__PURE__*/React.createElement(React.Fragment, null, animatableLayers.length ? /*#__PURE__*/React.createElement(SyncLayerTimelineButton, {
+      onSyncLayerTimeline: onSyncLayerTimeline
+    }) : null), filterDatasetsNum < datasetsWithTimeNum ? /*#__PURE__*/React.createElement(SyncedDatasetButton, {
+      onAddSyncedFilter: onAddSyncedFilter
+    }) : null);
+  };
+  FilterSyncedDatasetPanel.displayName = 'FilterSyncedDatasetPanel';
+  return FilterSyncedDatasetPanel;
+}
+FilterSyncedDatasetPanelFactory.deps = [DatasetItemFactory, LayerTimelineFactory, SourceDataSelectorFactory, SyncedDatasetButtonFactory, SyncLayerTimelineButtonFactory];
+export default FilterSyncedDatasetPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","styled","withTheme","FormattedMessage","ALL_FIELD_TYPES","getAnimatableVisibleLayers","Button","Add","Trash","TippyTooltip","FilterPanelHeaderFactory","SourceSelectorFactory","SourceDataSelectorFactory","LayerTypeListItemFactory","TrashIcon","_templateObject","_taggedTemplateLiteral","props","theme","fontWhiteColor","SyncedDatasetsArea","div","_templateObject2","StyledContentTitle","_templateObject3","subtextColor","StyledSeparator","_templateObject4","StyledButton","_templateObject5","getDatasetsWithTimeField","datasets","rv","_i","_Object$keys","Object","keys","length","id","fields","some","f","type","timestamp","getTimeFields","dataset","filter","DatasetItemFactory","SourceSelector","FilterPanelHeader","StyledFilterPanelHeader","_templateObject6","StyledSourceSelector","_templateObject7","DatasetItem","_ref","dataId","supportedFields","idx","index","onRemoveSyncedFilter","filterDatasetsNum","datasetsWithTimeNum","onSelectSyncedDataset","onFieldSelector","createElement","allAvailableFields","removeFilter","disabled","onSelectDataset","datasetId","fieldValue","name","field","deps","StyledLayerTimeline","_templateObject8","StyledLayerList","_templateObject9","LayerTimelineFactory","LayerTypeListItem","StyledLayerTypeListItem","_templateObject0","dropdownListHighlightBg","LayerTimeline","_ref2","layers","onDelete","map","layer","key","value","icon","layerIcon","label","_objectSpread","layerTypeIconSizeSM","height","width","onClick","SyncedDatasetButtonFactory","SyncedDatasetButton","_ref3","onAddSyncedFilter","delay","placement","render","className","secondary","SyncLayerTimelineButtonFactory","SyncLayerTimelineButton","_ref4","onSyncLayerTimeline","FilterSyncedDatasetPanelFactory","SourceDataSelector","FilterSyncedDatasetPanel","_ref5","setFilter","onSourceDataSelector","syncTimeFilterWithLayerTimeline","datasetsWithTime","valueIndex","_getTimeFields","nextId","find","includes","timeFieldNames","nextName","onRemoveSyncWithLayerTimeline","animatableLayers","isLinkedWithLayerTimeline","syncedWithLayerTimeline","Fragment","inputTheme","Array","isArray","onSelect","displayName"],"sources":["../../../../src/filters/filter-panels/filter-synced-dataset-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo} from 'react';\nimport styled, {withTheme} from 'styled-components';\n\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {ALL_FIELD_TYPES} from '@kepler.gl/constants';\nimport {getAnimatableVisibleLayers} from '@kepler.gl/utils';\n\nimport {Button} from '../../common/styled-components';\nimport {Add, Trash} from '../../common/icons';\nimport TippyTooltip from '../../common/tippy-tooltip';\nimport FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';\nimport SourceSelectorFactory from '../../side-panel/common/source-selector';\nimport SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';\nimport LayerTypeListItemFactory from '../../side-panel/layer-panel/layer-type-list-item';\n\nconst TrashIcon = styled(Trash)`\n  cursor: pointer;\n  color: ${props => props.theme.fontWhiteColor};\n  margin-left: 8px;\n`;\n\nconst SyncedDatasetsArea = styled.div`\n  .side-panel-section {\n    margin-bottom: 0;\n  }\n`;\n\nconst StyledContentTitle = styled.div`\n  color: ${props => props.theme.subtextColor};\n  margin-bottom: 8px;\n`;\n\nconst StyledSeparator = styled.div`\n  border-left: 1px dashed ${props => props.theme.subtextColor};\n  height: 16px;\n  margin: 4px 0 4px 8px;\n`;\n\nconst StyledButton = styled(Button)`\n  margin-top: 2px;\n  padding: 2px;\n`;\n\nfunction getDatasetsWithTimeField(datasets) {\n  const rv = {};\n  for (const id of Object.keys(datasets)) {\n    // TODO: change to\n    if (datasets[id].fields.some(f => f.type === ALL_FIELD_TYPES.timestamp)) {\n      rv[id] = datasets[id];\n    }\n  }\n  return rv;\n}\n\nfunction getTimeFields(dataset) {\n  return dataset.fields.filter(f => f.type === ALL_FIELD_TYPES.timestamp);\n}\n\nfunction DatasetItemFactory(SourceSelector, FilterPanelHeader) {\n  const StyledFilterPanelHeader = styled(FilterPanelHeader)`\n    display: flex;\n    border: none;\n    height: unset;\n    padding: 2px 0;\n    background: none;\n    align-items: baseline;\n  `;\n\n  const StyledSourceSelector = styled(SourceSelector)`\n    flex: 1;\n    -webkit-border-radius: 8px;\n    -moz-border-radius: 8px;\n    border-radius: 8px;\n    background-color: transparent;\n  `;\n\n  // Check if this component already exists\n  const DatasetItem = ({\n    dataId,\n    datasets,\n    supportedFields,\n    idx,\n    filter,\n    index,\n    onRemoveSyncedFilter,\n    filterDatasetsNum,\n    datasetsWithTimeNum,\n    onSelectSyncedDataset,\n    onFieldSelector\n  }) => (\n    <div>\n      <StyledSeparator />\n      <StyledFilterPanelHeader\n        datasets={[datasets[dataId]]}\n        allAvailableFields={supportedFields}\n        idx={idx}\n        filter={filter}\n        removeFilter={() => onRemoveSyncedFilter(index)}\n      >\n        <StyledSourceSelector\n          datasets={datasets}\n          disabled={filterDatasetsNum >= datasetsWithTimeNum}\n          dataId={dataId}\n          onSelectDataset={datasetId => onSelectSyncedDataset(datasetId, index)}\n          fields={getTimeFields(datasets[dataId])}\n          fieldValue={filter.name[index]}\n          onFieldSelector={field => onFieldSelector(field, index)}\n        />\n      </StyledFilterPanelHeader>\n    </div>\n  );\n\n  return DatasetItem;\n}\n\nDatasetItemFactory.deps = [SourceSelectorFactory, FilterPanelHeaderFactory];\n\nconst StyledLayerTimeline = styled.div`\n  display: flex;\n  align-items: center;\n`;\n\nconst StyledLayerList = styled.div`\n  flex: 1;\n`;\n\nfunction LayerTimelineFactory(LayerTypeListItem) {\n  const StyledLayerTypeListItem = styled(LayerTypeListItem)`\n    background-color: ${props => props.theme.dropdownListHighlightBg};\n    padding: 4px;\n  `;\n\n  const LayerTimeline = ({layers, theme, onDelete}) => (\n    <StyledLayerTimeline>\n      <StyledLayerList>\n        {layers.map(layer => (\n          <StyledLayerTypeListItem\n            key={layer.id}\n            value={{icon: layer.layerIcon, label: layer.name}}\n            theme={{...theme, layerTypeIconSizeSM: 24}}\n          />\n        ))}\n      </StyledLayerList>\n      <TrashIcon height=\"12px\" width=\"12px\" onClick={onDelete} />\n    </StyledLayerTimeline>\n  );\n\n  return withTheme(LayerTimeline);\n}\n\nLayerTimelineFactory.deps = [LayerTypeListItemFactory];\n\nfunction SyncedDatasetButtonFactory() {\n  const SyncedDatasetButton = ({onAddSyncedFilter}) => (\n    <div>\n      <StyledSeparator />\n      <TippyTooltip\n        delay={[500, 0]}\n        placement=\"top\"\n        render={() => (\n          <div>\n            <FormattedMessage id={'tooltip.timeFilterSync'} />\n          </div>\n        )}\n      >\n        <StyledButton className=\"add-sync-dataset\" secondary={true} onClick={onAddSyncedFilter}>\n          <Add height=\"12px\" />\n          <FormattedMessage id={'filterManager.timeFilterSync'} />\n        </StyledButton>\n      </TippyTooltip>\n    </div>\n  );\n\n  return SyncedDatasetButton;\n}\n\nfunction SyncLayerTimelineButtonFactory() {\n  const SyncLayerTimelineButton = ({onSyncLayerTimeline}) => (\n    <div>\n      <StyledSeparator />\n      <TippyTooltip\n        delay={[500, 0]}\n        placement=\"top\"\n        render={() => (\n          <div>\n            <FormattedMessage id={'tooltip.timeLayerSync'} />\n          </div>\n        )}\n      >\n        <StyledButton className=\"add-sync-dataset\" secondary={true} onClick={onSyncLayerTimeline}>\n          <Add height=\"12px\" />\n          <FormattedMessage id={'filterManager.timeLayerSync'} />\n        </StyledButton>\n      </TippyTooltip>\n    </div>\n  );\n\n  return SyncLayerTimelineButton;\n}\n\nfunction FilterSyncedDatasetPanelFactory(\n  DatasetItem,\n  LayerTimeline,\n  SourceDataSelector,\n  SyncedDatasetButton,\n  SyncLayerTimelineButton\n) {\n  const FilterSyncedDatasetPanel = ({\n    datasets,\n    layers,\n    filter,\n    setFilter,\n    idx,\n    supportedFields,\n    onFieldSelector,\n    onSourceDataSelector,\n    syncTimeFilterWithLayerTimeline\n  }) => {\n    const datasetsWithTime = useMemo(() => getDatasetsWithTimeField(datasets), [datasets]);\n    const filterDatasetsNum = useMemo(() => filter.dataId.length, [filter.dataId]);\n    const datasetsWithTimeNum = useMemo(\n      () => Object.keys(datasetsWithTime).length,\n      [datasetsWithTime]\n    );\n\n    const onRemoveSyncedFilter = useCallback(\n      valueIndex => {\n        setFilter(idx, 'dataId', null, valueIndex);\n      },\n      [idx, setFilter]\n    );\n\n    const onSelectSyncedDataset = useCallback(\n      (datasetId, valueIndex) => {\n        setFilter(idx, 'dataId', datasetId, valueIndex);\n      },\n      [setFilter, idx]\n    );\n\n    const onAddSyncedFilter = useCallback(() => {\n      const nextId = Object.keys(datasetsWithTime).find(id => !filter.dataId.includes(id));\n      if (!nextId) return;\n      const timeFieldNames = getTimeFields(datasets[nextId])?.map(f => f.name);\n      if (!timeFieldNames || timeFieldNames.length < 1) return;\n      const nextName = timeFieldNames.includes(filter.name[0]) ? filter.name[0] : timeFieldNames[0];\n      setFilter(idx, ['dataId', 'name'], [nextId, nextName], filter.dataId.length);\n    }, [setFilter, idx, datasetsWithTime, datasets, filter.dataId, filter.name]);\n\n    const onSyncLayerTimeline = useCallback(\n      () => syncTimeFilterWithLayerTimeline(idx, true),\n      [syncTimeFilterWithLayerTimeline, idx]\n    );\n\n    const onRemoveSyncWithLayerTimeline = useCallback(\n      () => syncTimeFilterWithLayerTimeline(idx, false),\n      [syncTimeFilterWithLayerTimeline, idx]\n    );\n\n    const animatableLayers = useMemo(() => getAnimatableVisibleLayers(layers), [layers]);\n\n    const isLinkedWithLayerTimeline = useMemo(() => filter.syncedWithLayerTimeline, [filter]);\n\n    return (\n      <SyncedDatasetsArea>\n        {filter.dataId.length > 1 ? (\n          <>\n            <StyledContentTitle>Datasets</StyledContentTitle>\n            {filter.dataId.map((dataId, index) => {\n              return (\n                <DatasetItem\n                  key={dataId}\n                  dataId={dataId}\n                  index={index}\n                  datasets={datasets}\n                  supportedFields={supportedFields}\n                  idx={idx}\n                  filter={filter}\n                  onRemoveSyncedFilter={onRemoveSyncedFilter}\n                  filterDatasetsNum={filterDatasetsNum}\n                  datasetsWithTimeNum={datasetsWithTimeNum}\n                  onSelectSyncedDataset={onSelectSyncedDataset}\n                  onFieldSelector={onFieldSelector}\n                />\n              );\n            })}\n          </>\n        ) : (\n          <>\n            <SourceDataSelector\n              inputTheme=\"secondary\"\n              datasets={datasets}\n              dataId={Array.isArray(filter.dataId) ? filter.dataId[0] : filter.dataId}\n              onSelect={onSourceDataSelector}\n            />\n          </>\n        )}\n        {/** sync with animatable layers */}\n        {isLinkedWithLayerTimeline ? (\n          <>\n            <StyledSeparator />\n            <LayerTimeline layers={animatableLayers} onDelete={onRemoveSyncWithLayerTimeline} />\n          </>\n        ) : (\n          <>\n            {animatableLayers.length ? (\n              <SyncLayerTimelineButton onSyncLayerTimeline={onSyncLayerTimeline} />\n            ) : null}\n          </>\n        )}\n        {filterDatasetsNum < datasetsWithTimeNum ? (\n          <SyncedDatasetButton onAddSyncedFilter={onAddSyncedFilter} />\n        ) : null}\n      </SyncedDatasetsArea>\n    );\n  };\n\n  FilterSyncedDatasetPanel.displayName = 'FilterSyncedDatasetPanel';\n\n  return FilterSyncedDatasetPanel;\n}\n\nFilterSyncedDatasetPanelFactory.deps = [\n  DatasetItemFactory,\n  LayerTimelineFactory,\n  SourceDataSelectorFactory,\n  SyncedDatasetButtonFactory,\n  SyncLayerTimelineButtonFactory\n];\n\nexport default FilterSyncedDatasetPanelFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/filters/filter-panels/multi-select-filter-panel.js

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import MultiSelectFilterFactory from '../multi-select-filter';
+import FieldPanelWithFieldSelectFactory from './filter-panel-with-field-select';
+MultiSelectFilterPanelFactory.deps = [FieldPanelWithFieldSelectFactory, MultiSelectFilterFactory];
+function MultiSelectFilterPanelFactory(FieldPanelWithFieldSelect, MultiSelectFilterComponent) {
+  var MultiSelectFilterPanel = /*#__PURE__*/React.memo(function (_ref) {
+    var idx = _ref.idx,
+      datasets = _ref.datasets,
+      allAvailableFields = _ref.allAvailableFields,
+      filter = _ref.filter,
+      setFilter = _ref.setFilter,
+      removeFilter = _ref.removeFilter;
+    var onSetFilter = useCallback(function (value) {
+      return setFilter(idx, 'value', value);
+    }, [idx, setFilter]);
+    return /*#__PURE__*/React.createElement("div", {
+      className: "multi-select-filter-panel"
+    }, /*#__PURE__*/React.createElement(FieldPanelWithFieldSelect, {
+      allAvailableFields: allAvailableFields,
+      datasets: datasets,
+      filter: filter,
+      idx: idx,
+      removeFilter: removeFilter,
+      setFilter: setFilter
+    }, filter.type && /*#__PURE__*/React.createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/React.createElement(MultiSelectFilterComponent, {
+      filter: filter,
+      setFilter: onSetFilter
+    }))));
+  });
+  MultiSelectFilterPanel.displayName = 'MultiSelectFilterPanel';
+  return MultiSelectFilterPanel;
+}
+export default MultiSelectFilterPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZUNhbGxiYWNrIiwiTXVsdGlTZWxlY3RGaWx0ZXJGYWN0b3J5IiwiRmllbGRQYW5lbFdpdGhGaWVsZFNlbGVjdEZhY3RvcnkiLCJNdWx0aVNlbGVjdEZpbHRlclBhbmVsRmFjdG9yeSIsImRlcHMiLCJGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0IiwiTXVsdGlTZWxlY3RGaWx0ZXJDb21wb25lbnQiLCJNdWx0aVNlbGVjdEZpbHRlclBhbmVsIiwibWVtbyIsIl9yZWYiLCJpZHgiLCJkYXRhc2V0cyIsImFsbEF2YWlsYWJsZUZpZWxkcyIsImZpbHRlciIsInNldEZpbHRlciIsInJlbW92ZUZpbHRlciIsIm9uU2V0RmlsdGVyIiwidmFsdWUiLCJjcmVhdGVFbGVtZW50IiwiY2xhc3NOYW1lIiwidHlwZSIsImRpc3BsYXlOYW1lIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2ZpbHRlcnMvZmlsdGVyLXBhbmVscy9tdWx0aS1zZWxlY3QtZmlsdGVyLXBhbmVsLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgUmVhY3QsIHt1c2VDYWxsYmFja30gZnJvbSAncmVhY3QnO1xuaW1wb3J0IE11bHRpU2VsZWN0RmlsdGVyRmFjdG9yeSBmcm9tICcuLi9tdWx0aS1zZWxlY3QtZmlsdGVyJztcbmltcG9ydCB7TXVsdGlTZWxlY3RGaWx0ZXJ9IGZyb20gJ0BrZXBsZXIuZ2wvdHlwZXMnO1xuaW1wb3J0IEZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3RGYWN0b3J5IGZyb20gJy4vZmlsdGVyLXBhbmVsLXdpdGgtZmllbGQtc2VsZWN0JztcbmltcG9ydCB7RmlsdGVyUGFuZWxDb21wb25lbnR9IGZyb20gJy4vdHlwZXMnO1xuXG5NdWx0aVNlbGVjdEZpbHRlclBhbmVsRmFjdG9yeS5kZXBzID0gW0ZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3RGYWN0b3J5LCBNdWx0aVNlbGVjdEZpbHRlckZhY3RvcnldO1xuXG5mdW5jdGlvbiBNdWx0aVNlbGVjdEZpbHRlclBhbmVsRmFjdG9yeShcbiAgRmllbGRQYW5lbFdpdGhGaWVsZFNlbGVjdDogUmV0dXJuVHlwZTx0eXBlb2YgRmllbGRQYW5lbFdpdGhGaWVsZFNlbGVjdEZhY3Rvcnk+LFxuICBNdWx0aVNlbGVjdEZpbHRlckNvbXBvbmVudDogUmV0dXJuVHlwZTx0eXBlb2YgTXVsdGlTZWxlY3RGaWx0ZXJGYWN0b3J5PlxuKSB7XG4gIGNvbnN0IE11bHRpU2VsZWN0RmlsdGVyUGFuZWw6IEZpbHRlclBhbmVsQ29tcG9uZW50PE11bHRpU2VsZWN0RmlsdGVyPiA9IFJlYWN0Lm1lbW8oXG4gICAgKHtpZHgsIGRhdGFzZXRzLCBhbGxBdmFpbGFibGVGaWVsZHMsIGZpbHRlciwgc2V0RmlsdGVyLCByZW1vdmVGaWx0ZXJ9KSA9PiB7XG4gICAgICBjb25zdCBvblNldEZpbHRlciA9IHVzZUNhbGxiYWNrKHZhbHVlID0+IHNldEZpbHRlcihpZHgsICd2YWx1ZScsIHZhbHVlKSwgW2lkeCwgc2V0RmlsdGVyXSk7XG5cbiAgICAgIHJldHVybiAoXG4gICAgICAgIDxkaXYgY2xhc3NOYW1lPVwibXVsdGktc2VsZWN0LWZpbHRlci1wYW5lbFwiPlxuICAgICAgICAgIDxGaWVsZFBhbmVsV2l0aEZpZWxkU2VsZWN0XG4gICAgICAgICAgICBhbGxBdmFpbGFibGVGaWVsZHM9e2FsbEF2YWlsYWJsZUZpZWxkc31cbiAgICAgICAgICAgIGRhdGFzZXRzPXtkYXRhc2V0c31cbiAgICAgICAgICAgIGZpbHRlcj17ZmlsdGVyfVxuICAgICAgICAgICAgaWR4PXtpZHh9XG4gICAgICAgICAgICByZW1vdmVGaWx0ZXI9e3JlbW92ZUZpbHRlcn1cbiAgICAgICAgICAgIHNldEZpbHRlcj17c2V0RmlsdGVyfVxuICAgICAgICAgID5cbiAgICAgICAgICAgIHtmaWx0ZXIudHlwZSAmJiAoXG4gICAgICAgICAgICAgIDxkaXYgY2xhc3NOYW1lPVwiZmlsdGVyLXBhbmVsX19maWx0ZXJcIj5cbiAgICAgICAgICAgICAgICA8TXVsdGlTZWxlY3RGaWx0ZXJDb21wb25lbnQgZmlsdGVyPXtmaWx0ZXJ9IHNldEZpbHRlcj17b25TZXRGaWx0ZXJ9IC8+XG4gICAgICAgICAgICAgIDwvZGl2PlxuICAgICAgICAgICAgKX1cbiAgICAgICAgICA8L0ZpZWxkUGFuZWxXaXRoRmllbGRTZWxlY3Q+XG4gICAgICAgIDwvZGl2PlxuICAgICAgKTtcbiAgICB9XG4gICk7XG5cbiAgTXVsdGlTZWxlY3RGaWx0ZXJQYW5lbC5kaXNwbGF5TmFtZSA9ICdNdWx0aVNlbGVjdEZpbHRlclBhbmVsJztcblxuICByZXR1cm4gTXVsdGlTZWxlY3RGaWx0ZXJQYW5lbDtcbn1cblxuZXhwb3J0IGRlZmF1bHQgTXVsdGlTZWxlY3RGaWx0ZXJQYW5lbEZhY3Rvcnk7XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7O0FBRUEsT0FBT0EsS0FBSyxJQUFHQyxXQUFXLFFBQU8sT0FBTztBQUN4QyxPQUFPQyx3QkFBd0IsTUFBTSx3QkFBd0I7QUFFN0QsT0FBT0MsZ0NBQWdDLE1BQU0sa0NBQWtDO0FBRy9FQyw2QkFBNkIsQ0FBQ0MsSUFBSSxHQUFHLENBQUNGLGdDQUFnQyxFQUFFRCx3QkFBd0IsQ0FBQztBQUVqRyxTQUFTRSw2QkFBNkJBLENBQ3BDRSx5QkFBOEUsRUFDOUVDLDBCQUF1RSxFQUN2RTtFQUNBLElBQU1DLHNCQUErRCxnQkFBR1IsS0FBSyxDQUFDUyxJQUFJLENBQ2hGLFVBQUFDLElBQUEsRUFBMEU7SUFBQSxJQUF4RUMsR0FBRyxHQUFBRCxJQUFBLENBQUhDLEdBQUc7TUFBRUMsUUFBUSxHQUFBRixJQUFBLENBQVJFLFFBQVE7TUFBRUMsa0JBQWtCLEdBQUFILElBQUEsQ0FBbEJHLGtCQUFrQjtNQUFFQyxNQUFNLEdBQUFKLElBQUEsQ0FBTkksTUFBTTtNQUFFQyxTQUFTLEdBQUFMLElBQUEsQ0FBVEssU0FBUztNQUFFQyxZQUFZLEdBQUFOLElBQUEsQ0FBWk0sWUFBWTtJQUNsRSxJQUFNQyxXQUFXLEdBQUdoQixXQUFXLENBQUMsVUFBQWlCLEtBQUs7TUFBQSxPQUFJSCxTQUFTLENBQUNKLEdBQUcsRUFBRSxPQUFPLEVBQUVPLEtBQUssQ0FBQztJQUFBLEdBQUUsQ0FBQ1AsR0FBRyxFQUFFSSxTQUFTLENBQUMsQ0FBQztJQUUxRixvQkFDRWYsS0FBQSxDQUFBbUIsYUFBQTtNQUFLQyxTQUFTLEVBQUM7SUFBMkIsZ0JBQ3hDcEIsS0FBQSxDQUFBbUIsYUFBQSxDQUFDYix5QkFBeUI7TUFDeEJPLGtCQUFrQixFQUFFQSxrQkFBbUI7TUFDdkNELFFBQVEsRUFBRUEsUUFBUztNQUNuQkUsTUFBTSxFQUFFQSxNQUFPO01BQ2ZILEdBQUcsRUFBRUEsR0FBSTtNQUNUSyxZQUFZLEVBQUVBLFlBQWE7TUFDM0JELFNBQVMsRUFBRUE7SUFBVSxHQUVwQkQsTUFBTSxDQUFDTyxJQUFJLGlCQUNWckIsS0FBQSxDQUFBbUIsYUFBQTtNQUFLQyxTQUFTLEVBQUM7SUFBc0IsZ0JBQ25DcEIsS0FBQSxDQUFBbUIsYUFBQSxDQUFDWiwwQkFBMEI7TUFBQ08sTUFBTSxFQUFFQSxNQUFPO01BQUNDLFNBQVMsRUFBRUU7SUFBWSxDQUFFLENBQ2xFLENBRWtCLENBQ3hCLENBQUM7RUFFVixDQUNGLENBQUM7RUFFRFQsc0JBQXNCLENBQUNjLFdBQVcsR0FBRyx3QkFBd0I7RUFFN0QsT0FBT2Qsc0JBQXNCO0FBQy9CO0FBRUEsZUFBZUosNkJBQTZCIiwiaWdub3JlTGlzdCI6W119

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

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import { StyledFilterContent } from '../../common/styled-components';
+import FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';
+import SourceDataSelectorFactory from '../../side-panel/common/source-data-selector';
+import FieldSelectorFactory from '../../common/field-selector';
+NewFilterPanelFactory.deps = [FilterPanelHeaderFactory, SourceDataSelectorFactory, FieldSelectorFactory];
+export 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.memo(function (_ref) {
+    var idx = _ref.idx,
+      filter = _ref.filter,
+      datasets = _ref.datasets,
+      allAvailableFields = _ref.allAvailableFields,
+      setFilter = _ref.setFilter,
+      removeFilter = _ref.removeFilter;
+    var onFieldSelector = useCallback(function (field) {
+      return setFilter(idx, 'name', field.name);
+    }, [idx, setFilter]);
+    var onSourceDataSelector = useCallback(function (value) {
+      return setFilter(idx, 'dataId', value, 0);
+    }, [idx, setFilter]);
+    var dataset = datasets[filter.dataId[0]];
+    var supportedFields = useMemo(function () {
+      return getSupportedFilterFields(dataset.supportedFilterTypes, allAvailableFields);
+    }, [dataset.supportedFilterTypes, allAvailableFields]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterPanelHeader, {
+      datasets: [dataset],
+      filter: filter,
+      removeFilter: removeFilter
+    }, /*#__PURE__*/React.createElement(FieldSelector, {
+      inputTheme: "secondary",
+      fields: supportedFields,
+      value: Array.isArray(filter.name) ? filter.name[0] : filter.name,
+      erasable: false,
+      onSelect: onFieldSelector
+    })), /*#__PURE__*/React.createElement(StyledFilterContent, {
+      className: "filter-panel__content"
+    }, Object.keys(datasets).length > 1 && /*#__PURE__*/React.createElement(SourceDataSelector, {
+      inputTheme: "secondary",
+      datasets: datasets,
+      dataId: filter.dataId,
+      onSelect: onSourceDataSelector
+    })));
+  });
+  NewFilterPanel.displayName = 'NewFilterPanel';
+  return NewFilterPanel;
+}
+export default NewFilterPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo, useCallback } from 'react';
+import { StyledFilterContent } from '../../common/styled-components';
+import PolygonFilterFactory from '../polygon-filter';
+import PanelHeaderActionFactory from '../../side-panel/panel-header-action';
+import { EyeSeen, EyeUnseen } from '../../common/icons';
+import FilterPanelHeaderFactory from '../../side-panel/filter-panel/filter-panel-header';
+import { StyledFilterPanel } from '../components';
+import get from 'es-toolkit/compat/get';
+PolygonFilterPanelFactory.deps = [FilterPanelHeaderFactory, PolygonFilterFactory, PanelHeaderActionFactory];
+function PolygonFilterPanelFactory(FilterPanelHeader, PolygonFilter, PanelHeaderAction) {
+  var PolygonFilterPanel = /*#__PURE__*/React.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 = useMemo(function () {
+      return filter.dataId.map(function (d) {
+        return datasets[d];
+      });
+    }, [filter, datasets]);
+    var onSetLayers = useCallback(function (value) {
+      return setFilter(idx, 'layerId', value);
+    }, [setFilter, idx]);
+    var isVisible = get(filter, ['value', 'properties', 'isVisible'], true);
+    var featureType = get(filter, ['value', 'geometry', 'type'], 'Polygon');
+    return /*#__PURE__*/React.createElement("div", {
+      className: "polygon-filter-panel"
+    }, /*#__PURE__*/React.createElement(FilterPanelHeader, {
+      datasets: filterDatasets,
+      filter: filter,
+      removeFilter: removeFilter
+    }, /*#__PURE__*/React.createElement(StyledFilterPanel, null, "Geo - ", featureType), /*#__PURE__*/React.createElement(PanelHeaderAction, {
+      id: filter.id,
+      onClick: toggleFilterFeature,
+      tooltip: isVisible ? 'tooltip.hideFeature' : 'tooltip.showFeature',
+      IconComponent: isVisible ? EyeSeen : EyeUnseen,
+      active: isVisible
+    })), /*#__PURE__*/React.createElement(StyledFilterContent, {
+      className: "filter-panel__content"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "filter-panel__filter"
+    }, /*#__PURE__*/React.createElement(PolygonFilter, {
+      filter: filter,
+      layers: layers,
+      setLayers: onSetLayers
+    }))));
+  });
+  PolygonFilterPanel.displayName = 'PolygonFilterPanel';
+  return PolygonFilterPanel;
+}
+export default PolygonFilterPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZU1lbW8iLCJ1c2VDYWxsYmFjayIsIlN0eWxlZEZpbHRlckNvbnRlbnQiLCJQb2x5Z29uRmlsdGVyRmFjdG9yeSIsIlBhbmVsSGVhZGVyQWN0aW9uRmFjdG9yeSIsIkV5ZVNlZW4iLCJFeWVVbnNlZW4iLCJGaWx0ZXJQYW5lbEhlYWRlckZhY3RvcnkiLCJTdHlsZWRGaWx0ZXJQYW5lbCIsImdldCIsIlBvbHlnb25GaWx0ZXJQYW5lbEZhY3RvcnkiLCJkZXBzIiwiRmlsdGVyUGFuZWxIZWFkZXIiLCJQb2x5Z29uRmlsdGVyIiwiUGFuZWxIZWFkZXJBY3Rpb24iLCJQb2x5Z29uRmlsdGVyUGFuZWwiLCJtZW1vIiwiX3JlZiIsImlkeCIsImRhdGFzZXRzIiwibGF5ZXJzIiwiZmlsdGVyIiwicmVtb3ZlRmlsdGVyIiwic2V0RmlsdGVyIiwidG9nZ2xlRmlsdGVyRmVhdHVyZSIsImZpbHRlckRhdGFzZXRzIiwiZGF0YUlkIiwibWFwIiwiZCIsIm9uU2V0TGF5ZXJzIiwidmFsdWUiLCJpc1Zpc2libGUiLCJmZWF0dXJlVHlwZSIsImNyZWF0ZUVsZW1lbnQiLCJjbGFzc05hbWUiLCJpZCIsIm9uQ2xpY2siLCJ0b29sdGlwIiwiSWNvbkNvbXBvbmVudCIsImFjdGl2ZSIsInNldExheWVycyIsImRpc3BsYXlOYW1lIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2ZpbHRlcnMvZmlsdGVyLXBhbmVscy9wb2x5Z29uLWZpbHRlci1wYW5lbC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuaW1wb3J0IFJlYWN0LCB7dXNlTWVtbywgdXNlQ2FsbGJhY2t9IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7U3R5bGVkRmlsdGVyQ29udGVudH0gZnJvbSAnLi4vLi4vY29tbW9uL3N0eWxlZC1jb21wb25lbnRzJztcbmltcG9ydCBQb2x5Z29uRmlsdGVyRmFjdG9yeSBmcm9tICcuLi9wb2x5Z29uLWZpbHRlcic7XG5pbXBvcnQgUGFuZWxIZWFkZXJBY3Rpb25GYWN0b3J5IGZyb20gJy4uLy4uL3NpZGUtcGFuZWwvcGFuZWwtaGVhZGVyLWFjdGlvbic7XG5pbXBvcnQge0V5ZVNlZW4sIEV5ZVVuc2Vlbn0gZnJvbSAnLi4vLi4vY29tbW9uL2ljb25zJztcblxuaW1wb3J0IEZpbHRlclBhbmVsSGVhZGVyRmFjdG9yeSBmcm9tICcuLi8uLi9zaWRlLXBhbmVsL2ZpbHRlci1wYW5lbC9maWx0ZXItcGFuZWwtaGVhZGVyJztcbmltcG9ydCB7U3R5bGVkRmlsdGVyUGFuZWx9IGZyb20gJy4uL2NvbXBvbmVudHMnO1xuXG5pbXBvcnQgZ2V0IGZyb20gJ2VzLXRvb2xraXQvY29tcGF0L2dldCc7XG5pbXBvcnQge1BvbHlnb25GaWx0ZXJQYW5lbENvbXBvbmVudH0gZnJvbSAnLi90eXBlcyc7XG5pbXBvcnQge0tlcGxlclRhYmxlfSBmcm9tICdAa2VwbGVyLmdsL3RhYmxlJztcblxuUG9seWdvbkZpbHRlclBhbmVsRmFjdG9yeS5kZXBzID0gW1xuICBGaWx0ZXJQYW5lbEhlYWRlckZhY3RvcnksXG4gIFBvbHlnb25GaWx0ZXJGYWN0b3J5LFxuICBQYW5lbEhlYWRlckFjdGlvbkZhY3Rvcnlcbl07XG5cbmZ1bmN0aW9uIFBvbHlnb25GaWx0ZXJQYW5lbEZhY3RvcnkoXG4gIEZpbHRlclBhbmVsSGVhZGVyOiBSZXR1cm5UeXBlPHR5cGVvZiBGaWx0ZXJQYW5lbEhlYWRlckZhY3Rvcnk+LFxuICBQb2x5Z29uRmlsdGVyOiBSZXR1cm5UeXBlPHR5cGVvZiBQb2x5Z29uRmlsdGVyRmFjdG9yeT4sXG4gIFBhbmVsSGVhZGVyQWN0aW9uOiBSZXR1cm5UeXBlPHR5cGVvZiBQYW5lbEhlYWRlckFjdGlvbkZhY3Rvcnk+XG4pIHtcbiAgY29uc3QgUG9seWdvbkZpbHRlclBhbmVsOiBQb2x5Z29uRmlsdGVyUGFuZWxDb21wb25lbnQgPSBSZWFjdC5tZW1vKFxuICAgICh7aWR4LCBkYXRhc2V0cywgbGF5ZXJzLCBmaWx0ZXIsIHJlbW92ZUZpbHRlciwgc2V0RmlsdGVyLCB0b2dnbGVGaWx0ZXJGZWF0dXJlfSkgPT4ge1xuICAgICAgY29uc3QgZmlsdGVyRGF0YXNldHM6IEtlcGxlclRhYmxlW10gPSB1c2VNZW1vKFxuICAgICAgICAoKSA9PiBmaWx0ZXIuZGF0YUlkLm1hcChkID0+IGRhdGFzZXRzW2RdKSxcbiAgICAgICAgW2ZpbHRlciwgZGF0YXNldHNdXG4gICAgICApO1xuXG4gICAgICBjb25zdCBvblNldExheWVycyA9IHVzZUNhbGxiYWNrKHZhbHVlID0+IHNldEZpbHRlcihpZHgsICdsYXllcklkJywgdmFsdWUpLCBbc2V0RmlsdGVyLCBpZHhdKTtcblxuICAgICAgY29uc3QgaXNWaXNpYmxlID0gZ2V0KGZpbHRlciwgWyd2YWx1ZScsICdwcm9wZXJ0aWVzJywgJ2lzVmlzaWJsZSddLCB0cnVlKTtcbiAgICAgIGNvbnN0IGZlYXR1cmVUeXBlID0gZ2V0KGZpbHRlciwgWyd2YWx1ZScsICdnZW9tZXRyeScsICd0eXBlJ10sICdQb2x5Z29uJyk7XG5cbiAgICAgIHJldHVybiAoXG4gICAgICAgIDxkaXYgY2xhc3NOYW1lPVwicG9seWdvbi1maWx0ZXItcGFuZWxcIj5cbiAgICAgICAgICA8RmlsdGVyUGFuZWxIZWFkZXIgZGF0YXNldHM9e2ZpbHRlckRhdGFzZXRzfSBmaWx0ZXI9e2ZpbHRlcn0gcmVtb3ZlRmlsdGVyPXtyZW1vdmVGaWx0ZXJ9PlxuICAgICAgICAgICAgPFN0eWxlZEZpbHRlclBhbmVsPkdlbyAtIHtmZWF0dXJlVHlwZX08L1N0eWxlZEZpbHRlclBhbmVsPlxuICAgICAgICAgICAgPFBhbmVsSGVhZGVyQWN0aW9uXG4gICAgICAgICAgICAgIGlkPXtmaWx0ZXIuaWR9XG4gICAgICAgICAgICAgIG9uQ2xpY2s9e3RvZ2dsZUZpbHRlckZlYXR1cmV9XG4gICAgICAgICAgICAgIHRvb2x0aXA9e2lzVmlzaWJsZSA/ICd0b29sdGlwLmhpZGVGZWF0dXJlJyA6ICd0b29sdGlwLnNob3dGZWF0dXJlJ31cbiAgICAgICAgICAgICAgSWNvbkNvbXBvbmVudD17aXNWaXNpYmxlID8gRXllU2VlbiA6IEV5ZVVuc2Vlbn1cbiAgICAgICAgICAgICAgYWN0aXZlPXtpc1Zpc2libGV9XG4gICAgICAgICAgICAvPlxuICAgICAgICAgIDwvRmlsdGVyUGFuZWxIZWFkZXI+XG4gICAgICAgICAgPFN0eWxlZEZpbHRlckNvbnRlbnQgY2xhc3NOYW1lPVwiZmlsdGVyLXBhbmVsX19jb250ZW50XCI+XG4gICAgICAgICAgICA8ZGl2IGNsYXNzTmFtZT1cImZpbHRlci1wYW5lbF9fZmlsdGVyXCI+XG4gICAgICAgICAgICAgIDxQb2x5Z29uRmlsdGVyIGZpbHRlcj17ZmlsdGVyfSBsYXllcnM9e2xheWVyc30gc2V0TGF5ZXJzPXtvblNldExheWVyc30gLz5cbiAgICAgICAgICAgIDwvZGl2PlxuICAgICAgICAgIDwvU3R5bGVkRmlsdGVyQ29udGVudD5cbiAgICAgICAgPC9kaXY+XG4gICAgICApO1xuICAgIH1cbiAgKTtcblxuICBQb2x5Z29uRmlsdGVyUGFuZWwuZGlzcGxheU5hbWUgPSAnUG9seWdvbkZpbHRlclBhbmVsJztcblxuICByZXR1cm4gUG9seWdvbkZpbHRlclBhbmVsO1xufVxuXG5leHBvcnQgZGVmYXVsdCBQb2x5Z29uRmlsdGVyUGFuZWxGYWN0b3J5O1xuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBOztBQUVBLE9BQU9BLEtBQUssSUFBR0MsT0FBTyxFQUFFQyxXQUFXLFFBQU8sT0FBTztBQUNqRCxTQUFRQyxtQkFBbUIsUUFBTyxnQ0FBZ0M7QUFDbEUsT0FBT0Msb0JBQW9CLE1BQU0sbUJBQW1CO0FBQ3BELE9BQU9DLHdCQUF3QixNQUFNLHNDQUFzQztBQUMzRSxTQUFRQyxPQUFPLEVBQUVDLFNBQVMsUUFBTyxvQkFBb0I7QUFFckQsT0FBT0Msd0JBQXdCLE1BQU0sbURBQW1EO0FBQ3hGLFNBQVFDLGlCQUFpQixRQUFPLGVBQWU7QUFFL0MsT0FBT0MsR0FBRyxNQUFNLHVCQUF1QjtBQUl2Q0MseUJBQXlCLENBQUNDLElBQUksR0FBRyxDQUMvQkosd0JBQXdCLEVBQ3hCSixvQkFBb0IsRUFDcEJDLHdCQUF3QixDQUN6QjtBQUVELFNBQVNNLHlCQUF5QkEsQ0FDaENFLGlCQUE4RCxFQUM5REMsYUFBc0QsRUFDdERDLGlCQUE4RCxFQUM5RDtFQUNBLElBQU1DLGtCQUErQyxnQkFBR2hCLEtBQUssQ0FBQ2lCLElBQUksQ0FDaEUsVUFBQUMsSUFBQSxFQUFtRjtJQUFBLElBQWpGQyxHQUFHLEdBQUFELElBQUEsQ0FBSEMsR0FBRztNQUFFQyxRQUFRLEdBQUFGLElBQUEsQ0FBUkUsUUFBUTtNQUFFQyxNQUFNLEdBQUFILElBQUEsQ0FBTkcsTUFBTTtNQUFFQyxNQUFNLEdBQUFKLElBQUEsQ0FBTkksTUFBTTtNQUFFQyxZQUFZLEdBQUFMLElBQUEsQ0FBWkssWUFBWTtNQUFFQyxTQUFTLEdBQUFOLElBQUEsQ0FBVE0sU0FBUztNQUFFQyxtQkFBbUIsR0FBQVAsSUFBQSxDQUFuQk8sbUJBQW1CO0lBQzNFLElBQU1DLGNBQTZCLEdBQUd6QixPQUFPLENBQzNDO01BQUEsT0FBTXFCLE1BQU0sQ0FBQ0ssTUFBTSxDQUFDQyxHQUFHLENBQUMsVUFBQUMsQ0FBQztRQUFBLE9BQUlULFFBQVEsQ0FBQ1MsQ0FBQyxDQUFDO01BQUEsRUFBQztJQUFBLEdBQ3pDLENBQUNQLE1BQU0sRUFBRUYsUUFBUSxDQUNuQixDQUFDO0lBRUQsSUFBTVUsV0FBVyxHQUFHNUIsV0FBVyxDQUFDLFVBQUE2QixLQUFLO01BQUEsT0FBSVAsU0FBUyxDQUFDTCxHQUFHLEVBQUUsU0FBUyxFQUFFWSxLQUFLLENBQUM7SUFBQSxHQUFFLENBQUNQLFNBQVMsRUFBRUwsR0FBRyxDQUFDLENBQUM7SUFFNUYsSUFBTWEsU0FBUyxHQUFHdEIsR0FBRyxDQUFDWSxNQUFNLEVBQUUsQ0FBQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsQ0FBQyxFQUFFLElBQUksQ0FBQztJQUN6RSxJQUFNVyxXQUFXLEdBQUd2QixHQUFHLENBQUNZLE1BQU0sRUFBRSxDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxDQUFDLEVBQUUsU0FBUyxDQUFDO0lBRXpFLG9CQUNFdEIsS0FBQSxDQUFBa0MsYUFBQTtNQUFLQyxTQUFTLEVBQUM7SUFBc0IsZ0JBQ25DbkMsS0FBQSxDQUFBa0MsYUFBQSxDQUFDckIsaUJBQWlCO01BQUNPLFFBQVEsRUFBRU0sY0FBZTtNQUFDSixNQUFNLEVBQUVBLE1BQU87TUFBQ0MsWUFBWSxFQUFFQTtJQUFhLGdCQUN0RnZCLEtBQUEsQ0FBQWtDLGFBQUEsQ0FBQ3pCLGlCQUFpQixRQUFDLFFBQU0sRUFBQ3dCLFdBQStCLENBQUMsZUFDMURqQyxLQUFBLENBQUFrQyxhQUFBLENBQUNuQixpQkFBaUI7TUFDaEJxQixFQUFFLEVBQUVkLE1BQU0sQ0FBQ2MsRUFBRztNQUNkQyxPQUFPLEVBQUVaLG1CQUFvQjtNQUM3QmEsT0FBTyxFQUFFTixTQUFTLEdBQUcscUJBQXFCLEdBQUcscUJBQXNCO01BQ25FTyxhQUFhLEVBQUVQLFNBQVMsR0FBRzFCLE9BQU8sR0FBR0MsU0FBVTtNQUMvQ2lDLE1BQU0sRUFBRVI7SUFBVSxDQUNuQixDQUNnQixDQUFDLGVBQ3BCaEMsS0FBQSxDQUFBa0MsYUFBQSxDQUFDL0IsbUJBQW1CO01BQUNnQyxTQUFTLEVBQUM7SUFBdUIsZ0JBQ3BEbkMsS0FBQSxDQUFBa0MsYUFBQTtNQUFLQyxTQUFTLEVBQUM7SUFBc0IsZ0JBQ25DbkMsS0FBQSxDQUFBa0MsYUFBQSxDQUFDcEIsYUFBYTtNQUFDUSxNQUFNLEVBQUVBLE1BQU87TUFBQ0QsTUFBTSxFQUFFQSxNQUFPO01BQUNvQixTQUFTLEVBQUVYO0lBQVksQ0FBRSxDQUNyRSxDQUNjLENBQ2xCLENBQUM7RUFFVixDQUNGLENBQUM7RUFFRGQsa0JBQWtCLENBQUMwQixXQUFXLEdBQUcsb0JBQW9CO0VBRXJELE9BQU8xQixrQkFBa0I7QUFDM0I7QUFFQSxlQUFlTCx5QkFBeUIiLCJpZ25vcmVMaXN0IjpbXX0=