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.tsxindex 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 => (<PanelHeaderActionid={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}+ /><FilterInvertTogglefilter={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.tsxnew file mode 100644index 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.tsxindex 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><StyledSourceSelectordatasets={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><SourceDataSelectorinputTheme="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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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 domaindomain: [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.jsindex 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.jsindex 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';