Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
feat(layers): animate point pulses from timestamp filters (#3971)
Igor Dykhta6ed144a3b37d
diff --git a/docs/user-guides/c-types-of-layers/a-point.md b/docs/user-guides/c-types-of-layers/a-point.mdindex 4ad07d309..0048cf994 100644--- a/docs/user-guides/c-types-of-layers/a-point.md+++ b/docs/user-guides/c-types-of-layers/a-point.md@@ -52,4 +52,23 @@ Enable **Pulse / Ripple** to animate the points.The effect loops continuously while the layer is visible; it does not require a timestamp field or timeline playback. It uses the point layer's colors, sizes, opacity, filters, and map or billboard orientation. Text labels stay still. Settings are saved with the map and retained when the effect is turned off.+Choose **Trigger → At event time** to play one effect for each recorded event. Select an+**Event timestamp** field and a **Duration (timeline seconds)**. The ordinary point remains+visible according to the existing filters; a temporary Pulse or Ripple plays from the event+timestamp until the duration expires. Missing or invalid timestamps produce no effect.++Event effects use the timeline of an enabled time filter on the same dataset and event+timestamp field. Selecting an event timestamp does not create a separate layer timeline.+Add the time filter yourself; the first enabled filter matching that dataset and timestamp+column drives the effect automatically. The help tooltip beside **Event timestamp** explains+this requirement. Removing or disabling the filter uses the next enabled match, if available.+Without a matching filter, ordinary points remain visible but the event effect is inactive.++The end of the filter window is the current time. Pause freezes the effect, scrubbing shows+its phase at the selected time, and replay plays events again. Duration is measured in data+time: faster playback shortens the visible effect, and coarse timeline steps can skip short+events. Filters still determine visibility and can cut an effect short; their window and+domain are not automatically widened, including at the last event. Existing layer-timeline+synchronization is not required. **Continuous** remains the default trigger.+[Back to table of contents](../README.md)diff --git a/src/components/src/side-panel/layer-panel/layer-configurator.tsx b/src/components/src/side-panel/layer-panel/layer-configurator.tsxindex 3b8ce565c..aefdabc9b 100644--- a/src/components/src/side-panel/layer-panel/layer-configurator.tsx+++ b/src/components/src/side-panel/layer-panel/layer-configurator.tsx@@ -9,7 +9,14 @@ import styled from 'styled-components';import {createSelector} from 'reselect';import ItemSelector from '../../common/item-selector/item-selector';-import {InputLight, PanelLabel, SidePanelSection} from '../../common/styled-components';+import InfoHelperFactory from '../../common/info-helper';+import {+ Input,+ InputLight,+ PanelLabel,+ PanelLabelWrapper,+ SidePanelSection+} from '../../common/styled-components';import Switch from '../../common/switch';import SourceDataSelectorFactory from '../common/source-data-selector';@@ -76,6 +83,44 @@ const TARGET_ARROW_SHAPE_LABELS: Record<string, string> = {stealth: 'Stealth'};+function PulseDurationInput({+ id,+ durationMs,+ onChange+}: {+ id: string;+ durationMs: number;+ onChange: (durationMs: number) => void;+}) {+ const [draft, setDraft] = useState(String(durationMs / 1000));+ useEffect(() => setDraft(String(durationMs / 1000)), [durationMs, id]);++ const commit = () => {+ const value = Number(draft) * 1000;+ if (Number.isFinite(value) && value > 0) {+ setDraft(String(value / 1000));+ if (value !== durationMs) onChange(value);+ } else {+ setDraft(String(durationMs / 1000));+ }+ };++ return (+ <Input+ id={id}+ type="number"+ min={0.001}+ step="any"+ value={draft}+ onChange={event => setDraft(event.target.value)}+ onBlur={commit}+ onKeyDown={event => {+ if (event.key === 'Enter') event.currentTarget.blur();+ }}+ />+ );+}+type LayerConfiguratorProps = {layer: Layer;datasets: Datasets;@@ -472,7 +517,8 @@ LayerConfiguratorFactory.deps = [VectorTileLayerConfiguratorFactory,RasterTileLayerConfiguratorFactory,ScenegraphModelSelectorFactory,- RangeSliderFactory+ RangeSliderFactory,+ InfoHelperFactory];export default function LayerConfiguratorFactory(@@ -491,7 +537,8 @@ export default function LayerConfiguratorFactory(VectorTileLayerConfigurator: ReturnType<typeof VectorTileLayerConfiguratorFactory>,RasterTileLayerConfigurator: ReturnType<typeof RasterTileLayerConfiguratorFactory>,ScenegraphModelSelector: ReturnType<typeof ScenegraphModelSelectorFactory>,- RangeSlider: ReturnType<typeof RangeSliderFactory>+ RangeSlider: ReturnType<typeof RangeSliderFactory>,+ InfoHelper: ReturnType<typeof InfoHelperFactory>): React.ComponentType<LayerConfiguratorProps> {const AggregationTextLabelPanel: React.FC<Omit<React.ComponentProps<typeof TextLabelPanel>, 'fields'>@@ -579,6 +626,13 @@ export default function LayerConfiguratorFactory(const selectedPulseMode = pulseModeOptions.find(({id}) => id === layer.config.visConfig.pulseMode);+ const pulseTriggerOptions = ['continuous', 'event'].map(id => ({+ id,+ label: <FormattedMessage id={`layerVisConfigs.point.${id}`} />+ }));+ const timestampFields = (visConfiguratorProps.fields || []).filter(+ f => f.type === 'timestamp'+ );return (<StyledLayerVisualConfigurator>{/* Fill Color */}@@ -729,10 +783,74 @@ export default function LayerConfiguratorFactory(onChange={value => visConfiguratorProps.onChange({pulseMode: value})}/></SidePanelSection>- <VisConfigSlider- {...layer.visConfigSettings.pulseSpeed}- {...visConfiguratorProps}- />+ <SidePanelSection>+ <PanelLabel>+ <FormattedMessage id="layerVisConfigs.point.pulseTrigger" />+ </PanelLabel>+ <ItemSelector+ selectedItems={pulseTriggerOptions.find(+ ({id}) => id === (layer.config.visConfig.pulseTrigger || 'continuous')+ )}+ options={pulseTriggerOptions}+ disabled={!layer.config.visConfig.pulseEnabled}+ displayOption="label"+ getOptionValue="id"+ multiSelect={false}+ searchable={false}+ onChange={value => visConfiguratorProps.onChange({pulseTrigger: value})}+ />+ </SidePanelSection>+ {layer.config.visConfig.pulseTrigger === 'event' ? (+ <>+ <SidePanelSection>+ <PanelLabelWrapper>+ <PanelLabel>+ <FormattedMessage id="layerVisConfigs.point.pulseTimeField" />+ </PanelLabel>+ <InfoHelper+ description="layerVisConfigs.point.pulseFilterMissing"+ id={`${layer.id}-pulse-time-filter-help`}+ width={220}+ />+ </PanelLabelWrapper>+ <ItemSelector+ selectedItems={+ timestampFields.find(+ f => f.name === layer.config.visConfig.pulseTimeField+ ) || null+ }+ options={timestampFields}+ disabled={!layer.config.visConfig.pulseEnabled}+ displayOption="name"+ filterOption="name"+ getOptionValue="name"+ multiSelect={false}+ onChange={value =>+ visConfiguratorProps.onChange({+ pulseTimeField: value || ''+ })+ }+ />+ </SidePanelSection>+ <SidePanelSection>+ <PanelLabel htmlFor={`${layer.id}-pulse-duration`}>+ <FormattedMessage id="layerVisConfigs.point.pulseDuration" />+ </PanelLabel>+ <PulseDurationInput+ id={`${layer.id}-pulse-duration`}+ durationMs={layer.config.visConfig.pulseDurationMs}+ onChange={duration =>+ visConfiguratorProps.onChange({pulseDurationMs: duration})+ }+ />+ </SidePanelSection>+ </>+ ) : (+ <VisConfigSlider+ {...layer.visConfigSettings.pulseSpeed}+ {...visConfiguratorProps}+ />+ )}<VisConfigSlider{...layer.visConfigSettings.pulseExpansion}{...visConfiguratorProps}diff --git a/src/deckgl-arrow-layers/src/layers/geo-arrow-scatterplot-layer.ts b/src/deckgl-arrow-layers/src/layers/geo-arrow-scatterplot-layer.tsindex 633211bfe..d586cb052 100644--- a/src/deckgl-arrow-layers/src/layers/geo-arrow-scatterplot-layer.ts+++ b/src/deckgl-arrow-layers/src/layers/geo-arrow-scatterplot-layer.ts@@ -11,7 +11,8 @@ import {DefaultProps,GetPickingInfoParams,Layer,- LayersList+ LayersList,+ UpdateParameters} from '@deck.gl/core';import {ScatterplotLayer} from '@deck.gl/layers';import type {ScatterplotLayerProps} from '@deck.gl/layers';@@ -28,7 +29,13 @@ import {invertOffsets} from '../utils/utils';import {GeoArrowExtraPickingProps, computeChunkOffsets, getPickingInfo} from '../utils/picking';-import {ColorAccessor, FloatAccessor, GeoArrowPickingInfo, ExtensionProps} from '../types';+import {+ ColorAccessor,+ FloatAccessor,+ GeoArrowPickingInfo,+ ExtensionProps,+ _GeoArrowInternalLayerData+} from '../types';import {assert} from '../utils/utils';import {validateAccessors} from '../utils/validate';@@ -95,12 +102,56 @@ const defaultProps: DefaultProps<GeoArrowScatterplotLayerProps> = {...ourDefaultProps};+type BatchProps = {data: _GeoArrowInternalLayerData<arrow.RecordBatch>} & Record<string, any>;+export class GeoArrowScatterplotLayer<ExtraProps extends object = object> extends CompositeLayer<GeoArrowScatterplotLayerProps & ExtraProps> {static defaultProps = defaultProps;static layerName = 'GeoArrowScatterplotLayer';+ declare state: {+ batchTable: arrow.Table;+ batchProps: {+ geometry: arrow.Data;+ accessors: Record<string, any>;+ props: BatchProps;+ }[];+ };++ updateState(params: UpdateParameters<this>): void {+ super.updateState(params);+ if (params.changeFlags.dataChanged || params.changeFlags.updateTriggersChanged) {+ this.state.batchProps = [];+ }+ }++ private _getBatchProps(+ batchIndex: number,+ geometry: arrow.Data,+ accessors: Record<string, any>,+ create: () => BatchProps+ ): BatchProps {+ // Layer state survives deck.gl's replacement of composite instances. Keep+ // binary data stable on uniform-only updates so attributes are not rebuilt.+ if (this.state?.batchTable !== this.props.data) {+ this.state = {...this.state, batchTable: this.props.data, batchProps: []};+ }+ const cached = this.state.batchProps[batchIndex];+ const keys = Object.keys(accessors);+ if (+ cached &&+ cached.geometry === geometry &&+ keys.length === Object.keys(cached.accessors).length &&+ keys.every(key => accessors[key] === cached.accessors[key])+ ) {+ return cached.props;+ }+ const props = create();+ this.state.batchProps[batchIndex] = {geometry, accessors, props};+ return props;+ }+getPickingInfo(params: GetPickingInfoParams & {sourceLayer: {props: GeoArrowExtraPickingProps};@@ -152,52 +203,58 @@ export class GeoArrowScatterplotLayer<ExtraProps extends object = object> extendconst layers: ScatterplotLayer<any>[] = [];for (let recordBatchIdx = 0; recordBatchIdx < table.batches.length; recordBatchIdx++) {- const geometryData = convertStructToFixedSizeList(geometryColumn.data[recordBatchIdx]);- const flatCoordsData = ga.child.getPointChild(geometryData);- const flatCoordinateArray = flatCoordsData.values;-- // @ts-expect-error how to properly retrieve batch offset?- const batchOffset = geometryColumn._offsets[recordBatchIdx];+ const batchProps = this._getBatchProps(+ recordBatchIdx,+ geometryColumn.data[recordBatchIdx],+ accessors,+ () => {+ const geometryData = convertStructToFixedSizeList(geometryColumn.data[recordBatchIdx]);+ const props: BatchProps = {+ data: {+ data: table.batches[recordBatchIdx],+ length: geometryData.length,+ attributes: {+ getPosition: {+ value: ga.child.getPointChild(geometryData).values,+ size: geometryData.type.listSize+ }+ }+ }+ };+ for (const [propName, propInput] of Object.entries(accessors)) {+ assignAccessor({+ props,+ propName,+ propInput,+ chunkIdx: recordBatchIdx,+ // @ts-expect-error how to properly retrieve batch offset?+ batchOffset: geometryColumn._offsets[recordBatchIdx]+ });+ }+ return props;+ }+ );- const props: ScatterplotLayerProps<any> & ExtensionProps = {+ const props: ScatterplotLayerProps<any> & ExtensionProps & GeoArrowExtraPickingProps = {// Note: because this is a composite layer and not doing the rendering// itself, we still have to pass in our defaultProps...ourDefaultProps,...otherProps,+ ...batchProps,// used for picking purposesrecordBatchIdx,tableOffsets,- id: `${this.props.id}-geoarrow-scatterplot-${recordBatchIdx}`,- data: {- // @ts-expect-error- data: table.batches[recordBatchIdx],- length: geometryData.length,- attributes: {- getPosition: {- value: flatCoordinateArray,- size: geometryData.type.listSize- }- }- }+ id: `${this.props.id}-geoarrow-scatterplot-${recordBatchIdx}`};- for (const [propName, propInput] of Object.entries(accessors)) {- assignAccessor({- props,- propName,- propInput,- chunkIdx: recordBatchIdx,- batchOffset- });- }-const layer = new ScatterplotLayer({...this.getSubLayerProps(props),// preserve binded accessors, as they are overwriten back by pass-through accessors from extensionsgetFiltered: props.getFiltered,- getFilterValue: props.getFilterValue+ getFilterValue: props.getFilterValue,+ ...(props.getPulseStartTime ? {getPulseStartTime: props.getPulseStartTime} : {})});layers.push(layer);}@@ -223,60 +280,64 @@ export class GeoArrowScatterplotLayer<ExtraProps extends object = object> extendconst layers: ScatterplotLayer[] = [];for (let recordBatchIdx = 0; recordBatchIdx < table.batches.length; recordBatchIdx++) {- const multiPointData = geometryColumn.data[recordBatchIdx];- const pointData = ga.child.getMultiPointChild(multiPointData);- // Arrow buffers may include alignment padding after the logical offsets.- const geomOffsets = multiPointData.valueOffsets.subarray(0, multiPointData.length + 1);- const flatCoordsData = ga.child.getPointChild(pointData);- const flatCoordinateArray = flatCoordsData.values;-- // @ts-expect-error how to properly retrieve batch offset?- const batchOffset = geometryColumn._offsets[recordBatchIdx];+ const batchProps = this._getBatchProps(+ recordBatchIdx,+ geometryColumn.data[recordBatchIdx],+ accessors,+ () => {+ const multiPointData = geometryColumn.data[recordBatchIdx];+ const pointData = ga.child.getMultiPointChild(multiPointData);+ // Arrow buffers may include alignment padding after the logical offsets.+ const geomOffsets = multiPointData.valueOffsets.subarray(0, multiPointData.length + 1);+ const props: BatchProps = {+ data: {+ data: table.batches[recordBatchIdx],+ // Used both in picking and for function callbacks.+ invertedGeomOffsets: invertOffsets(geomOffsets),+ length: pointData.length,+ attributes: {+ getPosition: {+ value: ga.child.getPointChild(pointData).values,+ size: pointData.type.listSize+ }+ }+ }+ };+ for (const [propName, propInput] of Object.entries(accessors)) {+ assignAccessor({+ props,+ propName,+ propInput,+ chunkIdx: recordBatchIdx,+ geomCoordOffsets: geomOffsets,+ // @ts-expect-error how to properly retrieve batch offset?+ batchOffset: geometryColumn._offsets[recordBatchIdx]+ });+ }+ return props;+ }+ );- const props: ScatterplotLayerProps & ExtensionProps = {+ const props: ScatterplotLayerProps & ExtensionProps & GeoArrowExtraPickingProps = {// Note: because this is a composite layer and not doing the rendering// itself, we still have to pass in our defaultProps...ourDefaultProps,...otherProps,+ ...batchProps,// used for picking purposesrecordBatchIdx,tableOffsets,- id: `${this.props.id}-geoarrow-scatterplot-${recordBatchIdx}`,- data: {- // @ts-expect-error- data: table.batches[recordBatchIdx],- // Map from expanded multi-geometry index to original index- // Used both in picking and for function callbacks- invertedGeomOffsets: invertOffsets(geomOffsets),- // Note: this needs to be the length one level down.- length: pointData.length,- attributes: {- getPosition: {- value: flatCoordinateArray,- size: pointData.type.listSize- }- }- }+ id: `${this.props.id}-geoarrow-scatterplot-${recordBatchIdx}`};- for (const [propName, propInput] of Object.entries(accessors)) {- assignAccessor({- props,- propName,- propInput,- chunkIdx: recordBatchIdx,- geomCoordOffsets: geomOffsets,- batchOffset- });- }-const layer = new ScatterplotLayer({...this.getSubLayerProps(props),// preserve binded accessors, as they are overwriten back by pass-through accessors from extensionsgetFiltered: props.getFiltered,- getFilterValue: props.getFilterValue+ getFilterValue: props.getFilterValue,+ ...(props.getPulseStartTime ? {getPulseStartTime: props.getPulseStartTime} : {})});layers.push(layer);}diff --git a/src/deckgl-arrow-layers/src/types.ts b/src/deckgl-arrow-layers/src/types.tsindex 2ae8a4501..642514b0c 100644--- a/src/deckgl-arrow-layers/src/types.ts+++ b/src/deckgl-arrow-layers/src/types.ts@@ -73,6 +73,7 @@ export type NormalAccessor =| Accessor<arrow.Table, arrow.Vector<arrow.FixedSizeList<arrow.Float32>>>;export type ExtensionProps = {+ getPulseStartTime?: (d: any, objectInfo?: {index: number}) => number[];getFiltered?: ({index}: {index: number}) => number;getFilterValue?: (d: any, objectInfo?: {index: number}) => (number | number[])[];};diff --git a/src/layers/src/point-layer/point-layer.ts b/src/layers/src/point-layer/point-layer.tsindex a8b3a9c2c..11f40d111 100644--- a/src/layers/src/point-layer/point-layer.ts+++ b/src/layers/src/point-layer/point-layer.ts@@ -20,10 +20,15 @@ import {hexToRgb, DataContainerInterface, ArrowDataContainer} from '@kepler.gl/uimport {applyDefaultColorField} from '../layer-color-utils';import {default as KeplerTable} from '@kepler.gl/table';import PointLayerIcon from './point-layer-icon';-import PulseRippleExtension from './pulse-ripple-extension';+import PulseRippleExtension, {+ EventPulseRippleExtension,+ encodePulseTime,+ isPulseTimeActive+} from './pulse-ripple-extension';import PointGlowExtension from './point-glow-extension';import {DatasetType,+ FILTER_TYPES,LAYER_VIS_CONFIGS,DEFAULT_LAYER_COLOR,CHANNEL_SCALES,@@ -55,6 +60,8 @@ import {VisConfigRange,LayerColumn,Field,+ Filter,+ TimeRangeFilter,AnimationConfig} from '@kepler.gl/types';@@ -76,6 +83,9 @@ export type PointLayerVisConfigSettings = {pulseMode: VisConfigSelection;pulseSpeed: VisConfigNumber;pulseExpansion: VisConfigNumber;+ pulseTrigger: VisConfigSelection;+ pulseTimeField: VisConfigSelection;+ pulseDurationMs: VisConfigNumber;};export type PointLayerColumnsConfig = {@@ -105,6 +115,9 @@ export type PointLayerVisConfig = {pulseMode: 'pulse' | 'ripple';pulseSpeed: number;pulseExpansion: number;+ pulseTrigger: 'continuous' | 'event';+ pulseTimeField: string;+ pulseDurationMs: number;billboard: boolean;allowHover: boolean;showNeighborOnHover: boolean;@@ -182,6 +195,7 @@ const DEFAULT_COLUMN_MODE = COLUMN_MODE_POINTS;const brushingExtension = new BrushingExtension();const arrowCPUFilterExtension = new FilterArrowExtension();const pulseRippleExtension = new PulseRippleExtension();+const eventPulseRippleExtension = new EventPulseRippleExtension();const pointGlowExtension = new PointGlowExtension();function pushPointPosition(data: any[], pos: number[], index: number, neighbors?: number[]) {@@ -213,11 +227,38 @@ export const pointVisConfigs: {pulseMode: VisConfigSelection;pulseSpeed: VisConfigNumber;pulseExpansion: VisConfigNumber;+ pulseTrigger: VisConfigSelection;+ pulseTimeField: VisConfigSelection;+ pulseDurationMs: VisConfigNumber;billboard: 'billboard';allowHover: 'allowHover';showNeighborOnHover: 'showNeighborOnHover';showHighlightColor: 'showHighlightColor';} = {+ pulseTrigger: {+ type: 'select',+ defaultValue: 'continuous',+ options: ['continuous', 'event'],+ label: 'layerVisConfigs.point.pulseTrigger',+ property: 'pulseTrigger'+ } as VisConfigSelection,+ pulseTimeField: {+ type: 'select',+ defaultValue: '',+ options: [],+ label: 'layerVisConfigs.point.pulseTimeField',+ property: 'pulseTimeField',+ group: 'point'+ } as VisConfigSelection,+ pulseDurationMs: {+ type: 'number',+ defaultValue: 1000,+ label: 'layerVisConfigs.point.pulseDuration',+ property: 'pulseDurationMs',+ isRanged: false,+ range: [1, Number.MAX_SAFE_INTEGER],+ step: 1+ } as VisConfigNumber,glowEnabled: {type: 'boolean',defaultValue: false,@@ -272,8 +313,8 @@ export const pointVisConfigs: {description: 'layerVisConfigs.point.pulseExpansionDescription',property: 'pulseExpansion',isRanged: false,- range: [1, 5],- step: 0.1+ range: [1, 50],+ step: 0.01} as VisConfigNumber,radius: 'radius',fixedRadius: 'fixedRadius',@@ -304,6 +345,14 @@ export default class PointLayer extends Layer {dataContainer: DataContainerInterface | null = null;geoArrowVector: arrow.Vector | undefined = undefined;+ private pulseTimeCache?: {+ dataContainer: DataContainerInterface;+ dataRevision: number;+ field: Field;+ origin: number;+ domain: [number, number] | null;+ getPulseStartTime: (row: {index: number}) => number[];+ };/** CPU filtering an arrow table by values and assembling a partial copy of the raw table is expensive@@ -362,7 +411,6 @@ export default class PointLayer extends Layer {'glowEnabled','glowExtent','glowStrength',- 'pulseEnabled','pulseMode','pulseSpeed','pulseExpansion'@@ -542,6 +590,7 @@ export default class PointLayer extends Layer {const {textLabel} = this.config;const {gpuFilter, dataContainer} = datasets[this.config.dataId];const {data, triggerChanged} = this.updateData(datasets, oldLayerData);+ const pulseData = this.updateEventAnimation(datasets[this.config.dataId]);const getPosition = d => d.position;// get all distinct characters in the text labels@@ -566,11 +615,84 @@ export default class PointLayer extends Layer {getFilterValue: gpuFilter.filterValueAccessor(dataContainer)(),getFiltered: isFilteredAccessor,textLabels,+ ...pulseData,...accessors};}/* eslint-enable complexity */+ getEventPulseCurrentTime(filters: Filter[] = []): number | null {+ const {dataId, visConfig} = this.config;+ if (!dataId || !visConfig.pulseTimeField) return null;+ const filter = filters.find((candidate): candidate is TimeRangeFilter => {+ const datasetIndex = candidate.dataId.indexOf(dataId);+ return (+ candidate.type === FILTER_TYPES.timeRange &&+ candidate.enabled !== false &&+ datasetIndex >= 0 &&+ candidate.name[datasetIndex] === visConfig.pulseTimeField+ );+ });+ const value = filter?.value;+ return Array.isArray(value) &&+ value.length === 2 &&+ value.every(Number.isFinite) &&+ value[1] >= value[0]+ ? value[1]+ : null;+ }++ updateEventAnimation(dataset: KeplerTable) {+ // Event effects follow a user-created filter, never register a layer timeline.+ this.config.animation = {enabled: false};+ const {pulseEnabled, pulseTrigger, pulseTimeField, pulseDurationMs} = this.config.visConfig;+ const field = dataset.fields.find(f => f.name === pulseTimeField && f.type === 'timestamp');+ if (+ !pulseEnabled ||+ pulseTrigger !== 'event' ||+ !field ||+ !Number.isFinite(pulseDurationMs) ||+ pulseDurationMs <= 0+ ) {+ this.pulseTimeCache = undefined;+ return {};+ }+ const {dataContainer, dataRevision} = dataset;+ let cache = this.pulseTimeCache;+ if (+ !cache ||+ cache.dataContainer !== dataContainer ||+ cache.dataRevision !== dataRevision ||+ cache.field !== field+ ) {+ let min = Infinity;+ let max = -Infinity;+ const times = dataContainer.mapIndex(({index}) => {+ const value = field.valueAccessor({index});+ if (!Number.isFinite(value)) return null;+ min = Math.min(min, value);+ max = Math.max(max, value);+ return value as number;+ });+ const origin = Number.isFinite(min) ? min : 0;+ const encoded = times.map(time => encodePulseTime(time === null ? null : time - origin));+ cache = this.pulseTimeCache = {+ dataContainer,+ dataRevision,+ field,+ origin,+ domain: Number.isFinite(min) ? [min, max] : null,+ getPulseStartTime: ({index}) => encoded[index] || [0, 0, 0]+ };+ }+ const end = cache.domain ? cache.domain[1] + pulseDurationMs : NaN;+ return {+ getPulseStartTime: cache.getPulseStartTime,+ pulseTimeOrigin: cache.origin,+ pulseTimeDomain: cache.domain && Number.isFinite(end) ? [cache.domain[0], end] : null+ };+ }+updateLayerMeta(dataset: KeplerTable) {const {dataContainer} = dataset;this.dataContainer = dataContainer;@@ -599,13 +721,25 @@ export default class PointLayer extends Layer {// eslint-disable-next-line complexityrenderLayer(opts) {- const {data, gpuFilter, objectHovered, mapState, interactionConfig, dataset} = opts;+ const {data, gpuFilter, objectHovered, mapState, interactionConfig, dataset, filters} = opts;// if no field size is defined we need to pass fixed radius = falseconst fixedRadius = this.config.visConfig.fixedRadius && Boolean(this.config.sizeField);const radiusScale = this.getRadiusScaleByZoom(mapState, fixedRadius);- const {pulseEnabled, pulseMode, pulseSpeed, pulseExpansion} = this.config.visConfig;- const pulseProps = {pulseEnabled, pulseMode, pulseSpeed, pulseExpansion};+ const {pulseEnabled, pulseMode, pulseSpeed, pulseExpansion, pulseTrigger, pulseDurationMs} =+ this.config.visConfig;+ const continuous = pulseEnabled && pulseTrigger !== 'event';+ const pulseProps = {pulseEnabled: continuous, pulseMode, pulseSpeed, pulseExpansion};+ const eventDomain = data.pulseTimeDomain;+ const pulseCurrentTime =+ pulseEnabled && pulseTrigger === 'event' ? this.getEventPulseCurrentTime(filters) : null;+ const eventColorAccessor = this.config.visConfig.filled ? 'getFillColor' : 'getLineColor';+ const showEventOverlay =+ (this.config.visConfig.filled || this.config.visConfig.outline) &&+ pulseEnabled &&+ pulseTrigger === 'event' &&+ eventDomain &&+ isPulseTimeActive(pulseCurrentTime, eventDomain[0], eventDomain[1] - eventDomain[0]);const layerProps = {stroked: this.config.visConfig.outline,@@ -716,12 +850,48 @@ export default class PointLayer extends Layer {lineWidthUnits: 'pixels',updateTriggers,...pulseProps,- extensions: [...extensions, ...(pulseEnabled ? [pulseRippleExtension] : [])],+ extensions: [...extensions, ...(continuous ? [pulseRippleExtension] : [])],opacity: hoveredObject && showNeighborOnHover ? 0.2 : this.config.visConfig.opacity,pickable: allowHover,autoHighlight: false})),+ ...(showEventOverlay+ ? [+ // @ts-expect-error Scatterplot and GeoArrow have different data signatures.+ new ScatterplotLayerClass({+ ...defaultLayerProps,+ ...brushingProps,+ ...layerProps,+ ...data,+ id: `${this.id}-event-pulse`,+ data: deckLayerData,+ getPosition,+ // Only the ordinary point reports counts and owns picking and text labels.+ onFilteredItemsChange: null,+ getFillColor: data[eventColorAccessor],+ pickable: false,+ autoHighlight: false,+ filled: true,+ stroked: false,+ pulseMode,+ pulseExpansion,+ pulseDurationMs,+ pulseCurrentTime:+ pulseCurrentTime !== null ? pulseCurrentTime - data.pulseTimeOrigin : null,+ extensions: [...extensions, eventPulseRippleExtension],+ updateTriggers: {+ ...updateTriggers,+ getFillColor: updateTriggers[eventColorAccessor],+ getPulseStartTime: data.getPulseStartTime+ },+ parameters: {+ depthTest: (this.config.columns.altitude?.fieldIdx as number) > -1,+ ...(mapState?.layerParameters ?? {})+ }+ })+ ]+ : []),// hover layer...(hoveredObject? withGlow(@@ -729,7 +899,7 @@ export default class PointLayer extends Layer {...this.getDefaultHoverLayerProps(),...layerProps,...pulseProps,- ...(pulseEnabled ? {extensions: [pulseRippleExtension]} : {}),+ ...(continuous ? {extensions: [pulseRippleExtension]} : {}),visible: defaultLayerProps.visible,data: [...neighborsData, hoveredObject],getLineColor: this.config.visConfig.showHighlightColordiff --git a/src/layers/src/point-layer/pulse-ripple-extension.spec.ts b/src/layers/src/point-layer/pulse-ripple-extension.spec.tsindex 3700bf613..d2b6f37b9 100644--- a/src/layers/src/point-layer/pulse-ripple-extension.spec.ts+++ b/src/layers/src/point-layer/pulse-ripple-extension.spec.ts@@ -4,13 +4,17 @@import {Layer} from '@deck.gl/core';import PulseRippleExtension, {getPulseRippleUniforms,- PulseRippleProps+ PulseRippleProps,+ encodePulseTime,+ isPulseTimeActive,+ EventPulseRippleExtension,+ EventPulseRippleProps} from './pulse-ripple-extension';describe('Pulse / Ripple animation', () => {test('disabled and missing settings leave point rendering unchanged', () => {expect(getPulseRippleUniforms({}, 500)).toEqual({radiusScale: 1, opacity: 1, ripple: 0});- expect(getPulseRippleUniforms({pulseEnabled: false, pulseExpansion: 5}, 500)).toEqual({+ expect(getPulseRippleUniforms({pulseEnabled: false, pulseExpansion: 50}, 500)).toEqual({radiusScale: 1,opacity: 1,ripple: 0@@ -60,7 +64,15 @@ describe('Pulse / Ripple animation', () => {).toEqual({radiusScale: 1, opacity: 0.4, ripple: 0});expect(getPulseRippleUniforms({pulseEnabled: true, pulseSpeed: 100, pulseExpansion: 100}, 500)- ).toEqual({radiusScale: 5, opacity: 0.4, ripple: 0});+ ).toEqual({radiusScale: 50, opacity: 0.4, ripple: 0});+ });++ test.each(['pulse', 'ripple'] as const)('%s supports expansion up to 50', pulseMode => {+ const uniforms = getPulseRippleUniforms(+ {pulseEnabled: true, pulseMode, pulseExpansion: 50},+ 500+ );+ expect(uniforms.radiusScale).toBe(pulseMode === 'pulse' ? 50 : 25.5);});test('updates GPU uniforms and requests redraw only for visible, enabled, nonempty points', () => {@@ -88,3 +100,88 @@ describe('Pulse / Ripple animation', () => {}});});++describe('Recorded event Pulse / Ripple', () => {+ test('has one half-open event window, including epoch zero, without looping', () => {+ for (const start of [0, Date.UTC(2026, 10, 2)]) {+ for (const [offset, active] of [+ [-1, false],+ [0, true],+ [500, true],+ [999, true],+ [1000, false],+ [1500, false],+ [2000, false]+ ] as const) {+ expect(isPulseTimeActive(start + offset, start, 1000)).toBe(active);+ }+ }+ for (const value of [null, undefined, NaN, Infinity]) {+ expect(isPulseTimeActive(value, 0, 1000)).toBe(false);+ }+ for (const duration of [0, -1, NaN, Infinity]) {+ expect(isPulseTimeActive(0, 0, duration)).toBe(false);+ }+ });+ test('preserves millisecond differences across long datasets and rejects missing times', () => {+ const start = Date.UTC(2026, 10, 2) - Date.UTC(2000, 0, 1);+ for (const offset of [0, 1, 499, 500, 999, 1000, 1001]) {+ const a = encodePulseTime(start).map(Math.fround);+ const b = encodePulseTime(start + offset).map(Math.fround);+ const gpuAge = Math.fround(Math.fround(b[0] - a[0]) + Math.fround(b[1] - a[1]));+ expect(gpuAge).toBe(offset);+ }+ expect(encodePulseTime(0)).toEqual([0, 0, 1]);+ for (const value of [null, undefined, NaN, Infinity, -Infinity]) {+ expect(encodePulseTime(value)).toEqual([0, 0, 0]);+ }+ });++ test.each([+ [25, 25],+ [50, 50],+ [100, 50]+ ])('event expansion %s sends %s to the shader', (pulseExpansion, expected) => {+ const extension = new EventPulseRippleExtension();+ const setProps = jest.fn();+ const host = {+ props: {pulseExpansion},+ getModels: () => [{shaderInputs: {setProps}}]+ };+ extension.draw.call(host as unknown as Layer<EventPulseRippleProps>);+ expect(setProps).toHaveBeenCalledWith({+ eventPulse: expect.objectContaining({expansion: expected})+ });+ });++ test('uses only the playhead, including pause, scrubbing and replay; never requests redraw', () => {+ const extension = new EventPulseRippleExtension();+ const setProps = jest.fn();+ const redraw = jest.fn();+ const host = {+ props: {pulseCurrentTime: 500, pulseDurationMs: 1000, pulseExpansion: 3, pulseMode: 'ripple'},+ getModels: () => [{shaderInputs: {setProps}}],+ setNeedsRedraw: redraw+ };+ for (const time of [500, 500, 1200, -1, 0, 500]) {+ host.props.pulseCurrentTime = time;+ extension.draw.call(host as unknown as Layer<EventPulseRippleProps>);+ expect(setProps).toHaveBeenLastCalledWith({+ eventPulse: {+ currentTime: encodePulseTime(time),+ duration: 1000,+ expansion: 3,+ ripple: 1+ }+ });+ }+ expect(redraw).not.toHaveBeenCalled();+ for (const duration of [0, -1, NaN, Infinity]) {+ host.props.pulseDurationMs = duration;+ extension.draw.call(host as unknown as Layer<EventPulseRippleProps>);+ expect(setProps).toHaveBeenLastCalledWith({+ eventPulse: expect.objectContaining({duration: 0})+ });+ }+ });+});diff --git a/src/layers/src/point-layer/pulse-ripple-extension.ts b/src/layers/src/point-layer/pulse-ripple-extension.tsindex 43c130c31..6c1251554 100644--- a/src/layers/src/point-layer/pulse-ripple-extension.ts+++ b/src/layers/src/point-layer/pulse-ripple-extension.ts@@ -38,7 +38,7 @@ export function getPulseRippleUniforms(props: PulseRippleProps, timeMs: number)? Math.min(3, Math.max(0.1, props.pulseSpeed as number)): 1;const expansion = Number.isFinite(props.pulseExpansion)- ? Math.min(5, Math.max(1, props.pulseExpansion as number))+ ? Math.min(50, Math.max(1, props.pulseExpansion as number)): 2;const phase = Number.isFinite(timeMs) ? ((Math.max(0, timeMs) / 1000) * speed) % 1 : 0;if (props.pulseMode === 'ripple') {@@ -95,3 +95,119 @@ export default class PulseRippleExtension extends LayerExtension {}}}++export type EventPulseRippleProps = PulseRippleProps & {+ pulseCurrentTime?: number | null;+ pulseDurationMs?: number;+ getPulseStartTime?: (row: {index: number}) => number[];+};++/** Split milliseconds before uploading to float32 attributes/uniforms. The third+ * component distinguishes a missing timestamp from the valid Unix epoch. */+export function encodePulseTime(time: number | null | undefined): number[] {+ if (!Number.isFinite(time)) return [0, 0, 0];+ const high = Math.fround(time as number);+ return [high, (time as number) - high, 1];+}++export function isPulseTimeActive(time: unknown, start: number, duration: number): boolean {+ return (+ typeof time === 'number' &&+ Number.isFinite(time) &&+ Number.isFinite(start) &&+ Number.isFinite(duration) &&+ duration > 0 &&+ time >= start &&+ time - start < duration+ );+}++const eventUniformBlock = `\+layout(std140) uniform eventPulseUniforms {+ vec3 currentTime;+ float duration;+ float expansion;+ float ripple;+} eventPulse;+`;++const eventPulseUniforms = {+ name: 'eventPulse',+ vs: eventUniformBlock,+ fs: eventUniformBlock,+ uniformTypes: {+ currentTime: 'vec3<f32>',+ duration: 'f32',+ expansion: 'f32',+ ripple: 'f32'+ } as const+};++/** A transient, non-pickable overlay. Only the Kepler playhead advances it. */+export class EventPulseRippleExtension extends LayerExtension {+ static extensionName = 'EventPulseRippleExtension';+ static defaultProps = {+ pulseCurrentTime: null,+ pulseDurationMs: 1000,+ pulseExpansion: 2,+ pulseMode: 'pulse',+ getPulseStartTime: {type: 'accessor', value: [0, 0, 0]}+ };++ initializeState(this: Layer<EventPulseRippleProps>) {+ this.getAttributeManager()?.addInstanced({+ instancePulseStartTime: {size: 3, accessor: 'getPulseStartTime'}+ });+ }++ getShaders() {+ return {+ modules: [eventPulseUniforms],+ inject: {+ 'vs:#decl': 'in vec3 instancePulseStartTime; out float pulseOpacity;',+ 'fs:#decl': 'in float pulseOpacity;',+ 'vs:DECKGL_FILTER_SIZE': `+ float age = (eventPulse.currentTime.x - instancePulseStartTime.x)+ + (eventPulse.currentTime.y - instancePulseStartTime.y);+ bool eventActive = eventPulse.currentTime.z > 0.5 && instancePulseStartTime.z > 0.5+ && eventPulse.duration > 0.0 && age >= 0.0 && age < eventPulse.duration;+ float phase = eventActive ? age / eventPulse.duration : 0.0;+ float breath = (1.0 - cos(phase * 6.28318530718)) / 2.0;+ float growth = eventPulse.ripple > 0.5 ? phase : breath;+ size *= 1.0 + (eventPulse.expansion - 1.0) * growth;+ pulseOpacity = eventActive+ ? (eventPulse.ripple > 0.5 ? pow(1.0 - phase, 2.0) : breath) : 0.0;+ `,+ 'fs:DECKGL_FILTER_COLOR': `+ if (pulseOpacity <= 0.0) discard;+ if (eventPulse.ripple > 0.5) {+ float radius = length(geometry.uv);+ float edge = max(fwidth(radius), 0.001);+ float ring = smoothstep(0.88 - edge, 0.88 + edge, radius);+ if (ring <= 0.0) discard;+ color.a *= ring;+ }+ color.a *= pulseOpacity;+ `+ }+ };+ }++ draw(this: Layer<EventPulseRippleProps>) {+ const {pulseCurrentTime, pulseDurationMs, pulseExpansion, pulseMode} = this.props;+ const uniforms = {+ currentTime: encodePulseTime(pulseCurrentTime),+ duration:+ Number.isFinite(pulseDurationMs) && (pulseDurationMs as number) > 0+ ? (pulseDurationMs as number)+ : 0,+ expansion: Number.isFinite(pulseExpansion)+ ? Math.min(50, Math.max(1, pulseExpansion as number))+ : 2,+ ripple: pulseMode === 'ripple' ? 1 : 0+ };+ for (const model of this.getModels()) {+ model.shaderInputs.setProps({eventPulse: uniforms});+ }+ }+}diff --git a/src/localization/src/translations/en.ts b/src/localization/src/translations/en.tsindex ac6ec240c..c5b2c0726 100644--- a/src/localization/src/translations/en.ts+++ b/src/localization/src/translations/en.ts@@ -211,6 +211,13 @@ export default {pulse: 'Pulse',ripple: 'Ripple',pulseSpeed: 'Speed (cycles/s)',+ pulseTrigger: 'Trigger',+ continuous: 'Continuous',+ event: 'At event time',+ pulseTimeField: 'Event timestamp',+ pulseDuration: 'Duration (timeline seconds)',+ pulseFilterMissing:+ 'Add an enabled timeline animation filter on the same timestamp column to play this effect.',pulseExpansion: 'Expansion',pulseExpansionDescription: 'Maximum radius as a multiple of the point radius.'},diff --git a/src/reducers/src/layer-utils.ts b/src/reducers/src/layer-utils.tsindex 83826fa76..3965f61da 100644--- a/src/reducers/src/layer-utils.ts+++ b/src/reducers/src/layer-utils.ts@@ -347,6 +347,7 @@ export function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: anmapIndex,interactionConfig,animationConfig,+ filters,mapLayers,experimentalContext} = props;@@ -366,6 +367,7 @@ export function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: anmapState,mapIndex,animationConfig,+ filters,objectHovered,visible,dataset,@@ -491,6 +493,7 @@ function computeDeckLayersFromLayerOrder(mapIndex?: number;interactionConfig: any;animationConfig: any;+ filters?: VisState['filters'];mapLayers: any;hasShadowEffect: boolean;isAnnotationMode?: boolean;@@ -505,6 +508,7 @@ function computeDeckLayersFromLayerOrder(mapIndex,interactionConfig,animationConfig,+ filters,mapLayers,hasShadowEffect,isAnnotationMode@@ -554,6 +558,7 @@ function computeDeckLayersFromLayerOrder(mapIndex,interactionConfig,animationConfig,+ filters,mapLayers,experimentalContext: {hasShadowEffect,@@ -583,6 +588,7 @@ export function computeDeckLayers(clicked,interactionConfig,animationConfig,+ filters,splitMaps} = visState;@@ -630,6 +636,7 @@ export function computeDeckLayers(mapIndex,interactionConfig,animationConfig,+ filters,mapLayers,hasShadowEffect,isAnnotationMode@@ -663,6 +670,7 @@ export function computeDeckLayers(mapIndex,interactionConfig,animationConfig,+ filters,mapLayers,experimentalContext: {hasShadowEffect,diff --git a/src/reducers/src/vis-state-updaters.ts b/src/reducers/src/vis-state-updaters.tsindex 385e05c35..f10482430 100644--- a/src/reducers/src/vis-state-updaters.ts+++ b/src/reducers/src/vis-state-updaters.ts@@ -4680,6 +4680,11 @@ function reconcileLayerWithNewSchema(configPatch.columns = {...layer.config.columns, ...columnsPatch};}+ const {pulseTimeField} = layer.config.visConfig;+ if (layer.type === LAYER_TYPES.point && pulseTimeField && renames[pulseTimeField]) {+ configPatch.visConfig = {...layer.config.visConfig, pulseTimeField: renames[pulseTimeField]};+ }+// follow renamed visual-channel fields (colorField, sizeField, ...)Object.values(layer.visualChannels).forEach(({field}) => {const fieldConfig = layer.config[field];diff --git a/test/browser/components/side-panel/layer-configurator-test.js b/test/browser/components/side-panel/layer-configurator-test.jsindex 710a46313..8b86693f4 100644--- a/test/browser/components/side-panel/layer-configurator-test.js+++ b/test/browser/components/side-panel/layer-configurator-test.js@@ -1462,7 +1462,7 @@ test('Components -> LayerConfigurator -> collapsed Heatmap surface toggle group'other: 'glowEnabled',values: [['pulseSpeed', '1', '0.5'],- ['pulseExpansion', '2', '4']+ ['pulseExpansion', '2', '49.99']]}].forEach(({label, enabled, other, values}) => {@@ -1564,6 +1564,81 @@ test('Components -> LayerConfigurator -> collapsed Heatmap surface toggle group'`keyboard adjusts ${property}`);}+ if (enabled === 'pulseEnabled') {+ fireEvent.click(content.querySelectorAll('.item-selector__dropdown')[1]);+ fireEvent.click(view.getByText('At event time'));+ t.deepEqual(+ changed.lastCall.args[0],+ {pulseTrigger: 'event'},+ 'trigger selects recorded events'+ );+ t.notOk(+ within(content).queryByText('Speed (cycles/s)'),+ 'recorded events use duration instead of repetition speed'+ );+ const duration = within(content).getByLabelText('Duration (timeline seconds)');+ const beforeEdit = changed.callCount;+ await user.clear(duration);+ t.equal(duration.value, '', 'duration can be cleared while editing');+ await user.type(duration, '0.5');+ t.equal(duration.value, '0.5', 'fractional duration can be typed from an empty input');+ t.equal(changed.callCount, beforeEdit, 'draft edits do not update the timeline');+ await user.tab();+ t.deepEqual(changed.lastCall.args[0], {pulseDurationMs: 500}, 'blur commits a half second');+ await user.clear(duration);+ await user.type(duration, '2.5{Enter}');+ t.deepEqual(+ changed.lastCall.args[0],+ {pulseDurationMs: 2500},+ 'Enter commits duration in milliseconds'+ );+ const durationChanges = () =>+ changed.getCalls().filter(call => 'pulseDurationMs' in call.args[0]).length;+ const beforeInvalid = durationChanges();+ for (const value of ['', '0', '-1']) {+ await user.clear(duration);+ if (value) await user.type(duration, value);+ await user.tab();+ t.equal(durationChanges(), beforeInvalid, 'invalid duration is rejected on commit');+ t.equal(duration.value, '2.5', 'invalid duration restores the saved value');+ }+ const timeField = defaultProps.datasets[testCsvDataId].fields.find(+ f => f.type === 'timestamp'+ );+ fireEvent.click(content.querySelectorAll('.item-selector__dropdown')[2]);+ const timestampDropdown = view+ .getByText(timeField.name, {selector: '.list-selector .list__item__anchor[title]'})+ .closest('.typeahead');+ await user.type(within(timestampDropdown).getByRole('textbox'), timeField.name);+ fireEvent.click(+ view.getByText(timeField.name, {selector: '.list-selector .list__item__anchor[title]'})+ );+ t.equal(+ layer.config.visConfig.pulseTimeField,+ timeField.name,+ 'searching timestamps by name selects the recorded event field'+ );+ const helpSelector = `[data-for="${layer.id}-pulse-time-filter-help"] [data-id="tooltip"]`;+ t.ok(content.querySelector(helpSelector), 'event timestamp includes timeline guidance');+ t.notOk(within(content).queryByRole('status'), 'guidance adds no inline message');+ t.equal(+ content.querySelectorAll('.item-selector__dropdown').length,+ 3,+ 'event controls only offer effect, trigger and timestamp choices'+ );+ fireEvent.click(content.querySelectorAll('.item-selector__dropdown')[1]);+ fireEvent.click(+ view.getByText('Continuous', {+ selector: '.list-selector .list__item__anchor:not(.disabled)'+ })+ );+ t.equal(+ layer.config.visConfig.pulseSpeed,+ 0.5,+ 'returning to continuous preserves its speed'+ );+ t.notOk(content.querySelector(helpSelector), 'continuous mode needs no timeline guidance');+ }fireEvent.click(otherToggle);t.equal(layer.config.visConfig[enabled],diff --git a/test/browser/layer-tests/point-layer-specs.js b/test/browser/layer-tests/point-layer-specs.jsindex 94a134b75..6f91631b5 100644--- a/test/browser/layer-tests/point-layer-specs.js+++ b/test/browser/layer-tests/point-layer-specs.js@@ -4,8 +4,13 @@import test from 'tape';import {LayerManager, MapView, _GlobeView} from '@deck.gl/core';import {device} from '@deck.gl/test-utils';+import {ScatterplotLayer} from '@deck.gl/layers';+import {spawnSync} from 'child_process';import {visStateSchemaV1} from '@kepler.gl/schemas';-import PulseRippleExtension from '../../../src/layers/src/point-layer/pulse-ripple-extension';+import PulseRippleExtension, {+ EventPulseRippleExtension,+ encodePulseTime+} from '../../../src/layers/src/point-layer/pulse-ripple-extension';import PointGlowExtension from '../../../src/layers/src/point-layer/point-glow-extension';import moment from 'moment';import {getDistanceScales, zoomToScale} from '@math.gl/web-mercator';@@ -49,6 +54,15 @@ import {const {PointLayer} = KeplerGlLayers;+const eventTimeFilter = (layer, time) => ({+ id: 'event-time',+ type: 'timeRange',+ dataId: [layer.config.dataId],+ name: [layer.config.visConfig.pulseTimeField],+ enabled: true,+ value: [time, time]+});+[PointLayer, KeplerGlLayers.ArcLayer, KeplerGlLayers.LineLayer].forEach(LayerClass => {test(`#${LayerClass.name} -> progressive numeric Arrow coordinates render and pick`, async t => {const rows = [@@ -321,7 +335,11 @@ test('#PointLayer -> native separated points preserve every coordinate through iconst batches = coordinates.map((coords, index) => {const table = new arrow.Table({geometry: arrow.vectorFromArray(coords, type),- value: arrow.vectorFromArray(values[index], new arrow.Float64())+ value: arrow.vectorFromArray(values[index], new arrow.Float64()),+ started: arrow.vectorFromArray(+ values[index].map(v => v * 1000),+ new arrow.TimestampMillisecond()+ )});table.schema.fields[0].metadata.set('ARROW:extension:name', `geoarrow.${geometryType}`);return table;@@ -490,6 +508,82 @@ test('#PointLayer -> native separated points preserve every coordinate through i);}}+ layer.updateLayerVisConfig({+ pulseEnabled: true,+ pulseTrigger: 'event',+ pulseTimeField: 'started'+ });+ const eventData = layer.formatLayerData({[dataset.id]: dataset}, formatted);+ const renderEvents = currentTime =>+ layer.renderLayer({+ data: eventData,+ dataset,+ idx: 0,+ mapState: INITIAL_MAP_STATE,+ gpuFilter: dataset.gpuFilter,+ interactionConfig: INITIAL_VIS_STATE.interactionConfig,+ visible: true,+ layerCallbacks: {onFilteredItemsChange: () => {}},+ filters: [eventTimeFilter(layer, currentTime)]+ });+ const eventLayers = renderEvents(90500);+ const eventComposite = eventLayers.find(l => l.id === `${layer.id}-event-pulse`);+ t.ok(eventComposite, 'event overlay supports Arrow geometry');+ eventComposite.renderLayers().forEach((sublayer, batchIndex) => {+ t.notOk(sublayer.props.onFilteredItemsChange, 'event Arrow batches do not report counts');+ rowIndices[batchIndex].forEach((rowIndex, index) => {+ const context = {index, data: sublayer.props.data, target: []};+ t.deepEqual(+ sublayer.props.getPulseStartTime(null, context),+ encodePulseTime(values.flat()[rowIndex] * 1000 - 10000),+ 'event timestamp uses the absolute feature row, including MultiPoint expansion'+ );+ t.deepEqual(+ sublayer.props.getFilterValue(null, context),+ formatted.getFilterValue({index: rowIndex}),+ 'event overlay preserves GPU filtering across batches'+ );+ t.equal(+ sublayer.props.getFiltered(null, context),+ formatted.getFiltered({index: rowIndex}),+ 'event overlay preserves CPU filtering across batches'+ );+ });+ });+ let timestampReads = 0;+ const getPulseStartTime = eventData.getPulseStartTime;+ eventData.getPulseStartTime = row => {+ timestampReads++;+ return getPulseStartTime(row);+ };+ const manager = new LayerManager(device, {+ viewport: new MapView().makeViewport({+ width: 400,+ height: 400,+ viewState: INITIAL_MAP_STATE+ })+ });+ try {+ manager.setLayers(renderEvents(90500));+ t.equal(timestampReads, rowIndices.flat().length, 'initial upload reads expanded points');+ timestampReads = 0;+ for (const time of [90600, 90200, 10000]) {+ manager.setLayers(renderEvents(time));+ t.equal(timestampReads, 0, 'playback and scrubbing reuse Arrow event attributes');+ }+ eventData.getPulseStartTime = row => {+ timestampReads++;+ return encodePulseTime(row.index * 2000);+ };+ manager.setLayers(renderEvents(10500));+ t.equal(+ timestampReads,+ rowIndices.flat().length,+ 'changing the event accessor uploads fresh attributes across all batches'+ );+ } finally {+ manager.finalize();+ }const vectorLayer = new GeoArrowScatterplotLayer({id: 'batched-vector-radius',data: table,@@ -593,6 +687,73 @@ test('#PointLayer -> MultiPoint IPC offset padding and vector attributes', asynct.end();});+test('#PointLayer -> ordinary Arrow MultiPoint vectors honor explicit invalidation', t => {+ const pointType = new arrow.FixedSizeList(2, new arrow.Field('xy', new arrow.Float64()));+ const geometry = arrow.vectorFromArray(+ [+ [+ [0, 0],+ [1, 1]+ ],+ [[2, 2]]+ ],+ new arrow.List(new arrow.Field('points', pointType))+ );+ const radius = arrow.vectorFromArray([10, 20], new arrow.Float64());+ const colors = arrow.vectorFromArray(+ [+ [10, 20, 30],+ [40, 50, 60]+ ],+ new arrow.FixedSizeList(3, new arrow.Field('rgb', new arrow.Uint8()))+ );+ const table = new arrow.Table({geometry, radius, colors});+ table.schema.fields[0].metadata.set('ARROW:extension:name', 'geoarrow.multipoint');+ const manager = new LayerManager(device, {+ viewport: new MapView().makeViewport({width: 400, height: 400, viewState: INITIAL_MAP_STATE})+ });+ let layer = new GeoArrowScatterplotLayer({+ id: 'ordinary-multipoint-vectors',+ data: table,+ getPosition: geometry,+ getRadius: radius,+ getFillColor: colors+ });+ try {+ manager.setLayers([layer]);+ const originalData = layer.getSubLayers()[0].props.data;+ layer = layer.clone({opacity: 0.5});+ manager.setLayers([layer]);+ t.equal(layer.getSubLayers()[0].props.data, originalData, 'uniform changes reuse batch data');+ const updates = [+ {updateTriggers: {getRadius: 1, getFillColor: 1}},+ {updateTriggers: {all: 1}},+ {dataComparator: () => false}+ ];+ updates.forEach((props, index) => {+ const value = 90 + index;+ radius.set(0, value);+ colors.set(0, [value, 1, 2]);+ layer = layer.clone(props);+ manager.setLayers([layer]);+ const attributes = layer.getSubLayers()[0].props.data.attributes;+ t.deepEqual(+ Array.from(attributes.getRadius.value),+ [value, value, 20],+ 'accessor, all-accessor and data invalidations refresh expanded radii'+ );+ t.deepEqual(+ Array.from(attributes.getFillColor.value),+ [value, 1, 2, value, 1, 2, 40, 50, 60],+ 'explicit invalidations refresh expanded colors'+ );+ });+ } finally {+ manager.finalize();+ t.end();+ }+});+test('#PointLayer -> constructor', t => {const TEST_CASES = {CREATE: [@@ -2379,3 +2540,475 @@ test('#PointLayer -> Glow and Pulse / Ripple rendering and saved settings', t =>);t.end();});++test('#PointLayer -> ordinary, continuous and event shaders compile and link in WebGL2', t => {+ const viewport = new MapView().makeViewport({+ width: 1,+ height: 1,+ viewState: {longitude: 0, latitude: 0, zoom: 1}+ });+ const manager = new LayerManager(device, {viewport});+ const sources = [];+ try {+ for (const extension of [null, new PulseRippleExtension(), new EventPulseRippleExtension()]) {+ const layer = new ScatterplotLayer({+ id: 'pulse-shader-compilation',+ data: [{position: [0, 0]}],+ extensions: extension ? [extension] : []+ });+ manager.setLayers([layer]);+ const model = layer.getModels()[0];+ sources.push({vs: model.vs, fs: model.fs});+ }+ } finally {+ manager.finalize();+ }+ // Keep native GL cleanup outside the test process: its Node 24 destructor can abort during GC.+ // NullDevice assembles deck.gl's complete shaders; this real GL compiler validates them.+ const result = spawnSync(+ process.execPath,+ [+ '-e',+ `+ const sources = JSON.parse(require('fs').readFileSync(0, 'utf8'));+ const gl = require('gl')(1, 1, {createWebGL2Context: true});+ if (!gl) throw new Error('Could not create a WebGL2 context');+ try {+ for (const {vs, fs} of sources) {+ const program = gl.createProgram();+ if (!program) throw new Error('Could not create a WebGL program');+ try {+ for (const [type, source] of [[gl.VERTEX_SHADER, vs], [gl.FRAGMENT_SHADER, fs]]) {+ const shader = gl.createShader(type);+ if (!shader) throw new Error('Could not create a WebGL shader');+ try {+ gl.shaderSource(shader, source);+ gl.compileShader(shader);+ if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {+ throw new Error(gl.getShaderInfoLog(shader) || 'Shader compilation failed');+ }+ gl.attachShader(program, shader);+ } finally {+ gl.deleteShader(shader);+ }+ }+ gl.linkProgram(program);+ if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {+ throw new Error(gl.getProgramInfoLog(program) || 'Shader linking failed');+ }+ } finally {+ gl.deleteProgram(program);+ }+ }+ process.stdout.write(String(sources.length));+ } finally {+ gl.getExtension('STACKGL_destroy_context').destroy();+ }+ `+ ],+ {input: JSON.stringify(sources), encoding: 'utf8', timeout: 30000}+ );+ t.equal(result.status, 0, result.stderr || 'shader compiler exits successfully');+ t.equal(result.stdout?.trim(), '3', 'ordinary, continuous and event shaders compile and link');+ t.end();+});++test('#PointLayer -> recorded events preserve points, filters and saved settings', async t => {+ const dataset = new KeplerTable({info: {id: 'events'}, color: [0, 0, 0]});+ const fields = [+ {name: 'lat', type: 'real'},+ {name: 'lng', type: 'real'},+ {name: 'started', type: 'timestamp', format: ''}+ ];+ await dataset.importData({+ data: {+ fields,+ rows: [+ [1, 2, 0],+ [3, 4, 2000],+ [5, 6, null],+ [7, 8, NaN]+ ]+ }+ });+ const layer = new PointLayer({dataId: dataset.id});+ layer.config.columns.lat = {value: 'lat', fieldIdx: 0};+ layer.config.columns.lng = {value: 'lng', fieldIdx: 1};+ layer.updateLayerVisConfig({+ pulseEnabled: true,+ pulseTrigger: 'event',+ pulseTimeField: 'started',+ pulseDurationMs: 1000+ });+ const datasets = {[dataset.id]: dataset};+ let data = layer.formatLayerData(datasets);+ const reportedCounts = [];+ const render = (time, filters = [eventTimeFilter(layer, time)]) =>+ layer.renderLayer({+ data,+ dataset,+ idx: 0,+ mapState: INITIAL_MAP_STATE,+ gpuFilter: dataset.gpuFilter,+ interactionConfig: INITIAL_VIS_STATE.interactionConfig,+ visible: true,+ layerCallbacks: {onFilteredItemsChange: event => reportedCounts.push(event)},+ filters,+ animationConfig: {currentTime: 500}+ });+ const isEvent = l => l.props.extensions.some(e => e instanceof EventPulseRippleExtension);+ t.notOk(layer.config.animation.enabled, 'event effects do not register a layer timeline');+ t.deepEqual(data.pulseTimeDomain, [0, 3000], 'effect lifetime includes the final tail');+ const matchingFilter = eventTimeFilter(layer, 500);+ for (const filters of [+ [],+ [{...matchingFilter, enabled: false}],+ [{...matchingFilter, type: 'range'}],+ [{...matchingFilter, dataId: ['another-dataset']}],+ [{...matchingFilter, name: ['another-field']}],+ [{...matchingFilter, value: [600, 500]}],+ [{...matchingFilter, value: [0, Infinity]}],+ [{...matchingFilter, value: []}]+ ]) {+ t.notOk(render(500, filters).some(isEvent), 'missing or invalid filter never uses layer time');+ t.equal(render(500, filters)[0].props.data.length, 4, 'inactive filter keeps ordinary points');+ }+ t.ok(+ render(500, [+ {...matchingFilter, dataId: ['other', dataset.id], name: ['other', 'started']}+ ]).some(isEvent),+ 'a synced multi-dataset filter matches the corresponding timestamp field'+ );+ const multiple = [matchingFilter, {...matchingFilter, id: 'second', value: [0, 800]}];+ t.equal(+ render(500, multiple).find(isEvent).props.pulseCurrentTime,+ 500,+ 'the first enabled matching filter supplies the window end'+ );+ t.equal(+ render(500, [...multiple].reverse()).find(isEvent).props.pulseCurrentTime,+ 800,+ 'filter order determines the playback clock without a selection'+ );+ for (const first of [+ {...matchingFilter, enabled: false},+ {...matchingFilter, type: 'range'},+ {...matchingFilter, dataId: ['another-dataset']},+ {...matchingFilter, name: ['another-field']}+ ]) {+ t.equal(+ render(500, [first, multiple[1]]).find(isEvent).props.pulseCurrentTime,+ 800,+ 'disabled or unrelated filters are skipped'+ );+ }+ t.equal(+ render(500, multiple.slice(1)).find(isEvent).props.pulseCurrentTime,+ 800,+ 'removing the first filter automatically uses the next matching filter'+ );+ t.deepEqual(data.getPulseStartTime({index: 0}), [0, 0, 1], 'epoch zero is a valid event');+ for (const index of [2, 3])+ t.deepEqual(+ data.getPulseStartTime({index}),+ [0, 0, 0],+ 'invalid time suppresses only its effect'+ );+ for (const time of [null, undefined, NaN, -1, 3000, 4000]) {+ const layers = render(time);+ t.notOk(layers.some(isEvent), 'no overlay outside the event domain or without a clock');+ t.equal(layers[0].props.data.length, 4, 'ordinary points remain');+ }+ for (const time of [0, 500, 500, 2500, 0]) {+ const layers = render(time);+ t.notOk(+ layers[0].props.extensions.some(+ e => e instanceof PulseRippleExtension || e instanceof EventPulseRippleExtension+ ),+ 'base points stay ordinary'+ );+ const overlay = layers.find(isEvent);+ t.ok(overlay, 'playback, pause, scrubbing and replay derive the overlay from the playhead');+ t.equal(overlay.props.pulseCurrentTime, time, 'overlay follows recorded time');+ t.notOk(overlay.props.pickable, 'overlay does not intercept point picking');+ t.equal(overlay.props.getFilterValue, data.getFilterValue, 'GPU filtering is preserved');+ t.deepEqual(+ overlay.props.filterRange,+ dataset.gpuFilter.filterRange,+ 'filter ranges are unchanged'+ );+ t.equal(overlay.props.getRadius, data.getRadius, 'radius mapping is shared');+ t.equal(overlay.props.getFillColor, data.getFillColor, 'color mapping is shared');+ reportedCounts.length = 0;+ layers.forEach(item => item.props.onFilteredItemsChange?.({id: item.id, count: 2}));+ t.deepEqual(reportedCounts, [{id: layer.id, count: 2}], 'only ordinary points report counts');+ }+ layer.updateLayerConfig({color: [0, 0, 255]});+ layer.updateLayerVisConfig({filled: false, outline: true, strokeColor: [255, 0, 0]});+ data = layer.formatLayerData(datasets, data);+ const outlined = render(500);+ const outlineCore = outlined.find(item => item.id === layer.id);+ const outlineEffect = outlined.find(isEvent);+ t.equal(+ outlineEffect.props.getFillColor,+ outlineCore.props.getLineColor,+ 'event uses outline color'+ );+ t.deepEqual(+ outlineEffect.props.updateTriggers.getFillColor,+ outlineCore.props.updateTriggers.getLineColor,+ 'outline color updates invalidate event colors'+ );+ layer.updateLayerVisConfig({strokeColor: [0, 255, 0]});+ data = layer.formatLayerData(datasets, data);+ t.deepEqual(+ render(500).find(isEvent).props.getFillColor,+ [0, 255, 0],+ 'event follows edited outline color'+ );+ layer.updateLayerVisConfig({outline: false});+ t.notOk(render(500).some(isEvent), 'no event effect when fill and outline are both disabled');+ layer.updateLayerVisConfig({filled: true});+ data = layer.formatLayerData(datasets, data);+ const viewport = new MapView().makeViewport({+ width: 400,+ height: 400,+ viewState: INITIAL_MAP_STATE+ });+ const manager = new LayerManager(device, {viewport});+ try {+ for (const glowEnabled of [false, true]) {+ for (const pulseMode of ['pulse', 'ripple']) {+ layer.updateLayerVisConfig({pulseMode, glowEnabled});+ const layers = render(500);+ const core = layers.find(l => l.id === layer.id);+ const halo = layers.find(l => l.id === `${layer.id}-glow`);+ t.equal(Boolean(halo), glowEnabled, 'event playback respects the independent Glow toggle');+ t.equal(core.props.data.length, 4, 'event playback with Glow preserves ordinary points');+ t.notOk(+ core.props.extensions.some(+ e => e instanceof PulseRippleExtension || e instanceof EventPulseRippleExtension+ ),+ 'event playback never animates the ordinary point core'+ );+ t.equal(layers.filter(isEvent).length, 1, 'only one event overlay is rendered');+ if (halo) {+ t.ok(+ halo.props.extensions.some(e => e instanceof PointGlowExtension),+ 'the halo retains its glow'+ );+ t.notOk(+ halo.props.extensions.some(+ e => e instanceof PulseRippleExtension || e instanceof EventPulseRippleExtension+ ),+ 'the halo stays static during event playback'+ );+ t.notOk(halo.props.pickable, 'the halo does not intercept ordinary point picking');+ }+ testRenderDeckLayer(t, `recorded ${pulseMode}, glow ${glowEnabled}`, layers, {+ layerManager: manager+ });+ }+ }+ t.ok(+ render(4000).some(l => l.id.endsWith('-glow')),+ 'Glow persists after events finish'+ );+ t.notOk(render(4000).some(isEvent), 'finished events do not keep an overlay alive');+ layer.updateLayerVisConfig({pulseEnabled: false});+ t.ok(+ render(500).some(l => l.id.endsWith('-glow')),+ 'disabling pulses preserves Glow'+ );+ t.notOk(render(500).some(isEvent), 'disabling pulses removes the event overlay');+ layer.updateLayerVisConfig({pulseEnabled: true, glowEnabled: false});+ } finally {+ manager.finalize();+ }+ const saved = visStateSchemaV1.save({+ ...INITIAL_VIS_STATE,+ layers: [layer],+ layerOrder: [layer.id]+ }).visState;+ const loaded = visStateSchemaV1.load(JSON.parse(JSON.stringify(saved))).visState;+ // Older PR previews may contain a filter selection; it no longer controls playback.+ loaded.layers[0].config.visConfig.pulseFilterId = 'second';+ const restored = testCreateLayerFromConfig(+ t,+ {layer: loaded.layers[0], datasets},+ {point: PointLayer}+ );+ for (const key of ['pulseTrigger', 'pulseTimeField', 'pulseDurationMs']) {+ t.equal(restored.config.visConfig[key], layer.config.visConfig[key], `restores ${key}`);+ }+ t.equal(+ restored.getEventPulseCurrentTime(multiple),+ 500,+ 'restored settings use the first matching filter despite an obsolete saved selection'+ );+ const accessor = data.getPulseStartTime;+ data = layer.formatLayerData(datasets, data);+ t.equal(data.getPulseStartTime, accessor, 'unchanged data reuses timestamp attributes');+ await dataset.update({fields, rows: [[1, 2, 8000]]});+ data = layer.formatLayerData(datasets, data);+ t.deepEqual(data.pulseTimeDomain, [8000, 9000], 'row replacement refreshes the effect lifetime');+ t.notEqual(data.getPulseStartTime, accessor, 'row replacement invalidates cached timestamps');+ for (const config of [+ {pulseEnabled: false},+ {pulseTrigger: 'continuous'},+ {pulseTimeField: 'missing'},+ {pulseTimeField: 'lat'},+ {pulseTimeField: 'started', pulseDurationMs: 0}+ ]) {+ layer.updateLayerVisConfig({+ pulseEnabled: true,+ pulseTrigger: 'event',+ pulseTimeField: 'started',+ pulseDurationMs: 1000+ });+ data = layer.formatLayerData(datasets, data);+ t.ok(data.getPulseStartTime, 'valid event mode prepares timestamps');+ layer.updateLayerVisConfig(config);+ data = layer.formatLayerData(datasets, data);+ t.notOk(+ layer.pulseTimeCache,+ 'inactive event mode releases cached timestamp and dataset references'+ );+ t.notOk(data.getPulseStartTime, 'inactive layer data no longer retains the timestamp accessor');+ t.notOk(layer.config.animation.enabled, 'inactive event mode never registers a layer timeline');+ t.equal(+ render(8500)[0].props.data.length,+ 1,+ 'invalid event configuration preserves ordinary points'+ );+ }+ t.end();+});++test('#PointLayer -> recorded playback only updates the clock', async t => {+ for (const arrowData of [false, true]) {+ const fields = [+ {name: 'lat', type: 'real'},+ {name: 'lng', type: 'real'},+ {name: 'time', type: 'timestamp', format: ''}+ ];+ const makeData = times => {+ const rows = times.map((time, index) => [index + 1, index + 2, time]);+ if (!arrowData) return {fields, rows};+ const table = new arrow.Table({+ lat: arrow.vectorFromArray(+ rows.map(row => row[0]),+ new arrow.Float64()+ ),+ lng: arrow.vectorFromArray(+ rows.map(row => row[1]),+ new arrow.Float64()+ ),+ time: arrow.vectorFromArray(times, new arrow.TimestampMillisecond())+ });+ return processArrowBatches(table.batches, {compact: false});+ };+ const dataset = new KeplerTable({info: {id: 'event-clock'}, color: [0, 0, 0]});+ await dataset.importData({data: makeData([1000, 2000])});+ const layer = new PointLayer({dataId: dataset.id});+ layer.config.columns.lat = {value: 'lat', fieldIdx: 0};+ layer.config.columns.lng = {value: 'lng', fieldIdx: 1};+ layer.updateLayerVisConfig({pulseEnabled: true, pulseTrigger: 'event', pulseTimeField: 'time'});+ let data;+ let reads = 0;+ const format = () => {+ data = layer.formatLayerData({[dataset.id]: dataset}, data);+ const getPulseStartTime = data.getPulseStartTime;+ data.getPulseStartTime = row => {+ reads++;+ return getPulseStartTime(row);+ };+ };+ format();+ const render = currentTime =>+ layer.renderLayer({+ data,+ dataset,+ idx: 0,+ mapState: INITIAL_MAP_STATE,+ gpuFilter: dataset.gpuFilter,+ interactionConfig: INITIAL_VIS_STATE.interactionConfig,+ visible: true,+ layerCallbacks: {},+ filters: [eventTimeFilter(layer, currentTime)]+ });+ const manager = new LayerManager(device, {+ viewport: new MapView().makeViewport({+ width: 400,+ height: 400,+ viewState: INITIAL_MAP_STATE+ })+ });+ const label = arrowData ? 'numeric Arrow points' : 'row points';+ try {+ manager.setLayers(render(1500));+ t.equal(reads, 2, `${label}: initial upload reads both timestamps`);+ reads = 0;+ for (const time of [1600, 1600, 1200]) {+ manager.setLayers(render(time));+ t.equal(reads, 0, `${label}: playback, pause and scrub reuse attributes`);+ }+ await dataset.update(makeData([1000, 1500, 2000]));+ format();+ manager.setLayers(render(1700));+ t.equal(reads, 3, `${label}: data replacement uploads new timestamps`);+ reads = 0;+ manager.setLayers(render(1800));+ t.equal(reads, 0, `${label}: replaced data is reused on the next tick`);+ } finally {+ manager.finalize();+ }+ }+ t.end();+});++test('#PointLayer -> Arrow timestamp units and invalid event data', async t => {+ const start = Date.UTC(2026, 10, 2);+ for (const type of [+ new arrow.TimestampSecond(),+ new arrow.TimestampMillisecond(),+ new arrow.TimestampMicrosecond(),+ new arrow.TimestampNanosecond()+ ]) {+ const source = new arrow.Table({+ time: arrow.vectorFromArray([start, null, start + 2000], type)+ });+ const dataset = new KeplerTable({info: {id: 'event-units'}, color: [0, 0, 0]});+ await dataset.importData({data: processArrowBatches(source.batches, {compact: false})});+ const layer = new PointLayer({dataId: dataset.id});+ layer.updateLayerVisConfig({+ pulseEnabled: true,+ pulseTrigger: 'event',+ pulseTimeField: 'time',+ pulseDurationMs: 500+ });+ const data = layer.updateEventAnimation(dataset);+ t.deepEqual(+ data.pulseTimeDomain,+ [start, start + 2500],+ `${type}: normalized milliseconds define the domain`+ );+ t.deepEqual(data.getPulseStartTime({index: 0}), [0, 0, 1], `${type}: first event is valid`);+ t.deepEqual(data.getPulseStartTime({index: 1}), [0, 0, 0], `${type}: null is not epoch zero`);+ t.deepEqual(+ data.getPulseStartTime({index: 2}),+ [2000, 0, 1],+ `${type}: elapsed milliseconds are preserved`+ );+ }+ const dataset = new KeplerTable({info: {id: 'empty-events'}, color: [0, 0, 0]});+ const fields = [{name: 'time', type: 'timestamp', format: ''}];+ const layer = new PointLayer({dataId: dataset.id});+ layer.updateLayerVisConfig({pulseEnabled: true, pulseTrigger: 'event', pulseTimeField: 'time'});+ for (const rows of [[], [[null], ['not-a-time'], [Infinity]]]) {+ await dataset.importData({data: {fields, rows}});+ const data = layer.updateEventAnimation(dataset);+ t.notOk(data.pulseTimeDomain, 'empty or wholly invalid events do not create a timeline');+ }+ t.end();+});diff --git a/test/fixtures/state-saved-v0.js b/test/fixtures/state-saved-v0.jsindex 92462668f..23afa83d6 100644--- a/test/fixtures/state-saved-v0.js+++ b/test/fixtures/state-saved-v0.js@@ -1079,7 +1079,10 @@ mergedLayer0.config = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000}};@@ -1238,7 +1241,10 @@ mergedLayer2.config = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000},animation: {enabled: false}};diff --git a/test/fixtures/state-saved-v1-3.js b/test/fixtures/state-saved-v1-3.jsindex 0be1aa596..ce374c1fa 100644--- a/test/fixtures/state-saved-v1-3.js+++ b/test/fixtures/state-saved-v1-3.js@@ -410,7 +410,10 @@ mergedLayer0.config = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000},animation: {enabled: false}};diff --git a/test/fixtures/state-saved-v1-4.js b/test/fixtures/state-saved-v1-4.jsindex d6a23da65..5bc88e6b0 100644--- a/test/fixtures/state-saved-v1-4.js+++ b/test/fixtures/state-saved-v1-4.js@@ -266,7 +266,10 @@ mergedLayer0.config = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000},animation: {enabled: false}};diff --git a/test/helpers/mock-state.js b/test/helpers/mock-state.jsindex cf687eef0..bf6f7d65c 100644--- a/test/helpers/mock-state.js+++ b/test/helpers/mock-state.js@@ -951,7 +951,10 @@ export const expectedSavedLayer1 = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000}},visualChannels: {@@ -1003,7 +1006,10 @@ export const expectedLoadedLayer1 = {pulseEnabled: false,pulseMode: 'pulse',pulseSpeed: 1,- pulseExpansion: 2+ pulseExpansion: 2,+ pulseTrigger: 'continuous',+ pulseTimeField: '',+ pulseDurationMs: 1000},colorField: {name: 'gps_data.types',diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.jsindex 93724832b..4aaf67f24 100644--- a/test/node/reducers/vis-state-test.js+++ b/test/node/reducers/vis-state-test.js@@ -26,7 +26,8 @@ import {setTimeFilterTimelineModeUpdater,setFilterAnimationTimeUpdater,setFilterAnimationWindowUpdater,- calculateLayerData+ calculateLayerData,+ computeDeckLayers} from '@kepler.gl/reducers';import {formatCsv} from '../../../src/reducers/src/export-utils';@@ -12455,3 +12456,174 @@ test('VisStateUpdater -> Arrow Int64 upserts match JSON keys and reject invalidt.deepEqual(Array.from(source.getChildAt(1)), [1, 2], 'source values remain unchanged');t.end();});++test('#visStateReducer -> Point events follow timestamp filters without a layer timeline', async t => {+ const dataset = new KeplerTable({info: {id: 'point-events'}, color: [0, 0, 0]});+ await dataset.importData({+ data: {+ fields: [+ {name: 'lat', type: 'real'},+ {name: 'lng', type: 'real'},+ {name: 'time', type: 'timestamp', format: ''}+ ],+ rows: [+ [1, 2, 1000],+ [3, 4, 2000]+ ]+ }+ });+ const point = new PointLayer({dataId: dataset.id});+ point.config.columns.lat = {value: 'lat', fieldIdx: 0};+ point.config.columns.lng = {value: 'lng', fieldIdx: 1};+ const datasets = {[dataset.id]: dataset};+ let state = {+ ...INITIAL_VIS_STATE,+ datasets,+ layers: [point],+ layerOrder: [point.id],+ layerData: [point.formatLayerData(datasets)]+ };+ const configure = config => {+ state = reducer(state, VisStateActions.layerVisConfigChange(state.layers[0], config));+ };+ const render = (current = state) =>+ computeDeckLayers(+ {visState: current, mapState: INITIAL_MAP_STATE, mapStyle: {}},+ {primaryMap: false}+ );+ const overlay = current => render(current).find(layer => layer.id === `${point.id}-event-pulse`);+ configure({+ pulseEnabled: true,+ pulseTrigger: 'event',+ pulseTimeField: 'time',+ pulseDurationMs: 1000+ });+ const animationConfig = state.animationConfig;+ t.equal(animationConfig.domain, null, 'choosing an event timestamp does not create a timeline');+ t.equal(+ getAnimatableVisibleLayers(state.layers).length,+ 0,+ 'event points are not standalone animated layers'+ );+ t.notOk(overlay(), 'no event overlay until a matching time filter exists');+ t.ok(+ render().some(layer => layer.id === point.id),+ 'ordinary point layer stays visible'+ );++ state = reducer(state, VisStateActions.addFilter(dataset.id));+ state = reducer(state, VisStateActions.setFilter(0, 'name', 'time'));+ const accessor = state.layerData[0].getPulseStartTime;+ for (const time of [1500, 1500, 1800, 1100, 1000]) {+ state = setFilterAnimationTimeUpdater(state, {idx: 0, prop: 'value', value: [1000, time]});+ t.equal(+ overlay().props.pulseCurrentTime,+ time - 1000,+ 'filter playback, pause, scrub and replay drive event time'+ );+ t.equal(+ state.layerData[0].getPulseStartTime,+ accessor,+ 'filter ticks reuse cached event attributes'+ );+ t.equal(+ state.animationConfig,+ animationConfig,+ 'unsynced filter leaves the layer clock unchanged'+ );+ }+ t.notOk(state.filters[0].syncedWithLayerTimeline, 'no timeline synchronization is required');+ const grouped = {...state, layerOrder: [{id: 'group', isVisible: true, layerOrder: [point.id]}]};+ t.equal(+ overlay(grouped).props.pulseCurrentTime,+ 0,+ 'grouped layers receive the filter clock too'+ );+ state = setFilterAnimationTimeUpdater(state, {idx: 0, prop: 'value', value: [1200, 1500]});+ t.deepEqual(state.filters[0].value, [1200, 1500], 'event playback does not widen a short window');+ const gpu = state.datasets[dataset.id].gpuFilter;+ const channel = state.filters[0].gpuChannel[0];+ t.ok(+ state.layerData[0].getFilterValue({index: 0})[channel] < gpu.filterRange[channel][0],+ 'filter still clips the first point'+ );+ configure({pulseDurationMs: 5000});+ t.equal(+ state.animationConfig,+ animationConfig,+ 'duration edits do not create or extend layer time'+ );+ t.deepEqual(state.filters[0].value, [1200, 1500], 'duration edits preserve the filter window');++ const renamed = reducer(state, VisStateActions.renameTableColumn(dataset.id, 'time', 'started'));+ t.equal(+ renamed.layers[0].config.visConfig.pulseTimeField,+ 'started',+ 'event field follows a rename'+ );+ t.ok(overlay(renamed), 'renamed filter still drives the event overlay');+ t.equal(state.layers[0].config.visConfig.pulseTimeField, 'time', 'rename preserves prior state');+ const removed = reducer(+ renamed,+ VisStateActions.updateDataset(dataset.id, {fields: dataset.fields.slice(0, 2), rows: [[1, 2]]})+ );+ t.notOk(overlay(removed), 'removing the event field stops effects');+ t.equal(removed.layerData[0].data.length, 1, 'ordinary points survive field removal');+ const replaced = reducer(+ state,+ VisStateActions.updateDataset(dataset.id, {+ fields: dataset.fields,+ rows: [+ [1, 2, 10000],+ [3, 4, 20000]+ ]+ })+ );+ t.deepEqual(+ replaced.layerData[0].pulseTimeDomain,+ [10000, 25000],+ 'replacement refreshes event timestamps and duration'+ );+ t.equal(replaced.animationConfig.domain, null, 'replacement does not create a layer timeline');+ const empty = reducer(+ state,+ VisStateActions.updateDataset(dataset.id, {fields: dataset.fields, rows: []})+ );+ t.notOk(overlay(empty), 'empty data has no event overlay');++ state = reducer(state, VisStateActions.setFilter(0, 'enabled', false));+ t.notOk(overlay(), 'disabled filter stops event effects');+ state = reducer(state, VisStateActions.setFilter(0, 'enabled', true));+ t.ok(overlay(), 'reenabled filter resumes its current effect phase');+ state = reducer(state, VisStateActions.removeFilter(0));+ t.notOk(overlay(), 'removing the filter stops event effects');+ t.ok(+ render().some(layer => layer.id === point.id),+ 'removing the filter preserves ordinary points'+ );++ const trip = new TripLayer({dataId: dataset.id});+ trip.config.animation = {enabled: true, domain: [0, 9000]};+ const tripClock = {...animationConfig, domain: [0, 9000], currentTime: 5000};+ state = {+ ...state,+ layers: [...state.layers, trip],+ layerData: [...state.layerData, {}],+ animationConfig: tripClock+ };+ for (const config of [+ {pulseDurationMs: 100},+ {pulseEnabled: false},+ {pulseTrigger: 'continuous'},+ {pulseEnabled: true}+ ]) {+ configure(config);+ t.equal(state.animationConfig, tripClock, 'event settings do not change a Trip layer clock');+ }+ t.deepEqual(+ getAnimatableVisibleLayers(state.layers).map(layer => layer.id),+ [trip.id],+ 'only the Trip layer contributes a standalone timeline'+ );+ t.end();+});