Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

feat(filters): support multiple datasets per filter (#3835)

Igor Dykhta2654322c8de8
diff --git a/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx b/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx
index 0b3a91823..ff076dcc9 100644
--- a/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx
+++ b/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx
@@ -5,25 +5,28 @@ 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';
import {FilterPanelWithFieldSelectComponent} from './types';
import {KeplerTable} from '@kepler.gl/table';
import FilterInvertToggle from '../filter-invert-toggle';
+import FilterSyncedDatasetPanelFactory from './filter-synced-dataset-panel';
+import TimeSyncedFieldSelectorFactory from './time-synced-field-selector';
FieldPanelWithFieldSelectFactory.deps = [
FilterPanelHeaderFactory,
- SourceDataSelectorFactory,
FieldSelectorFactory,
- PanelHeaderActionFactory
+ PanelHeaderActionFactory,
+ FilterSyncedDatasetPanelFactory,
+ TimeSyncedFieldSelectorFactory
];
function FieldPanelWithFieldSelectFactory(
FilterPanelHeader: ReturnType<typeof FilterPanelHeaderFactory>,
- SourceDataSelector: ReturnType<typeof SourceDataSelectorFactory>,
FieldSelector: ReturnType<typeof FieldSelectorFactory>,
- PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>
+ PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>,
+ FilterSyncedDatasetPanel: ReturnType<typeof FilterSyncedDatasetPanelFactory>,
+ TimeSyncedFieldSelector: ReturnType<typeof TimeSyncedFieldSelectorFactory>
) {
const FilterPanelWithFieldSelect: FilterPanelWithFieldSelectComponent = React.memo(
({
@@ -37,7 +40,7 @@ function FieldPanelWithFieldSelectFactory(
panelActions = []
}) => {
const onFieldSelector = useCallback(
- field => setFilter(idx, 'name', field.name),
+ (field, valueIndex = 0) => setFilter(idx, 'name', field.name, valueIndex),
[idx, setFilter]
);
@@ -56,16 +59,26 @@ function FieldPanelWithFieldSelectFactory(
() => getSupportedFilterFields(dataset.supportedFilterTypes, allAvailableFields),
[dataset.supportedFilterTypes, allAvailableFields]
);
+ const fieldType =
+ dataset.fields.find(field => field.name === fieldValue)?.type || filter.fieldType;
+ const isSynced = filter.dataId.length > 1;
+ const isInversionSupported = filter.dataId.every(
+ dataId => !datasets[dataId]?.disableDataOperation
+ );
return (
<>
<FilterPanelHeader datasets={[dataset]} filter={filter} removeFilter={removeFilter}>
- <FieldSelector
- inputTheme="secondary"
- fields={supportedFields}
- value={fieldValue}
- erasable={false}
- onSelect={onFieldSelector}
- />
+ {isSynced ? (
+ <TimeSyncedFieldSelector type={fieldType} />
+ ) : (
+ <FieldSelector
+ inputTheme="secondary"
+ fields={supportedFields}
+ value={fieldValue}
+ erasable={false}
+ onSelect={field => onFieldSelector(field, 0)}
+ />
+ )}
{panelActions.map(panelAction => (
<PanelHeaderAction
id={panelAction.id}
@@ -78,19 +91,20 @@ function FieldPanelWithFieldSelectFactory(
))}
</FilterPanelHeader>
<StyledFilterContent className="filter-panel__content">
- {Object.keys(datasets).length > 1 && (
- <SourceDataSelector
- inputTheme="secondary"
- datasets={datasets}
- dataId={filter.dataId}
- onSelect={onSourceDataSelector}
- />
- )}
+ <FilterSyncedDatasetPanel
+ datasets={datasets}
+ filter={filter}
+ idx={idx}
+ onFieldSelector={onFieldSelector}
+ onSourceDataSelector={onSourceDataSelector}
+ setFilter={setFilter}
+ showSourceDataSelector={Object.keys(datasets).length > 1}
+ />
<FilterInvertToggle
filter={filter}
idx={idx}
setFilter={setFilter}
- isSupported={!dataset.disableDataOperation}
+ isSupported={isInversionSupported}
/>
{children}
</StyledFilterContent>
diff --git a/src/components/src/filters/filter-panels/filter-synced-dataset-panel.spec.tsx b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.spec.tsx
new file mode 100644
index 000000000..2a379f096
--- /dev/null
+++ b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.spec.tsx
@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import {fireEvent, screen} from '@testing-library/react';
+
+import {ALL_FIELD_TYPES, FILTER_TYPES} from '@kepler.gl/constants';
+import {renderWithTheme} from 'test/helpers/component-jest-utils';
+
+// Break DatasetTag's package-index cycle when testing these factories directly.
+jest.mock('../../side-panel/common/dataset-tag', () => () => () => null);
+
+import FilterSyncedDatasetPanelFactory, {
+ DatasetItemFactory,
+ SyncedDatasetButtonFactory
+} from './filter-synced-dataset-panel';
+import FieldPanelWithFieldSelectFactory from './filter-panel-with-field-select';
+
+const MockDatasetItem = ({dataId, datasets, fields, index, onFieldSelector, addButton}) => (
+ <div
+ data-testid={`dataset-${dataId}`}
+ data-datasets={Object.keys(datasets).join(',')}
+ data-fields={fields.map(field => field.name).join(',')}
+ >
+ {fields.map(field => (
+ <button key={field.name} onClick={() => onFieldSelector(field, index)}>
+ {field.name}
+ </button>
+ ))}
+ {addButton}
+ </div>
+);
+const MockLayerTimeline = () => <div data-testid="layer-timeline" />;
+const MockSourceDataSelector = () => <div data-testid="source-data-selector" />;
+const MockSyncedDatasetButton = ({onAddSyncedFilter}) => (
+ <button onClick={onAddSyncedFilter}>Sync dataset</button>
+);
+const MockSyncLayerTimelineButton = () => <div data-testid="sync-layer-timeline" />;
+
+const FilterSyncedDatasetPanel = FilterSyncedDatasetPanelFactory(
+ MockDatasetItem,
+ MockLayerTimeline,
+ MockSourceDataSelector,
+ MockSyncedDatasetButton,
+ MockSyncLayerTimelineButton
+);
+
+const integerField = name => ({name, type: ALL_FIELD_TYPES.integer});
+const realField = name => ({name, type: ALL_FIELD_TYPES.real});
+const stringField = name => ({name, type: ALL_FIELD_TYPES.string});
+
+const datasets = {
+ first: {
+ id: 'first',
+ fields: [integerField('count')],
+ supportedFilterTypes: [ALL_FIELD_TYPES.integer]
+ },
+ incompatible: {
+ id: 'incompatible',
+ fields: [stringField('count')],
+ supportedFilterTypes: [ALL_FIELD_TYPES.string]
+ },
+ second: {
+ id: 'second',
+ fields: [integerField('amount'), realField('ratio')],
+ supportedFilterTypes: [ALL_FIELD_TYPES.integer, ALL_FIELD_TYPES.real]
+ },
+ realOnly: {
+ id: 'realOnly',
+ fields: [realField('count'), realField('ratio')],
+ supportedFilterTypes: [ALL_FIELD_TYPES.real]
+ },
+ third: {
+ id: 'third',
+ fields: [integerField('count')],
+ supportedFilterTypes: [ALL_FIELD_TYPES.integer]
+ }
+};
+
+const defaultProps = {
+ datasets,
+ filter: {
+ id: 'filter',
+ dataId: ['first'],
+ name: ['count'],
+ fieldType: ALL_FIELD_TYPES.integer,
+ type: FILTER_TYPES.range
+ },
+ idx: 2,
+ setFilter: jest.fn(),
+ onFieldSelector: jest.fn(),
+ onSourceDataSelector: jest.fn()
+};
+
+describe('FilterSyncedDatasetPanel', () => {
+ test('places the add control beside the current data source', () => {
+ renderWithTheme(<FilterSyncedDatasetPanel {...defaultProps} />);
+
+ expect(screen.getByTestId('source-data-selector').parentElement).toBe(
+ screen.getByRole('button', {name: 'Sync dataset'}).parentElement
+ );
+ });
+
+ test('waits for a field selection when multiple compatible fields do not match by name', () => {
+ const setFilter = jest.fn();
+ renderWithTheme(<FilterSyncedDatasetPanel {...defaultProps} setFilter={setFilter} />);
+
+ fireEvent.click(screen.getByRole('button', {name: 'Sync dataset'}));
+
+ expect(setFilter).not.toHaveBeenCalled();
+ expect(screen.getByTestId('dataset-second')).toHaveAttribute('data-fields', 'amount,ratio');
+
+ fireEvent.click(screen.getByRole('button', {name: 'ratio'}));
+
+ expect(setFilter).toHaveBeenCalledWith(2, ['dataId', 'name'], ['second', 'ratio'], 1);
+ });
+
+ test('automatically uses an exact-name field across compatible numeric types', () => {
+ const setFilter = jest.fn();
+ renderWithTheme(
+ <FilterSyncedDatasetPanel
+ {...defaultProps}
+ datasets={{first: datasets.first, realOnly: datasets.realOnly}}
+ setFilter={setFilter}
+ />
+ );
+
+ fireEvent.click(screen.getByRole('button', {name: 'Sync dataset'}));
+
+ expect(setFilter).toHaveBeenCalledWith(2, ['dataId', 'name'], ['realOnly', 'count'], 1);
+ });
+
+ test('limits synced rows to compatible fields and unselected datasets', () => {
+ const filter = {
+ ...defaultProps.filter,
+ dataId: ['first', 'second'],
+ name: ['count', 'amount']
+ };
+ renderWithTheme(<FilterSyncedDatasetPanel {...defaultProps} filter={filter} />);
+
+ expect(screen.getByTestId('dataset-first')).toHaveAttribute(
+ 'data-datasets',
+ 'first,realOnly,third'
+ );
+ expect(screen.getByTestId('dataset-first')).toHaveAttribute('data-fields', 'count');
+ expect(screen.getByTestId('dataset-second')).toHaveAttribute(
+ 'data-datasets',
+ 'second,realOnly,third'
+ );
+ expect(screen.getByTestId('dataset-second')).toHaveAttribute('data-fields', 'amount,ratio');
+ expect(screen.getByTestId('dataset-second')).toContainElement(
+ screen.getByRole('button', {name: 'Sync dataset'})
+ );
+ expect(screen.queryByTestId('sync-layer-timeline')).not.toBeInTheDocument();
+ });
+});
+
+describe('SyncedDatasetButton', () => {
+ const SyncedDatasetButton = SyncedDatasetButtonFactory();
+
+ test('renders a centered accessible icon without a filled button treatment', () => {
+ const onAddSyncedFilter = jest.fn();
+ renderWithTheme(<SyncedDatasetButton onAddSyncedFilter={onAddSyncedFilter} />);
+
+ const button = screen.getByRole('button', {
+ name: 'Add synced filter'
+ });
+ expect(button).toHaveTextContent('');
+ expect(button).toHaveStyle({
+ width: '16px',
+ height: '34px',
+ marginLeft: '4px',
+ padding: '0px',
+ alignItems: 'center',
+ justifyContent: 'center',
+ background: 'transparent',
+ border: '0px'
+ });
+ expect(button.querySelector('svg')).toHaveAttribute('height', '16px');
+ expect(button.querySelector('svg')).toHaveStyle({marginRight: '0px'});
+
+ fireEvent.click(button);
+ expect(onAddSyncedFilter).toHaveBeenCalledTimes(1);
+ });
+});
+
+describe('DatasetItem', () => {
+ const MockSourceSelector = ({className}) => (
+ <div className={className} data-testid="synced-source-selector" />
+ );
+ const MockPanelHeaderAction = ({tooltip, onClick, IconComponent}) => (
+ <button aria-label={tooltip} onClick={onClick}>
+ <IconComponent />
+ </button>
+ );
+ const DatasetItem = DatasetItemFactory(MockSourceSelector, MockPanelHeaderAction);
+
+ test('shows only the delete action for a synced dataset source', () => {
+ const onRemoveSyncedFilter = jest.fn();
+ renderWithTheme(
+ <DatasetItem
+ dataId="second"
+ datasets={datasets}
+ fields={datasets.second.fields}
+ filter={{...defaultProps.filter, dataId: ['first', 'second']}}
+ index={1}
+ onRemoveSyncedFilter={onRemoveSyncedFilter}
+ filterDatasetsNum={2}
+ compatibleDatasetsNum={3}
+ onSelectSyncedDataset={jest.fn()}
+ onFieldSelector={jest.fn()}
+ addButton={null}
+ />
+ );
+
+ const sourceSelector = screen.getByTestId('synced-source-selector');
+ expect(sourceSelector).toHaveStyle({minWidth: '0', overflow: 'hidden'});
+ expect(sourceSelector.parentElement).toHaveStyle({width: '100%', minWidth: '0'});
+ expect(screen.queryByRole('button', {name: 'tooltip.editFilterJson'})).not.toBeInTheDocument();
+
+ fireEvent.click(screen.getByRole('button', {name: 'tooltip.delete'}));
+ expect(onRemoveSyncedFilter).toHaveBeenCalledWith(1);
+ });
+});
+
+describe('FilterPanelWithFieldSelect', () => {
+ const MockFilterPanelHeader = ({children}) => <div>{children}</div>;
+ const MockFieldSelector = () => <div data-testid="field-selector" />;
+ const MockPanelHeaderAction = () => null;
+ const MockFilterSyncedDatasetPanel = () => <div data-testid="synced-dataset-panel" />;
+ const MockSyncedFieldSelector = ({type}) => <div data-testid="synced-field">{type}</div>;
+
+ const FilterPanelWithFieldSelect = FieldPanelWithFieldSelectFactory(
+ MockFilterPanelHeader as any,
+ MockFieldSelector as any,
+ MockPanelHeaderAction as any,
+ MockFilterSyncedDatasetPanel as any,
+ MockSyncedFieldSelector as any
+ );
+
+ test('uses the synced dataset UI for a non-time filter', () => {
+ const filter = {
+ ...defaultProps.filter,
+ dataId: ['first', 'second'],
+ name: ['count', 'amount'],
+ enabled: true,
+ inverted: false
+ };
+
+ renderWithTheme(
+ <FilterPanelWithFieldSelect
+ allAvailableFields={datasets.first.fields as any}
+ datasets={datasets as any}
+ filter={filter as any}
+ idx={0}
+ removeFilter={jest.fn()}
+ setFilter={jest.fn()}
+ >
+ <div />
+ </FilterPanelWithFieldSelect>
+ );
+
+ expect(screen.getByTestId('synced-field')).toHaveTextContent(ALL_FIELD_TYPES.integer);
+ expect(screen.getByTestId('synced-dataset-panel')).toBeInTheDocument();
+ expect(screen.queryByTestId('field-selector')).not.toBeInTheDocument();
+ });
+});
diff --git a/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx
index 23826f01d..cba2fba33 100644
--- a/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx
+++ b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx
@@ -1,17 +1,18 @@
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
-import React, {useCallback, useMemo} from 'react';
+import React, {useCallback, useMemo, useState} from 'react';
+import {useIntl} from 'react-intl';
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 {FILTER_TYPES} from '@kepler.gl/constants';
+import {areFilterFieldTypesCompatible, 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 PanelHeaderActionFactory from '../../side-panel/panel-header-action';
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';
@@ -46,24 +47,91 @@ const StyledButton = styled(Button)`
padding: 2px;
`;
-function getDatasetsWithTimeField(datasets) {
+const StyledIconButton = styled.button`
+ appearance: none;
+ align-items: center;
+ background: transparent;
+ border: 0;
+ color: ${props => props.theme.panelHeaderIcon};
+ cursor: pointer;
+ display: inline-flex;
+ justify-content: center;
+ width: 16px;
+ height: ${props => props.theme.inputBoxHeight};
+ margin: 0 0 0 4px;
+ padding: 0;
+ flex: 0 0 auto;
+
+ &:hover,
+ &:focus {
+ color: ${props => props.theme.panelHeaderIconHover};
+ }
+
+ svg {
+ margin-right: 0;
+ }
+`;
+
+const StyledSourceDataRow = styled.div`
+ display: flex;
+ align-items: flex-end;
+
+ .data-source-selector {
+ flex: 1;
+ min-width: 0;
+ }
+`;
+
+function getFilterFieldType(datasets, filter) {
+ const firstDataset = datasets[filter.dataId[0]];
+ const firstField = firstDataset?.fields.find(field => field.name === filter.name[0]);
+
+ return firstField?.type || filter.fieldType;
+}
+
+function getFieldsByType(dataset, fieldType) {
+ if (!dataset || !fieldType) {
+ return [];
+ }
+
+ return dataset.fields.filter(
+ field =>
+ areFilterFieldTypesCompatible(fieldType, field.type) &&
+ (!dataset.supportedFilterTypes || dataset.supportedFilterTypes.includes(field.type))
+ );
+}
+
+function getDatasetsWithFieldType(datasets, fieldType) {
const rv = {};
for (const id of Object.keys(datasets)) {
- // TODO: change to
- if (datasets[id].fields.some(f => f.type === ALL_FIELD_TYPES.timestamp)) {
+ if (getFieldsByType(datasets[id], fieldType).length) {
rv[id] = datasets[id];
}
}
return rv;
}
-function getTimeFields(dataset) {
- return dataset.fields.filter(f => f.type === ALL_FIELD_TYPES.timestamp);
+function getSelectableDatasets(datasets, compatibleDatasets, filterDataIds, currentDataId) {
+ const selectableDatasets = {};
+ for (const id of Object.keys(compatibleDatasets)) {
+ if (id === currentDataId || !filterDataIds.includes(id)) {
+ selectableDatasets[id] = compatibleDatasets[id];
+ }
+ }
+
+ // Keep malformed or legacy selections visible so users can repair them.
+ if (datasets[currentDataId] && !selectableDatasets[currentDataId]) {
+ selectableDatasets[currentDataId] = datasets[currentDataId];
+ }
+
+ return selectableDatasets;
}
-function DatasetItemFactory(SourceSelector, FilterPanelHeader) {
- const StyledFilterPanelHeader = styled(FilterPanelHeader)`
+export function DatasetItemFactory(SourceSelector, PanelHeaderAction) {
+ const StyledDatasetItemHeader = styled.div`
display: flex;
+ width: 100%;
+ min-width: 0;
border: none;
height: unset;
padding: 2px 0;
@@ -73,6 +141,8 @@ function DatasetItemFactory(SourceSelector, FilterPanelHeader) {
const StyledSourceSelector = styled(SourceSelector)`
flex: 1;
+ min-width: 0;
+ overflow: hidden;
-webkit-border-radius: 8px;
-moz-border-radius: 8px;
border-radius: 8px;
@@ -83,42 +153,45 @@ function DatasetItemFactory(SourceSelector, FilterPanelHeader) {
const DatasetItem = ({
dataId,
datasets,
- supportedFields,
- idx,
+ fields,
filter,
index,
onRemoveSyncedFilter,
filterDatasetsNum,
- datasetsWithTimeNum,
+ compatibleDatasetsNum,
onSelectSyncedDataset,
- onFieldSelector
+ onFieldSelector,
+ addButton
}) => (
<div>
<StyledSeparator />
- <StyledFilterPanelHeader
- datasets={[datasets[dataId]]}
- allAvailableFields={supportedFields}
- idx={idx}
- filter={filter}
- removeFilter={() => onRemoveSyncedFilter(index)}
- >
+ <StyledDatasetItemHeader>
<StyledSourceSelector
datasets={datasets}
- disabled={filterDatasetsNum >= datasetsWithTimeNum}
+ disabled={filterDatasetsNum >= compatibleDatasetsNum}
dataId={dataId}
onSelectDataset={datasetId => onSelectSyncedDataset(datasetId, index)}
- fields={getTimeFields(datasets[dataId])}
+ fields={fields}
fieldValue={filter.name[index]}
onFieldSelector={field => onFieldSelector(field, index)}
/>
- </StyledFilterPanelHeader>
+ {addButton}
+ <PanelHeaderAction
+ id={`${filter.id}-${dataId}`}
+ tooltip="tooltip.delete"
+ tooltipType="error"
+ hoverColor="errorColor"
+ onClick={() => onRemoveSyncedFilter(index)}
+ IconComponent={Trash}
+ />
+ </StyledDatasetItemHeader>
</div>
);
return DatasetItem;
}
-DatasetItemFactory.deps = [SourceSelectorFactory, FilterPanelHeaderFactory];
+DatasetItemFactory.deps = [SourceSelectorFactory, PanelHeaderActionFactory];
const StyledLayerTimeline = styled.div`
display: flex;
@@ -155,26 +228,27 @@ function LayerTimelineFactory(LayerTypeListItem) {
LayerTimelineFactory.deps = [LayerTypeListItemFactory];
-function SyncedDatasetButtonFactory() {
- const SyncedDatasetButton = ({onAddSyncedFilter}) => (
- <div>
- <StyledSeparator />
- <TippyTooltip
- delay={[500, 0]}
- placement="top"
- render={() => (
- <div>
- <FormattedMessage id={'tooltip.timeFilterSync'} />
- </div>
- )}
- >
- <StyledButton className="add-sync-dataset" secondary={true} onClick={onAddSyncedFilter}>
- <Add height="12px" />
- <FormattedMessage id={'filterManager.timeFilterSync'} />
- </StyledButton>
+export function SyncedDatasetButtonFactory() {
+ const SyncedDatasetButton = ({onAddSyncedFilter}) => {
+ const intl = useIntl();
+ const label = intl.formatMessage({
+ id: 'tooltip.timeFilterSync',
+ defaultMessage: 'Add synced filter'
+ });
+
+ return (
+ <TippyTooltip delay={[500, 0]} placement="top" render={() => <div>{label}</div>}>
+ <StyledIconButton
+ aria-label={label}
+ className="add-sync-dataset"
+ type="button"
+ onClick={onAddSyncedFilter}
+ >
+ <Add height="16px" />
+ </StyledIconButton>
</TippyTooltip>
- </div>
- );
+ );
+ };
return SyncedDatasetButton;
}
@@ -203,6 +277,18 @@ function SyncLayerTimelineButtonFactory() {
return SyncLayerTimelineButton;
}
+type FilterSyncedDatasetPanelProps = {
+ datasets: Record<string, any>;
+ layers?: ReadonlyArray<any>;
+ filter: any;
+ setFilter: (...args: any[]) => void;
+ idx: number;
+ onFieldSelector: (...args: any[]) => void;
+ onSourceDataSelector: (...args: any[]) => void;
+ syncTimeFilterWithLayerTimeline?: (idx: number, enable: boolean) => void;
+ showSourceDataSelector?: boolean;
+};
+
function FilterSyncedDatasetPanelFactory(
DatasetItem,
LayerTimeline,
@@ -212,20 +298,25 @@ function FilterSyncedDatasetPanelFactory(
) {
const FilterSyncedDatasetPanel = ({
datasets,
- layers,
+ layers = [],
filter,
setFilter,
idx,
- supportedFields,
onFieldSelector,
onSourceDataSelector,
- syncTimeFilterWithLayerTimeline
- }) => {
- const datasetsWithTime = useMemo(() => getDatasetsWithTimeField(datasets), [datasets]);
+ syncTimeFilterWithLayerTimeline,
+ showSourceDataSelector = true
+ }: FilterSyncedDatasetPanelProps) => {
+ const [pendingDataId, setPendingDataId] = useState<string | null>(null);
+ const fieldType = useMemo(() => getFilterFieldType(datasets, filter), [datasets, filter]);
+ const compatibleDatasets = useMemo(
+ () => getDatasetsWithFieldType(datasets, fieldType),
+ [datasets, fieldType]
+ );
const filterDatasetsNum = useMemo(() => filter.dataId.length, [filter.dataId]);
- const datasetsWithTimeNum = useMemo(
- () => Object.keys(datasetsWithTime).length,
- [datasetsWithTime]
+ const compatibleDatasetsNum = useMemo(
+ () => Object.keys(compatibleDatasets).length,
+ [compatibleDatasets]
);
const onRemoveSyncedFilter = useCallback(
@@ -243,27 +334,58 @@ function FilterSyncedDatasetPanelFactory(
);
const onAddSyncedFilter = useCallback(() => {
- const nextId = Object.keys(datasetsWithTime).find(id => !filter.dataId.includes(id));
+ const nextId = Object.keys(compatibleDatasets).find(id => !filter.dataId.includes(id));
if (!nextId) return;
- const timeFieldNames = getTimeFields(datasets[nextId])?.map(f => f.name);
- if (!timeFieldNames || timeFieldNames.length < 1) return;
- const 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]);
+ const fieldNames = getFieldsByType(datasets[nextId], fieldType).map(field => field.name);
+ if (!fieldNames.length) return;
+ const matchingName = fieldNames.find(fieldName => fieldName === filter.name[0]);
+ if (matchingName || fieldNames.length === 1) {
+ setFilter(
+ idx,
+ ['dataId', 'name'],
+ [nextId, matchingName || fieldNames[0]],
+ filter.dataId.length
+ );
+ } else {
+ setPendingDataId(nextId);
+ }
+ }, [setFilter, idx, compatibleDatasets, datasets, fieldType, filter.dataId, filter.name]);
+
+ const onSelectPendingDataset = useCallback(datasetId => setPendingDataId(datasetId), []);
+
+ const onSelectPendingField = useCallback(
+ field => {
+ if (!pendingDataId) return;
+ setFilter(idx, ['dataId', 'name'], [pendingDataId, field.name], filter.dataId.length);
+ setPendingDataId(null);
+ },
+ [filter.dataId.length, idx, pendingDataId, setFilter]
+ );
+
+ const onCancelPendingDataset = useCallback(() => setPendingDataId(null), []);
const onSyncLayerTimeline = useCallback(
- () => syncTimeFilterWithLayerTimeline(idx, true),
+ () => syncTimeFilterWithLayerTimeline?.(idx, true),
[syncTimeFilterWithLayerTimeline, idx]
);
const onRemoveSyncWithLayerTimeline = useCallback(
- () => syncTimeFilterWithLayerTimeline(idx, false),
+ () => syncTimeFilterWithLayerTimeline?.(idx, false),
[syncTimeFilterWithLayerTimeline, idx]
);
- const animatableLayers = useMemo(() => getAnimatableVisibleLayers(layers), [layers]);
+ const isTimeRange = filter.type === FILTER_TYPES.timeRange;
+ const animatableLayers = useMemo(
+ () => (isTimeRange ? getAnimatableVisibleLayers([...layers]) : []),
+ [isTimeRange, layers]
+ );
- const isLinkedWithLayerTimeline = useMemo(() => filter.syncedWithLayerTimeline, [filter]);
+ const isLinkedWithLayerTimeline = isTimeRange && filter.syncedWithLayerTimeline;
+ const activePendingDataId =
+ pendingDataId && compatibleDatasets[pendingDataId] && !filter.dataId.includes(pendingDataId)
+ ? pendingDataId
+ : null;
+ const canAddSyncedDataset = !activePendingDataId && filterDatasetsNum < compatibleDatasetsNum;
return (
<SyncedDatasetsArea>
@@ -271,49 +393,79 @@ function FilterSyncedDatasetPanelFactory(
<>
<StyledContentTitle>Datasets</StyledContentTitle>
{filter.dataId.map((dataId, index) => {
+ const selectableDatasets = getSelectableDatasets(
+ datasets,
+ compatibleDatasets,
+ filter.dataId,
+ dataId
+ );
return (
<DatasetItem
- key={dataId}
+ key={`${dataId}-${index}`}
dataId={dataId}
index={index}
- datasets={datasets}
- supportedFields={supportedFields}
+ datasets={selectableDatasets}
+ fields={getFieldsByType(datasets[dataId], fieldType)}
idx={idx}
filter={filter}
onRemoveSyncedFilter={onRemoveSyncedFilter}
filterDatasetsNum={filterDatasetsNum}
- datasetsWithTimeNum={datasetsWithTimeNum}
+ compatibleDatasetsNum={compatibleDatasetsNum}
onSelectSyncedDataset={onSelectSyncedDataset}
onFieldSelector={onFieldSelector}
+ addButton={
+ canAddSyncedDataset && index === filter.dataId.length - 1 ? (
+ <SyncedDatasetButton onAddSyncedFilter={onAddSyncedFilter} />
+ ) : null
+ }
/>
);
})}
</>
- ) : (
- <>
+ ) : showSourceDataSelector ? (
+ <StyledSourceDataRow>
<SourceDataSelector
inputTheme="secondary"
datasets={datasets}
dataId={Array.isArray(filter.dataId) ? filter.dataId[0] : filter.dataId}
onSelect={onSourceDataSelector}
/>
- </>
- )}
- {/** sync with animatable layers */}
- {isLinkedWithLayerTimeline ? (
- <>
- <StyledSeparator />
- <LayerTimeline layers={animatableLayers} onDelete={onRemoveSyncWithLayerTimeline} />
- </>
- ) : (
- <>
- {animatableLayers.length ? (
- <SyncLayerTimelineButton onSyncLayerTimeline={onSyncLayerTimeline} />
+ {canAddSyncedDataset ? (
+ <SyncedDatasetButton onAddSyncedFilter={onAddSyncedFilter} />
) : null}
- </>
- )}
- {filterDatasetsNum < datasetsWithTimeNum ? (
- <SyncedDatasetButton onAddSyncedFilter={onAddSyncedFilter} />
+ </StyledSourceDataRow>
+ ) : null}
+ {activePendingDataId ? (
+ <DatasetItem
+ key={`pending-${activePendingDataId}`}
+ dataId={activePendingDataId}
+ index={filter.dataId.length}
+ datasets={getSelectableDatasets(
+ datasets,
+ compatibleDatasets,
+ filter.dataId,
+ activePendingDataId
+ )}
+ fields={getFieldsByType(datasets[activePendingDataId], fieldType)}
+ idx={idx}
+ filter={filter}
+ onRemoveSyncedFilter={onCancelPendingDataset}
+ filterDatasetsNum={filterDatasetsNum}
+ compatibleDatasetsNum={compatibleDatasetsNum}
+ onSelectSyncedDataset={onSelectPendingDataset}
+ onFieldSelector={onSelectPendingField}
+ />
+ ) : null}
+ {/** sync time filters with animatable layers */}
+ {isTimeRange && syncTimeFilterWithLayerTimeline ? (
+ isLinkedWithLayerTimeline ? (
+ <>
+ <StyledSeparator />
+ <LayerTimeline layers={animatableLayers} onDelete={onRemoveSyncWithLayerTimeline} />
+ </>
+ ) : animatableLayers.length ? (
+ <SyncLayerTimelineButton onSyncLayerTimeline={onSyncLayerTimeline} />
+ ) : null
) : null}
</SyncedDatasetsArea>
);
diff --git a/src/components/src/filters/filter-panels/time-range-filter-panel.tsx b/src/components/src/filters/filter-panels/time-range-filter-panel.tsx
index 7053e4d1f..d2dd0b568 100644
--- a/src/components/src/filters/filter-panels/time-range-filter-panel.tsx
+++ b/src/components/src/filters/filter-panels/time-range-filter-panel.tsx
@@ -167,7 +167,6 @@ function TimeRangeFilterPanelFactory(
onFieldSelector={onFieldSelector}
onSourceDataSelector={onSourceDataSelector}
setFilter={setFilter}
- supportedFields={supportedFields}
syncTimeFilterWithLayerTimeline={syncTimeFilterWithLayerTimeline}
/>
{!isSynced && endTimeFields.length ? (
diff --git a/src/components/src/filters/filter-panels/time-synced-field-selector.tsx b/src/components/src/filters/filter-panels/time-synced-field-selector.tsx
index f7f8f7d2f..3e9b9b1af 100644
--- a/src/components/src/filters/filter-panels/time-synced-field-selector.tsx
+++ b/src/components/src/filters/filter-panels/time-synced-field-selector.tsx
@@ -21,9 +21,9 @@ const StyledSyncTimeHeader = styled.div`
TimeSyncedFieldSelectorFactory.deps = [FieldTokenFactory];
function TimeSyncedFieldSelectorFactory(FieldToken) {
- const TimeSyncedFieldSelector = () => (
+ const TimeSyncedFieldSelector = ({type = ALL_FIELD_TYPES.timestamp}: {type?: string}) => (
<StyledSyncTimeHeader>
- <FieldToken type={ALL_FIELD_TYPES.timestamp} />
+ <FieldToken type={type} />
<span>Synced</span>
</StyledSyncTimeHeader>
);
diff --git a/src/localization/src/translations/en.ts b/src/localization/src/translations/en.ts
index 50313c7cd..8a40c40ff 100644
--- a/src/localization/src/translations/en.ts
+++ b/src/localization/src/translations/en.ts
@@ -600,7 +600,7 @@ export default {
removeBaseMapStyle: 'Remove base map style',
delete: 'Delete',
timePlayback: 'Time Playback',
- timeFilterSync: 'Sync with a column from another dataset',
+ timeFilterSync: 'Add synced filter',
cloudStorage: 'Cloud Storage',
'3DMap': '3D Map',
animationByWindow: 'Moving Time Window',
diff --git a/src/reducers/src/vis-state-updaters.ts b/src/reducers/src/vis-state-updaters.ts
index a140b816e..97f1e26af 100644
--- a/src/reducers/src/vis-state-updaters.ts
+++ b/src/reducers/src/vis-state-updaters.ts
@@ -1700,7 +1700,7 @@ function _updateFilterProp(state, filter, prop, value, valueIndex, datasetIds?)
datasetId,
value,
valueIndex,
- {mergeDomain: valueIndex > 0}
+ {mergeDomain: filter.dataId.length > 1}
);
if (updatedFilter) {
filter = updatedFilter;
diff --git a/src/utils/src/filter-utils.ts b/src/utils/src/filter-utils.ts
index fda2f69ae..d0ece6939 100644
--- a/src/utils/src/filter-utils.ts
+++ b/src/utils/src/filter-utils.ts
@@ -508,6 +508,25 @@ export function getFilterProps(
}
}
+/**
+ * Returns whether two field types can share the same filter value and domain.
+ */
+export function areFilterFieldTypesCompatible(
+ fieldType?: string | null,
+ candidateFieldType?: string | null
+): boolean {
+ if (!fieldType || !candidateFieldType) {
+ return false;
+ }
+
+ if (fieldType === candidateFieldType) {
+ return true;
+ }
+
+ const numericFieldTypes: string[] = [ALL_FIELD_TYPES.integer, ALL_FIELD_TYPES.real];
+ return numericFieldTypes.includes(fieldType) && numericFieldTypes.includes(candidateFieldType);
+}
+
function hasFiniteLngLat(pos: unknown): pos is number[] {
if (pos == null || !(Array.isArray(pos) || ArrayBuffer.isView(pos))) {
return false;
@@ -1318,6 +1337,7 @@ export function applyFilterFieldName<K extends KeplerTableModel<K, L>, L>(
let newFilter = {
...filter,
...filterProps,
+ ...(filterDatasetIndex > 0 && filter.fieldType ? {fieldType: filter.fieldType} : {}),
name: Object.assign([...toArray(filter.name)], {[filterDatasetIndex]: fieldName}),
fieldIdx: Object.assign([...toArray(filter.fieldIdx)], {
[filterDatasetIndex]: fieldIndex
@@ -1509,7 +1529,10 @@ export function mergeFilterDomainStep(
return filter;
}
- if ((filter.fieldType && filter.fieldType !== filterProps.fieldType) || !filterProps.domain) {
+ if (
+ (filter.fieldType && !areFilterFieldTypesCompatible(filter.fieldType, filterProps.fieldType)) ||
+ !filterProps.domain
+ ) {
return filter;
}
@@ -1520,6 +1543,7 @@ export function mergeFilterDomainStep(
const newFilter = {
...filter,
...filterProps,
+ ...(filter.fieldType ? {fieldType: filter.fieldType} : {}),
// use min max as default domain
domain: [sortedDomain[0], sortedDomain[sortedDomain.length - 1]]
};
@@ -1545,7 +1569,13 @@ export function mergeFilterDomainStep(
};
}
case ALL_FIELD_TYPES.real:
- case ALL_FIELD_TYPES.integer:
+ case ALL_FIELD_TYPES.integer: {
+ const steps = [
+ 'step' in filter ? filter.step : undefined,
+ 'step' in filterProps ? filterProps.step : undefined
+ ].filter((step): step is number => typeof step === 'number');
+ return steps.length ? {...newFilter, step: Math.min(...steps)} : newFilter;
+ }
default:
return newFilter;
}
diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.js
index 8b14e576d..e0902f6fb 100644
--- a/test/node/reducers/vis-state-test.js
+++ b/test/node/reducers/vis-state-test.js
@@ -2774,6 +2774,42 @@ test('#visStateReducer -> SET_FILTER.name', t => {
t.end();
});
+test('#visStateReducer -> SET_FILTER.name merges synced domains when changing first field', async t => {
+ const firstDataset = await createNewDataEntryMock({
+ info: {id: 'first', label: 'first'},
+ data: {
+ fields: [
+ {name: 'initial', type: ALL_FIELD_TYPES.integer},
+ {name: 'replacement', type: ALL_FIELD_TYPES.integer}
+ ],
+ rows: [
+ [0, 0],
+ [10, 20]
+ ]
+ }
+ });
+ const secondDataset = await createNewDataEntryMock({
+ info: {id: 'second', label: 'second'},
+ data: {
+ fields: [{name: 'amount', type: ALL_FIELD_TYPES.real}],
+ rows: [[100], [100.5]]
+ }
+ });
+ let state = {
+ ...INITIAL_VIS_STATE,
+ datasets: {...firstDataset, ...secondDataset}
+ };
+
+ state = reducer(state, VisStateActions.addFilter('first'));
+ state = reducer(state, VisStateActions.setFilter(0, 'name', 'initial'));
+ state = reducer(state, VisStateActions.setFilter(0, ['dataId', 'name'], ['second', 'amount'], 1));
+ state = reducer(state, VisStateActions.setFilter(0, 'name', 'replacement', 0));
+
+ t.deepEqual(state.filters[0].domain, [0, 100.5], 'keeps both synced datasets in the domain');
+ t.equal(state.filters[0].step, 0.0001, 'keeps the finest synced dataset step');
+ t.end();
+});
+
test('#visStateReducer -> SET_FILTER.inverted', t => {
const oldState = CloneDeep(StateWFilters.visState);
const dataId = testGeoJsonDataId;
diff --git a/test/node/utils/filter-utils-test.js b/test/node/utils/filter-utils-test.js
index 5d59b1881..38e0b0acc 100644
--- a/test/node/utils/filter-utils-test.js
+++ b/test/node/utils/filter-utils-test.js
@@ -25,10 +25,12 @@ import {
applyTimeFilterEndFieldName,
validateFilterWithData,
disableGpuIfInverted,
- getPlotBaseIndexByDataId
+ getPlotBaseIndexByDataId,
+ areFilterFieldTypesCompatible,
+ mergeFilterDomainStep
} from '@kepler.gl/utils';
-import {FILTER_TYPES} from '@kepler.gl/constants';
+import {ALL_FIELD_TYPES, FILTER_TYPES} from '@kepler.gl/constants';
import {mockPolygonFeature, mockPolygonData} from '../../fixtures/polygon';
/* eslint-disable max-statements */
@@ -135,6 +137,39 @@ test('filterUtils -> adjustValueToFilterDomain', t => {
t.end();
});
+test('filterUtils -> compatible numeric filter field types', t => {
+ t.ok(
+ areFilterFieldTypesCompatible(ALL_FIELD_TYPES.integer, ALL_FIELD_TYPES.real),
+ 'integer filters accept real fields'
+ );
+ t.ok(
+ areFilterFieldTypesCompatible(ALL_FIELD_TYPES.real, ALL_FIELD_TYPES.integer),
+ 'real filters accept integer fields'
+ );
+ t.notOk(
+ areFilterFieldTypesCompatible(ALL_FIELD_TYPES.integer, ALL_FIELD_TYPES.string),
+ 'numeric filters reject string fields'
+ );
+
+ const merged = mergeFilterDomainStep(
+ {
+ fieldType: ALL_FIELD_TYPES.real,
+ domain: [0.25, 1.5],
+ step: 0.25
+ },
+ {
+ fieldType: ALL_FIELD_TYPES.integer,
+ domain: [-1, 3],
+ step: 1
+ }
+ );
+
+ t.deepEqual(merged.domain, [-1, 3], 'merges integer and real domains');
+ t.equal(merged.fieldType, ALL_FIELD_TYPES.real, 'keeps the first field type');
+ t.equal(merged.step, 0.25, 'keeps the finest numeric step');
+ t.end();
+});
+
test('filterUtils -> getDatasetFieldIndexForFilter', t => {
const dataId = 'test-this-id';