Skip to content

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

100 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

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, {
  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';
import {scaleQuantize} from 'd3-scale';
import cloneDeep from 'es-toolkit/compat/cloneDeep';
import * as arrow from 'apache-arrow';

import {DEFAULT_TEXT_LABEL, PROJECTED_PIXEL_SIZE_MULTIPLIER} from '@kepler.gl/constants';
import {EnhancedMultiIconLayer, EnhancedTextBackgroundLayer} from '@kepler.gl/deckgl-layers';
import {GeoArrowScatterplotLayer} from '@kepler.gl/deckgl-arrow-layers';
import {KeplerGlLayers} from '@kepler.gl/layers';
import {arrowSchemaToFields, processArrowBatches, processGeojson} from '@kepler.gl/processors';
import {
  findDefaultLayer,
  INITIAL_MAP_STATE,
  INITIAL_VIS_STATE,
  layerFilteredItemsChangeUpdater,
  renderDeckGlLayer
} from '@kepler.gl/reducers';
import {copyTableAndUpdate, KeplerTable} from '@kepler.gl/table';
import {hexToRgb} from '@kepler.gl/utils';

import {geoJsonWithStyle, geojsonData} from 'test/fixtures/geojson';
import testArcData, {pointFromNeighbor} from 'test/fixtures/test-arc-data';
import {StateWArcNeighbors} from 'test/helpers/mock-state';
import {createNewDataEntryMock} from 'test/helpers/table-utils';
import {
  testCreateCases,
  testCreateLayerFromConfig,
  testFormatLayerData,
  testFormatLayerDataCases,
  testRenderLayerCases,
  testRenderDeckLayer,
  testUpdateLayer,
  preparedDataset,
  dataId,
  testRows,
  pointLayerMeta,
  fieldDomain
} from 'test/helpers/layer-utils';

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 = [
      [99, 89, 99, 89, 99], // Padding excluded by the Arrow slices below.
      [10, 20, 30, 40, 5],
      [0, 0, 50, 60, -5],
      [null, 25, 70, null, 10],
      [-10, -20, -30, -40, 15],
      [99, 89, 99, 89, 99]
    ];
    const names = ['lng0', 'lat0', 'lng1', 'lat1', 'altitude'];
    const makeTable = values =>
      new arrow.Table(
        Object.fromEntries(
          names.map((name, index) => [
            name,
            arrow.vectorFromArray(
              values.map(row => row[index]),
              new arrow.Float64()
            )
          ])
        )
      );
    const source = makeTable(rows);
    const empty = new arrow.Table(
      new arrow.RecordBatch(
        Object.fromEntries(
          names.map(name => [
            name,
            arrow.makeData({type: new arrow.Float64(), data: new Float64Array(0)})
          ])
        )
      )
    );
    const first = source.slice(1, 2);
    const appended = new arrow.Table(source.schema, [
      ...first.batches,
      ...empty.batches,
      ...source.slice(2, 4).batches
    ]);
    const complete = new arrow.Table(source.schema, [
      ...appended.batches,
      ...source.slice(4, 5).batches
    ]);
    const dataset = new KeplerTable({info: {id: 'progressive-numeric'}, color: [0, 0, 0]});
    await dataset.importData({data: processArrowBatches(first.batches, {compact: false})});
    const layer = new LayerClass({dataId: dataset.id});
    const isPoint = LayerClass === PointLayer;
    layer.updateLayerConfig({
      columns: Object.fromEntries(
        (isPoint
          ? [
              ['lng', 0],
              ['lat', 1],
              ['altitude', 4]
            ]
          : names.slice(0, 4).map((name, index) => [name, index])
        ).map(([key, fieldIdx]) => [key, {value: names[fieldIdx], fieldIdx}])
      )
    });
    let formatted;
    for (const [label, table, compact] of [
      ['initial', first, false],
      ['appended', appended, false],
      ['appended again', complete, false],
      ['completed', complete, true],
      ['empty', empty, false]
    ]) {
      const data = processArrowBatches(table.batches, {compact});
      await dataset.update(compact ? data : {...data, arrowTable: table});
      dataset.filteredIndex = dataset.allIndexes.filter(index => index !== 1);
      const actualTable = dataset.dataContainer.getTable();
      const expectedLengths = compact ? [4] : table.batches.map(batch => batch.numRows);
      t.deepEqual(
        actualTable.batches.map(batch => batch.numRows),
        expectedLengths,
        `${label}: import batch lengths`
      );
      formatted = layer.formatLayerData({[dataset.id]: dataset}, formatted);
      const [composite] = layer.renderLayer({
        data: formatted,
        dataset,
        idx: 0,
        layerInteraction: {},
        mapState: INITIAL_MAP_STATE,
        gpuFilter: dataset.gpuFilter,
        interactionConfig: INITIAL_VIS_STATE.interactionConfig,
        visible: true,
        layerCallbacks: {}
      });
      let sublayers;
      t.doesNotThrow(() => {
        sublayers = composite.renderLayers();
      }, `${label}: constructs every Arrow sublayer without a batch-count assertion`);
      if (!sublayers) continue;
      t.deepEqual(
        sublayers.map(sublayer => sublayer.props.data.length),
        expectedLengths,
        `${label}: rendered batch lengths`
      );
      let offset = 0;
      for (const sublayer of sublayers) {
        const batchData = sublayer.props.data;
        for (let index = 0; index < batchData.length; index++) {
          const globalIndex = offset + index;
          const row = rows[globalIndex + 1];
          const expected = isPoint
            ? {getPosition: [row[0], row[1], row[4]]}
            : {getSourcePosition: [row[0], row[1], 0], getTargetPosition: [row[2], row[3], 0]};
          for (const [accessor, position] of Object.entries(expected)) {
            const attribute = batchData.attributes[accessor];
            t.deepEqual(
              Array.from(
                attribute.value.slice(index * attribute.size, (index + 1) * attribute.size)
              ),
              position.map(value => Number(value)),
              `${label}: ${accessor} remains aligned, including nullable coordinates`
            );
          }
          t.equal(
            sublayer.props.getFiltered(null, {index, data: batchData}),
            globalIndex === 1 ? 0 : 1,
            `${label}: filter uses global index`
          );
          const picked = composite.getPickingInfo({
            info: {index, picked: true},
            sourceLayer: sublayer
          });
          t.equal(picked.index, globalIndex, `${label}: picking uses global index`);
          t.deepEqual(
            layer.getHoverData(picked.object, dataset.dataContainer, dataset.fields, {}, picked),
            dataset.dataContainer.row(globalIndex),
            `${label}: hover reads the picked source row`
          );
        }
        offset += batchData.length;
      }
    }
    t.end();
  });
});

test('#PointLayer -> native separated points preserve every coordinate through import', async t => {
  for (const dimensions of [2, 3]) {
    for (const separated of [true, false]) {
      const names = ['x', 'y', 'z'].slice(0, dimensions);
      const type = separated
        ? new arrow.Struct(names.map(name => new arrow.Field(name, new arrow.Float64(), false)))
        : new arrow.FixedSizeList(dimensions, new arrow.Field('coords', new arrow.Float64()));
      const coordinates = [
        [10, 20, 5],
        [30, 40, 15],
        [50, 60, 25]
      ].map(p => p.slice(0, dimensions));
      const batches = [coordinates.slice(0, 2), coordinates.slice(2)].map(points => {
        const table = new arrow.Table({
          geometry: arrow.vectorFromArray(
            separated
              ? points.map(point => Object.fromEntries(names.map((name, i) => [name, point[i]])))
              : points,
            type
          )
        });
        table.schema.fields[0].metadata.set('ARROW:extension:name', 'geoarrow.point');
        return table;
      });
      const table = arrow.tableFromIPC(arrow.tableToIPC(batches[0].concat(batches[1]), 'file'));
      const originalBytes = arrow.tableToIPC(table, 'file');
      const dataset = new KeplerTable({info: {id: 'native-points'}, color: [0, 0, 0]});
      await dataset.importData({data: processArrowBatches(table.batches)});
      const [geojson] = findDefaultLayer(dataset, {geojson: KeplerGlLayers.GeojsonLayer});
      t.ok(geojson, 'native point metadata discovers the default GeoJSON layer');
      geojson.formatLayerData({[dataset.id]: dataset});
      t.deepEqual(
        Array.from(geojson.dataToFeature[0].points.positions.value),
        coordinates.flat(),
        'default GeoJSON positions contain every axis'
      );
      t.equal(geojson.dataToFeature[0].points.positions.size, dimensions, 'GeoJSON position size');
      t.deepEqual(
        geojson.meta.bounds,
        [10, 20, 50, 60],
        'GeoJSON bounds use longitude and latitude'
      );

      // Progressive imports retain unequal record batches, including Arrow slices.
      const sliced = table.slice(1);
      await dataset.update({cols: [sliced.getChildAt(0)], arrowTable: sliced});
      const layer = new PointLayer({dataId: dataset.id, columnMode: 'geoarrow'});
      layer.config.columns.geoarrow = {value: 'geometry', fieldIdx: 0};
      const formatted = layer.formatLayerData({[dataset.id]: dataset});
      const [composite] = layer.renderLayer({
        data: formatted,
        dataset,
        idx: 0,
        layerInteraction: {},
        mapState: INITIAL_MAP_STATE,
        gpuFilter: dataset.gpuFilter,
        interactionConfig: INITIAL_VIS_STATE.interactionConfig,
        visible: true,
        layerCallbacks: {}
      });
      const sublayers = composite.renderLayers();
      t.equal(sublayers.length, 2, 'Point retains both sliced batches');
      sublayers.forEach((sublayer, i) => {
        const position = sublayer.props.data.attributes.getPosition;
        t.deepEqual(
          Array.from(position.value),
          coordinates[i + 1],
          'Point positions include latitude and altitude'
        );
        t.equal(position.size, dimensions, 'Point position size');
        t.equal(
          composite.getPickingInfo({info: {index: 0}, sourceLayer: sublayer}).index,
          i,
          'picking remains aligned'
        );
      });
      t.deepEqual(layer.meta.bounds, [30, 40, 50, 60], 'Point bounds reflect the slice');
      t.deepEqual(arrow.tableToIPC(table, 'file'), originalBytes, 'rendering preserves the source');
    }
  }
  t.end();
});

['point', 'multipoint'].forEach(geometryType => {
  [false, true].forEach(gpu => {
    test(`#PointLayer -> batched Arrow ${geometryType} accessors (${
      gpu ? 'GPU' : 'CPU'
    })`, async t => {
      const pointType = new arrow.FixedSizeList(2, new arrow.Field('xy', new arrow.Float64()));
      const type =
        geometryType === 'multipoint'
          ? new arrow.List(new arrow.Field('points', pointType))
          : pointType;
      const coordinates =
        geometryType === 'multipoint'
          ? [
              [
                [
                  [0, 0],
                  [1, 1]
                ],
                [],
                [[2, 2]]
              ],
              [
                [
                  [3, 3],
                  [4, 4]
                ],
                [[5, 5]]
              ]
            ]
          : [
              [
                [0, 0],
                [1, 1],
                [2, 2]
              ],
              [
                [3, 3],
                [4, 4]
              ]
            ];
      const values = [
        [10, 50, 20],
        [90, 30]
      ];
      const batches = coordinates.map((coords, index) => {
        const table = new arrow.Table({
          geometry: arrow.vectorFromArray(coords, type),
          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;
      });
      // IPC buffers can contain alignment padding after the logical offsets.
      const table = arrow.tableFromIPC(arrow.tableToIPC(batches[0].concat(batches[1]), 'file'));
      const originalBytes = arrow.tableToIPC(table, 'file');
      const dataset = new KeplerTable({info: {id: 'batched'}, color: [0, 0, 0]});
      await dataset.importData({
        data: {
          fields: arrowSchemaToFields(table),
          cols: batches[0].schema.fields.map((field, index) => batches[0].getChildAt(index))
        }
      });
      // Progressive updates preserve batches; completed imports compact them.
      await dataset.update({
        cols: table.schema.fields.map((field, index) => table.getChildAt(index)),
        arrowTable: table
      });
      const layer = new PointLayer({dataId: dataset.id});
      layer.config.columnMode = 'geoarrow';
      layer.config.columns.geoarrow = {value: 'geometry', fieldIdx: 0};
      layer.config.colorField = dataset.fields[1];
      layer.config.sizeField = dataset.fields[1];
      layer.config.sizeScale = 'linear';
      layer.config.visConfig.radiusRange = [10, 90];
      layer.updateLayerDomain({[dataset.id]: dataset});
      dataset.filterTable(
        [
          {
            id: 'later-batch',
            dataId: ['unrelated', dataset.id],
            name: ['other', 'value'],
            fieldIdx: [0, 1],
            type: 'range',
            value: [80, 100],
            domain: [10, 90],
            enabled: true,
            fixedDomain: true,
            gpu,
            gpuChannel: [2, 0]
          }
        ],
        [layer]
      );
      const formatted = layer.formatLayerData({[dataset.id]: dataset});
      const onFilteredItemsChange = () => {};
      const render = () =>
        layer.renderLayer({
          data: formatted,
          dataset,
          idx: 0,
          layerInteraction: {},
          mapState: INITIAL_MAP_STATE,
          gpuFilter: dataset.gpuFilter,
          interactionConfig: INITIAL_VIS_STATE.interactionConfig,
          visible: true,
          layerCallbacks: {onFilteredItemsChange}
        });
      const rowIndices =
        geometryType === 'multipoint'
          ? [
              [0, 0, 2],
              [3, 3, 4]
            ]
          : [
              [0, 1, 2],
              [3, 4]
            ];
      for (const {pulseEnabled, glowEnabled} of [
        {pulseEnabled: false, glowEnabled: false},
        {pulseEnabled: false, glowEnabled: true},
        {pulseEnabled: true, glowEnabled: true},
        {pulseEnabled: true, glowEnabled: false},
        {pulseEnabled: false, glowEnabled: false}
      ]) {
        layer.updateLayerVisConfig({
          pulseEnabled,
          glowEnabled,
          glowExtent: 3,
          glowStrength: 0.7,
          pulseMode: 'ripple',
          pulseSpeed: 2,
          pulseExpansion: 3
        });
        const rendered = render();
        t.equal(rendered.length, glowEnabled ? 2 : 1, 'only enabled glow adds a renderer');
        for (const composite of rendered) {
          const isGlow = composite.id.endsWith('-glow');
          const sublayers = composite.renderLayers();
          t.equal(sublayers.length, 2, 'renders both Arrow record batches');
          sublayers.forEach((sublayer, batchIndex) => {
            const {props} = sublayer;
            t.equal(
              props.extensions.some(extension => extension instanceof PulseRippleExtension),
              pulseEnabled && !isGlow,
              'only the ordinary Arrow points animate'
            );
            t.equal(
              props.extensions.some(extension => extension instanceof PointGlowExtension),
              isGlow,
              'only the halo batch has glow shaders'
            );
            if (isGlow) {
              t.notOk(props.pickable, 'halo batches do not change picking');
              t.equal(props.glowExtent, 3, 'Arrow batch inherits extent');
              t.equal(props.glowStrength, 0.7, 'Arrow batch inherits strength');
              t.notOk(props.onFilteredItemsChange, 'halo batches do not report data counts');
            } else {
              t.equal(
                props.onFilteredItemsChange,
                onFilteredItemsChange,
                'core batches retain count reporting'
              );
            }
            t.equal(props.pulseMode, 'ripple', 'Arrow batch inherits effect style');
            t.equal(props.pulseSpeed, 2, 'Arrow batch inherits speed');
            t.equal(props.pulseExpansion, 3, 'Arrow batch inherits expansion');
            t.equal(
              props.data.length,
              rowIndices[batchIndex].length,
              'empty features add no points'
            );
            rowIndices[batchIndex].forEach((rowIndex, index) => {
              const context = {index, data: props.data, target: []};
              const expected = {index: rowIndex};
              t.equal(
                props.getRadius(null, context),
                formatted.getRadius(expected),
                'radius uses the feature row'
              );
              t.deepEqual(
                props.getFillColor(null, context),
                formatted.getFillColor(expected),
                'color uses the feature row'
              );
              t.equal(
                props.getFiltered(null, context),
                formatted.getFiltered(expected),
                'CPU mask uses the feature row'
              );
              const filterValues = props.getFilterValue(null, context);
              t.deepEqual(
                filterValues,
                formatted.getFilterValue(expected),
                'GPU values use the feature row'
              );
              const [min, max] = dataset.gpuFilter.filterRange[0];
              const visible =
                Boolean(props.getFiltered(null, context)) &&
                filterValues[0] >= min &&
                filterValues[0] <= max;
              t.equal(visible, rowIndex === 3, 'only the matching later-batch feature is visible');
              const picked = composite.getPickingInfo({info: {index}, sourceLayer: sublayer});
              t.equal(picked.index, rowIndex, 'rendered attributes agree with the picked feature');
            });
          });
          t.equal(
            sublayers[1].props.getRadius(null, {
              index: 0,
              data: sublayers[1].props.data,
              target: []
            }),
            90,
            'later batch reads 90 rather than the first batch value 10'
          );
        }
      }
      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,
        getPosition: table.getChild('geometry'),
        getRadius: table.getChild('value')
      });
      vectorLayer.renderLayers().forEach((sublayer, batchIndex) => {
        t.deepEqual(
          Array.from(sublayer.props.data.attributes.getRadius.value),
          rowIndices[batchIndex].map(index => values.flat()[index]),
          'vector radius uses the correct row across unequal batches'
        );
      });
      t.deepEqual(
        arrow.tableToIPC(table, 'file'),
        originalBytes,
        'rendering preserves source data'
      );
      t.end();
    });
  });
});

test('#PointLayer -> MultiPoint IPC offset padding and vector attributes', async t => {
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('xy', new arrow.Float64()));
  const type = new arrow.List(new arrow.Field('points', pointType));
  const colorType = new arrow.FixedSizeList(3, new arrow.Field('rgb', new arrow.Uint8()));
  const cases = [
    {name: 'two rows', coords: [[[0, 0]], [[1, 1]]]},
    {name: 'three rows', coords: [[[0, 0]], [[1, 1]], [[2, 2]]]},
    {name: 'empty first row', coords: [[], [[1, 1]]]},
    {name: 'empty last row', coords: [[[0, 0]], []]},
    {name: 'all empty', coords: [[], []]}
  ];
  for (const {name, coords} of cases) {
    const values = coords.map((_, index) => 10 + index * 40);
    const colors = values.map(value => [value, value + 1, value + 2]);
    const input = new arrow.Table({
      geometry: arrow.vectorFromArray(coords, type),
      value: arrow.vectorFromArray(values, new arrow.Float32()),
      color: arrow.vectorFromArray(colors, colorType)
    });
    input.schema.fields[0].metadata.set('ARROW:extension:name', 'geoarrow.multipoint');
    const bytes = arrow.tableToIPC(input, 'file');
    const table = arrow.tableFromIPC(bytes);
    const originalBytes = bytes.slice();
    const dataset = new KeplerTable({info: {id: name}, color: [0, 0, 0]});
    await dataset.importData({data: processArrowBatches(table.batches)});
    const layer = new PointLayer({dataId: dataset.id, columnMode: 'geoarrow'});
    layer.config.columns.geoarrow = {value: 'geometry', fieldIdx: 0};
    layer.config.sizeField = dataset.fields[1];
    layer.config.sizeScale = 'linear';
    layer.config.visConfig.radiusRange = [10, values[values.length - 1]];
    layer.updateLayerDomain({[dataset.id]: dataset});
    const formatted = layer.formatLayerData({[dataset.id]: dataset});
    const [composite] = layer.renderLayer({
      data: formatted,
      dataset,
      idx: 0,
      layerInteraction: {},
      mapState: INITIAL_MAP_STATE,
      gpuFilter: dataset.gpuFilter,
      interactionConfig: INITIAL_VIS_STATE.interactionConfig,
      visible: true,
      layerCallbacks: {}
    });
    const [sublayer] = composite.renderLayers();
    const rowIndices = coords.flatMap((points, index) => points.map(() => index));
    t.equal(sublayer.props.data.length, rowIndices.length, `${name}: empty rows add no points`);
    rowIndices.forEach((row, index) => {
      const context = {index, data: sublayer.props.data, target: []};
      t.equal(sublayer.props.getRadius(null, context), values[row], `${name}: correct radius`);
      t.equal(sublayer.props.getFiltered(null, context), 1, `${name}: point remains visible`);
      t.equal(
        composite.getPickingInfo({info: {index}, sourceLayer: sublayer}).index,
        row,
        `${name}: correct picked row`
      );
    });
    const vectorLayer = new GeoArrowScatterplotLayer({
      id: `${name}-vectors`,
      data: table,
      getPosition: table.getChild('geometry'),
      getRadius: table.getChild('value'),
      getFillColor: table.getChild('color')
    });
    const [vectorSublayer] = vectorLayer.renderLayers();
    t.deepEqual(
      Array.from(vectorSublayer.props.data.attributes.getRadius.value),
      rowIndices.map(index => values[index]),
      `${name}: expands numeric Arrow attributes`
    );
    t.deepEqual(
      Array.from(vectorSublayer.props.data.attributes.getFillColor.value),
      rowIndices.flatMap(index => colors[index]),
      `${name}: expands vector Arrow attributes`
    );
    t.deepEqual(bytes, originalBytes, `${name}: leaves the source IPC buffer unchanged`);
    t.deepEqual(arrow.tableToIPC(table, 'file'), originalBytes, `${name}: preserves source values`);
  }
  t.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: [
      {
        props: {
          dataId: 'smoothie',
          isVisible: true,
          label: 'test point layer'
        },
        test: layer => {
          t.ok(layer.config.dataId === 'smoothie', 'PointLayer dataId should be correct');
          t.ok(layer.type === 'point', 'type should be point');
          t.equal(layer.config.visConfig.pulseEnabled, false, 'point animation is off by default');
          t.ok(layer.isAggregated === false, 'PointLayer is not aggregated');
          t.ok(layer.config.label === 'test point layer', 'label should be correct');
          t.deepEqual(
            layer.columnPairs,
            {
              lat: {pair: ['lng', 'altitude'], fieldPairKey: 'lat'},
              lng: {pair: ['lat', 'altitude'], fieldPairKey: 'lng'},
              altitude: {pair: ['lng', 'lat'], fieldPairKey: 'altitude'}
            },
            'columnPairs should be correct'
          );
        }
      }
    ]
  };

  testCreateCases(t, PointLayer, TEST_CASES.CREATE);
  t.end();
});

test('#PointLayer -> formatLayerData', t => {
  const filteredIndex = [0, 2, 4];
  const filterDomain0 = 1474071056000;
  const TEST_CASES = [
    {
      name: 'Point gps point.1',
      layer: {
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: 'id'
          },
          textLabel: [
            {
              field: {
                name: 'types',
                type: 'string'
              }
            },
            {
              field: {
                name: 'has_result',
                type: 'boolean'
              }
            }
          ],
          visConfig: {
            strokeColor: [1, 2, 3]
          }
        },
        type: 'point',
        id: 'test_layer_1'
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;

        const expectedLayerData = {
          textLabels: [
            {
              characterSet: [],
              getText: () => {}
            },
            {
              characterSet: [],
              getText: () => {}
            }
          ],
          data: [
            {
              index: 0,
              position: [testRows[0][2], testRows[0][1], testRows[0][7]]
            },
            {
              index: 4,
              position: [testRows[4][2], testRows[4][1], testRows[4][7]]
            }
          ],
          getFilterValue: () => {},
          getFiltered: () => {},
          getFillColor: () => {},
          getLineColor: () => {},
          getRadius: () => {},
          getPosition: () => {}
        };

        t.deepEqual(
          Object.keys(layerData).sort(),
          Object.keys(expectedLayerData).sort(),
          'layerData should have 7 keys'
        );
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct point layerData data'
        );
        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [testRows[0][2], testRows[0][1], testRows[0][7]],
          'getPosition should return correct position'
        );
        // getFillColor
        t.deepEqual(
          layerData.getFillColor,
          layer.config.color,
          'getFillColor should be a constant'
        );
        // getLineColor
        t.deepEqual(layerData.getLineColor, [1, 2, 3], 'getLineColor should be a constant');
        // getRadius
        t.equal(layerData.getRadius, 1, 'getRadius should be a constant');
        // getFilterValue
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [Number.MIN_SAFE_INTEGER, 0, 0, 0],
            [moment.utc(testRows[4][0]).valueOf() - filterDomain0, 0, 0, 0]
          ],
          'getFilterValue should return [0, 0, 0, 0]'
        );
        // textLabels
        t.deepEqual(
          layerData.textLabels.length,
          expectedLayerData.textLabels.length,
          'textLabels should have 2 items'
        );
        t.deepEqual(
          layerData.textLabels[0].characterSet,
          ['d', 'r', 'i', 'v', 'e', '_', 'a', 'n', 'l', 'y', 't', 'c', 's', '0'],
          'textLabels should have correct characterSet'
        );
        t.deepEqual(
          layerData.textLabels[0].getText(layerData.data[0]),
          'driver_analytics_0',
          'textLabels getText should have correct text'
        );
        // layerMeta
        t.deepEqual(layer.meta, pointLayerMeta, 'should format correct point layer meta');
      }
    },
    {
      name: 'Test gps point.2 Data colorFields. sizeField and fixedRadius',
      layer: {
        type: 'point',
        id: 'test_layer_2',
        config: {
          dataId,
          label: 'some point file',
          columns: {
            lat: 'lat',
            lng: 'lng'
          },
          visConfig: {
            outline: true,
            fixedRadius: true,
            colorRange: {
              colors: ['#010101', '#020202', '#030303']
            },
            strokeColor: [4, 5, 6]
          },
          // color by id(integer)
          colorField: {
            type: 'integer',
            name: 'id'
          },
          // size by id(integer)
          sizeField: {
            type: 'integer',
            name: 'id'
          }
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [testRows[0][2], testRows[0][1], 0]
            },
            {
              index: 4,
              position: [testRows[4][2], testRows[4][1], 0]
            }
          ],
          getFilterValue: () => {},
          getFiltered: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        t.deepEqual(layer.config.colorDomain, fieldDomain.id, 'should update layer color domain');
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should filter out nulls, format correct point layerData'
        );
        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [testRows[0][2], testRows[0][1], 0],
          'getPosition should return correct lat lng'
        );
        // layerMeta
        t.deepEqual(layer.meta, pointLayerMeta, 'should format correct layerMeta');
        // getFillColor
        t.deepEqual(
          layerData.getFillColor(layerData.data[0]),
          [1, 1, 1],
          'getFillColor should return correct color'
        );
        // getLineColor
        t.deepEqual(layerData.getLineColor, [4, 5, 6], 'getLineColor should return correct color');
        // getRadius
        // domain [1, 12124]
        t.equal(layerData.getRadius(layerData.data[0]), 1, 'getRadius should return fixed radius');
      }
    },
    {
      name: 'Test gps point.2 Data strokeColorFields and SizeField',
      layer: {
        type: 'point',
        id: 'test_layer_2',
        config: {
          dataId,
          label: 'some point file',
          columns: {
            lat: 'lat',
            lng: 'lng'
          },
          color: [10, 10, 10],
          visConfig: {
            outline: true,
            colorRange: {
              colors: ['#010101', '#020202', '#030303']
            },
            strokeColorRange: {
              colors: ['#040404', '#050505', '#060606']
            },
            strokeColor: [4, 5, 6],
            radiusRange: [10, 100]
          },
          // color by id(integer)
          strokeColorField: {
            type: 'integer',
            name: 'id'
          },
          // size by id(integer)
          sizeField: {
            type: 'integer',
            name: 'id'
          }
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;

        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [testRows[0][2], testRows[0][1], 0]
            },
            {
              index: 4,
              position: [testRows[4][2], testRows[4][1], 0]
            }
          ],
          getFilterValue: () => {},
          getFiltered: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };

        t.deepEqual(
          Object.keys(layerData).sort(),
          Object.keys(expectedLayerData).sort(),
          'layerData should have 6 keys'
        );
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct point layerData data'
        );
        t.deepEqual(
          layer.config.sizeDomain,
          [fieldDomain.id[0], fieldDomain.id[fieldDomain.id.length - 1]],
          'should update layer sizeDomain'
        );
        // getFillColor
        t.deepEqual(
          layerData.getFillColor,
          [10, 10, 10],
          'getFillColor should return correct color'
        );
        // getLineColor
        t.deepEqual(
          layerData.getLineColor(layerData.data[0]),
          [4, 4, 4],
          'getLineColor should return correct color'
        );
        // getRadius
        // domain [1, 12124]
        // range [10, 100]
        t.equal(
          layerData.getRadius(layerData.data[0]),
          10,
          'getRadius should return corrent radius'
        );
      }
    },
    {
      name: 'Test gps point.2 Data with fixed radius and null SizeField',
      layer: {
        type: 'point',
        id: 'test_layer_2',
        config: {
          dataId,
          label: 'some point file',
          columns: {
            lat: 'lat',
            lng: 'lng'
          },
          color: [10, 10, 10],
          visConfig: {
            outline: true,
            fixedRadius: true
          },
          // size by id(integer)
          sizeField: null
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;

        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [testRows[0][2], testRows[0][1], 0]
            },
            {
              index: 4,
              position: [testRows[4][2], testRows[4][1], 0]
            }
          ],
          getFilterValue: () => {},
          getFiltered: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };

        t.deepEqual(
          Object.keys(layerData).sort(),
          Object.keys(expectedLayerData).sort(),
          'layerData should have 6 keys'
        );
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct point layerData data'
        );
        t.deepEqual(layer.config.sizeDomain, [0, 1], 'should update layer sizeDomain');
        // getRadius should be a constant because sizeField is null
        t.equal(layerData.getRadius, 1, 'getRadius should return current radius');
      }
    },
    {
      name: 'Arc data from neighbors',
      layer: pointFromNeighbor,
      datasets: StateWArcNeighbors.visState.datasets,
      assert: result => {
        const {layerData} = result;
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [testArcData[0].longitude, testArcData[0].latitude, 0],
              neighbors: testArcData[0].neighbors
            },
            {
              index: 1,
              position: [testArcData[1].longitude, testArcData[1].latitude, 0],
              neighbors: testArcData[1].neighbors
            }
          ]
        };

        for (let i = 0; i < 2; i++) {
          t.deepEqual(
            layerData.data[i],
            expectedLayerData.data[i],
            'should format correct point layerData data with neighbors'
          );
        }
      }
    },
    {
      name: 'Test gps point.2 Data colorFields, domainStops',
      layer: {
        type: 'point',
        id: 'test_layer_2',
        config: {
          dataId,
          label: 'some point file',
          columns: {
            lat: 'lat',
            lng: 'lng'
          },
          visConfig: {
            outline: true,
            fixedRadius: true,
            colorRange: {
              colors: ['#010101', '#020202', '#030303', '#040404', '#050505', '#060606', '#070707']
            },
            strokeColor: [4, 5, 6]
          },
          // color by id(integer)
          colorField: {
            type: 'integer',
            name: 'id'
          },
          colorScale: 'quantize'
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layer} = result;
        layer.config.colorDomain = {
          z: [2, 3, 4, 5],
          stops: [
            [0, 20],
            [0, 30],
            [0, 40],
            [0, 50]
          ]
        };

        const layerData = layer.formatLayerData({
          [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
        });

        // get scale function
        const getFillColor0 = layerData.getFillColor(1);
        const getFillColor = layerData.getFillColor(1);
        t.equal(layerData.getFillColorByZoom, true, 'should set getFillColorByZoom to truthy');
        t.equal(getFillColor0, getFillColor, 'function should be memoized');

        const expectedScale = scaleQuantize()
          .domain([0, 20])
          .range(layer.config.visConfig.colorRange.colors);

        const expectedColors = [
          hexToRgb(expectedScale(preparedDataset.dataContainer.row(0).valueAt(7))),
          [0, 0, 0, 0],
          hexToRgb(expectedScale(preparedDataset.dataContainer.row(2).valueAt(7))),
          hexToRgb(expectedScale(preparedDataset.dataContainer.row(3).valueAt(7))),
          hexToRgb(expectedScale(preparedDataset.dataContainer.row(4).valueAt(7))),
          hexToRgb(expectedScale(preparedDataset.dataContainer.row(5).valueAt(7)))
        ];
        for (let i = 0; i < 6; i++) {
          t.deepEqual(
            getFillColor({
              data: preparedDataset.dataContainer.row(i),
              index: i
            }),
            expectedColors[i],
            `Should get corrent value from zoom scale for ${preparedDataset.dataContainer
              .row(i)
              .valueAt(7)}`
          );
        }
        // should use domain [0, 20]
      }
    }
  ];

  testFormatLayerDataCases(t, PointLayer, TEST_CASES);
  t.end();
});

test('#PointLayer -> renderLayer', t => {
  const filteredIndex = [0, 2, 4];
  const TEST_CASES = [
    {
      name: 'Test render point.1',
      layer: {
        id: 'test_layer_1',
        type: 'point',
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: null
          },
          strokeColorField: {
            type: 'string',
            name: 'types'
          },
          color: [1, 2, 3],
          visConfig: {
            strokeColorRange: {
              colors: ['#040404', '#050505', '#060606']
            },
            thickness: 3
          }
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: (deckLayers, layer) => {
        t.equal(deckLayers.length, 1, 'Should create 1 deck.gl layer');
        const {props} = deckLayers[0];
        const expectedProps = {
          opacity: layer.config.visConfig.opacity,
          stroked: layer.config.visConfig.outline,
          filled: layer.config.visConfig.filled,
          radiusScale: layer.getRadiusScaleByZoom(INITIAL_MAP_STATE),
          lineWidthScale: layer.config.visConfig.thickness,
          filterRange: preparedDataset.gpuFilter.filterRange
        };
        Object.keys(expectedProps).forEach(key => {
          t.deepEqual(props[key], expectedProps[key], `should have correct props.${key}`);
        });
      }
    },
    {
      name: 'Point gps point.1 with text labels',
      layer: {
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: 'id'
          },
          textLabel: [
            {
              field: {
                name: 'types',
                type: 'string'
              }
              // default anchor: start, alignment: center
            },
            {
              field: {
                name: 'has_result',
                type: 'boolean'
              },
              anchor: 'middle',
              alignment: 'bottom'
            }
          ],
          visConfig: {
            strokeColor: [1, 2, 3]
          }
        },
        type: 'point',
        id: 'test_layer_1'
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: (deckLayers, layer, layerData) => {
        t.equal(deckLayers.length, 5, 'Should create 5 deck.gl layer');
        t.deepEqual(
          deckLayers.map(l => l.id),
          [
            'test_layer_1',
            'test_layer_1-label-types',
            'test_layer_1-label-types-characters',
            'test_layer_1-label-has_result',
            'test_layer_1-label-has_result-characters'
          ],
          'Should create 5 deck.gl layers'
        );
        // test test_layer_1-label-types-characters
        const {getPosition, getColor, getSize, getPixelOffset, getFilterValue} =
          deckLayers[2].props;
        const {getPixelOffset: getPixelOffset1} = deckLayers[4].props;

        const distanceScale = getDistanceScales(INITIAL_MAP_STATE);
        const radiusScale = layer.getRadiusScaleByZoom(INITIAL_MAP_STATE);
        const pixelRadius =
          radiusScale * distanceScale.unitsPerMeter[0] * zoomToScale(INITIAL_MAP_STATE.zoom);

        const padding = 20;

        // anchor: start, alignment: center
        const expectedPixelOffset0 = [1 * (pixelRadius + padding), 0 * (pixelRadius + padding + 0)];

        // anchor: 'middle', alignment: 'bottom'
        const expectedPixelOffset1 = [
          0 * (pixelRadius + padding),
          1 * (pixelRadius + padding + DEFAULT_TEXT_LABEL.size)
        ];

        t.deepEqual(
          getPosition(layerData.data[0]),
          [testRows[0][2], testRows[0][1], 1],
          'Should calculate correct getPosition'
        );
        t.deepEqual(getColor, DEFAULT_TEXT_LABEL.color, 'Should calculate correct getColor');
        t.deepEqual(getSize, PROJECTED_PIXEL_SIZE_MULTIPLIER, 'Should calculate correct getSize');
        t.deepEqual(
          getPixelOffset,
          expectedPixelOffset0,
          'Should calculate correct instancePixelOffset'
        );
        t.deepEqual(
          getPixelOffset1,
          expectedPixelOffset1,
          'Should calculate correct instancePixelOffset'
        );
        t.deepEqual(
          getFilterValue(layerData.data[0]),
          [Number.MIN_SAFE_INTEGER, 0, 0, 0],
          'Should calculate correct instancePixelOffset'
        );
        t.notOk(
          (deckLayers[1].props.extensions || []).some(
            ext => ext.constructor.extensionName === 'CollisionFilterExtension'
          ),
          'Should not add CollisionFilterExtension when collision is off'
        );
        t.notOk(
          deckLayers[1].props.collisionEnabled,
          'Should leave collision filtering disabled by default'
        );
      }
    },
    {
      name: 'Point gps point.1 with text labels and collision filtering',
      layer: {
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: 'id'
          },
          textLabel: [
            {
              field: {
                name: 'types',
                type: 'string'
              },
              collisionEnabled: true
            }
          ]
        },
        type: 'point',
        id: 'test_layer_1'
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: deckLayers => {
        const labelLayer = deckLayers.find(l => l.id === 'test_layer_1-label-types-collision');
        t.ok(labelLayer, 'Should create a text label layer');
        t.ok(
          labelLayer.props.extensions.some(
            ext => ext.constructor.extensionName === 'CollisionFilterExtension'
          ),
          'Should add CollisionFilterExtension to the text label layer'
        );
        t.equal(labelLayer.props.collisionEnabled, true, 'Should enable collision filtering');
        t.equal(
          labelLayer.props.collisionGroup,
          'test_layer_1-text-label-0',
          'Should use a per-label collision group'
        );
        t.equal(
          labelLayer.constructor.layerName,
          'CollisionTextLayer',
          'Should use CollisionTextLayer so the hit area covers the anchor'
        );
        t.equal(labelLayer.props.background, true, 'Should enable a collision background');
        t.equal(
          labelLayer.props.collisionShowBackground,
          false,
          'Should hide the collision-only background in the color pass'
        );
      }
    },
    {
      name: 'Point gps point.1 with text labels, collision filtering and visible background',
      layer: {
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: 'id'
          },
          textLabel: [
            {
              field: {
                name: 'types',
                type: 'string'
              },
              background: true,
              collisionEnabled: true
            }
          ]
        },
        type: 'point',
        id: 'test_layer_1'
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: deckLayers => {
        const labelLayer = deckLayers.find(l => l.id === 'test_layer_1-label-types-collision');
        t.ok(labelLayer, 'Should create a text label layer');
        t.equal(
          labelLayer.constructor.layerName,
          'CollisionTextLayer',
          'Should use CollisionTextLayer so the hit area covers the anchor'
        );
        t.equal(labelLayer.props.background, true, 'Should keep the user background enabled');
        t.equal(
          labelLayer.props.collisionShowBackground,
          true,
          'Should still draw the user background in the color pass'
        );
      }
    },
    {
      name: 'Point gps point.1 with text labels, color and sizeField',
      layer: {
        config: {
          dataId,
          label: 'gps point',
          columns: {
            lat: 'lat',
            lng: 'lng',
            altitude: 'id'
          },
          textLabel: [
            {
              field: {
                name: 'types',
                type: 'string'
              },
              color: [2, 2, 2],
              size: 10,
              anchor: 'start',
              alignment: 'bottom'
            }
          ],
          // size by id(integer)
          sizeField: {
            type: 'integer',
            name: 'id'
          },
          visConfig: {
            strokeColor: [1, 2, 3]
          }
        },
        type: 'point',
        id: 'test_layer_1'
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: (deckLayers, layer, layerData) => {
        t.deepEqual(
          deckLayers.map(l => l.id),
          ['test_layer_1', 'test_layer_1-label-types', 'test_layer_1-label-types-characters'],
          'Should create 3 deck.gl layers'
        );
        // test test_layer_1-label-types
        const {getColor, getSize, getPixelOffset} = deckLayers[2].props;

        const distanceScale = getDistanceScales(INITIAL_MAP_STATE);
        const radiusScale = layer.getRadiusScaleByZoom(INITIAL_MAP_STATE);
        const pixelRadius =
          radiusScale * distanceScale.unitsPerMeter[0] * zoomToScale(INITIAL_MAP_STATE.zoom);

        const padding = 20;

        // anchor: start, alignment: center
        const getRadius = layerData.getRadius(layerData.data[1]);

        const expectedPixelOffset1 = [
          getRadius * pixelRadius + padding,
          getRadius * pixelRadius + padding + 10
        ];
        t.deepEqual(getColor, [2, 2, 2], 'Should calculate correct getColor');
        t.deepEqual(getSize, PROJECTED_PIXEL_SIZE_MULTIPLIER, 'Should calculate correct getSize');
        t.deepEqual(
          getPixelOffset(layerData.data[1]),
          expectedPixelOffset1,
          'Should calculate correct instancePixelOffset multiplied by getRadius'
        );
      }
    }
  ];

  testRenderLayerCases(t, PointLayer, TEST_CASES);
  t.end();
});

test('#PointLayer -> renderLayer split map label visibility', t => {
  const filteredIndex = [0, 2, 4];
  const tc = {
    layer: {
      config: {
        dataId,
        label: 'gps point',
        columns: {
          lat: 'lat',
          lng: 'lng',
          altitude: 'id'
        },
        textLabel: [
          {
            field: {
              name: 'types',
              type: 'string'
            }
          }
        ]
      },
      type: 'point',
      id: 'test_layer_1'
    },
    datasets: {
      [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
    }
  };

  const layer = testCreateLayerFromConfig(t, tc, {point: PointLayer});
  const data = testFormatLayerData(t, layer, tc.datasets);

  const renderWithMapLayers = mapLayers =>
    renderDeckGlLayer(
      {
        datasets: tc.datasets,
        layer,
        layerIndex: 0,
        data,
        mapState: INITIAL_MAP_STATE,
        interactionConfig: INITIAL_VIS_STATE.interactionConfig,
        mapLayers
      },
      {}
    );

  const assertVisible = (deckLayers, expected, message) => {
    const labelLayers = deckLayers.filter(l => String(l.id).includes('-label-'));
    t.ok(labelLayers.length > 0, `should create text label layers (${message})`);
    t.equal(deckLayers[0].props.visible, expected, `geometry ${message}`);
    labelLayers.forEach(l => {
      t.equal(l.props.visible, expected, `${l.id} ${message}`);
    });
  };

  assertVisible(
    renderWithMapLayers(undefined),
    true,
    'should be visible when mapLayers is not set'
  );
  assertVisible(
    renderWithMapLayers({[layer.id]: true}),
    true,
    'should be visible when the panel entry is true'
  );
  assertVisible(
    renderWithMapLayers({[layer.id]: false}),
    false,
    'should be hidden when the panel entry is false'
  );
  assertVisible(renderWithMapLayers({}), false, 'should be hidden when the panel entry is missing');

  t.end();
});

test('#PointLayer -> renderLayer globe mode text labels', t => {
  const tc = {
    layer: {
      config: {
        dataId,
        label: 'gps point',
        columns: {
          lat: 'lat',
          lng: 'lng',
          altitude: 'id'
        },
        textLabel: [
          {
            field: {
              name: 'types',
              type: 'string'
            },
            background: true
          }
        ]
      },
      type: 'point',
      id: 'test_layer_1'
    },
    datasets: {
      [dataId]: preparedDataset
    }
  };

  const layer = testCreateLayerFromConfig(t, tc, {point: PointLayer});
  const data = testFormatLayerData(t, layer, tc.datasets);

  const renderWithMapState = mapState =>
    renderDeckGlLayer(
      {
        datasets: tc.datasets,
        layer,
        layerIndex: 0,
        data,
        mapState,
        interactionConfig: INITIAL_VIS_STATE.interactionConfig
      },
      {}
    ).find(l => String(l.id).includes('-label-'));

  const flatLabel = renderWithMapState(INITIAL_MAP_STATE);
  t.ok(flatLabel, 'should create a text label layer in flat mode');
  t.equal(
    flatLabel.props.parameters.depthTest,
    false,
    'should not depth-test labels outside globe mode'
  );
  t.notOk('cull' in flatLabel.props.parameters, 'should not touch culling outside globe mode');
  t.notOk(
    flatLabel.props._subLayerProps.characters,
    'should not override the glyph sublayer outside globe mode'
  );
  t.equal(
    flatLabel.props._subLayerProps.background.parameters.depthTest,
    false,
    'should not depth-test the label background outside globe mode'
  );

  // globe mode sets a global `cull: true`, which would otherwise discard the glyph quads
  const globeLabel = renderWithMapState({...INITIAL_MAP_STATE, globe: {enabled: true}});
  t.equal(globeLabel.props.parameters.cull, false, 'should disable culling in globe mode');
  t.equal(
    globeLabel.props.parameters.depthTest,
    true,
    'should depth-test labels against the globe depth disk'
  );
  t.equal(
    globeLabel.props.parameters.depthMask,
    false,
    'should not write depth so labels do not occlude each other'
  );
  t.equal(
    globeLabel.props._subLayerProps.characters.type,
    EnhancedMultiIconLayer,
    'should render glyphs with the globe back-face culling sublayer'
  );
  t.equal(
    globeLabel.props._subLayerProps.background.type,
    EnhancedTextBackgroundLayer,
    'should render the label background with the globe back-face culling sublayer'
  );
  t.equal(
    globeLabel.props._subLayerProps.background.parameters.depthTest,
    true,
    'should depth-test the label background against the globe depth disk'
  );
  t.equal(
    globeLabel.props._subLayerProps.background.parameters.depthMask,
    false,
    'should not write depth from the label background'
  );

  t.end();
});

test('#PointLayer -> updateLayer', t => {
  const layerConfig = {
    id: 'test1',
    type: 'point',
    config: {
      dataId,
      label: 'some point file',
      columns: {
        lat: 'lat',
        lng: 'lng'
      },
      visConfig: {
        outline: true,
        filled: true,
        colorRange: {
          colors: ['#010101', '#020202', '#030303']
        },
        strokeColor: [4, 5, 6]
      }
    },
    visualChannels: {
      // color by id(integer)
      colorField: {
        type: 'string',
        name: 'types'
      },
      // size by id(integer)
      sizeField: {
        type: 'integer',
        name: 'id'
      }
    }
  };

  const shouldUpdate = {
    gpuFilter: {},
    dynamicGpuFilter: {instanceRadius: true}
  };

  testUpdateLayer(t, {layerConfig, shouldUpdate});
  t.end();
});

test('#PointLayer -> formatLayerData -> Geojson column mode', async t => {
  // create a mockup GeoJson dataset with Point and MultiPoint geometry
  const geoJsonWithMultiPoint = cloneDeep(geoJsonWithStyle);
  geoJsonWithMultiPoint.features.push({
    type: 'Feature',
    properties: {
      fillColor: [1, 2, 3],
      lineColor: [4, 5, 6],
      lineWidth: 1,
      elevation: 10,
      radius: 5
    },
    geometry: {
      type: 'MultiPoint',
      coordinates: [
        [-122.0, 37.4],
        [-121.9, 37.5]
      ]
    }
  });

  const geoJsonWithGeometryCollection = cloneDeep(geoJsonWithStyle);
  geoJsonWithGeometryCollection.features.push({
    type: 'Feature',
    properties: {
      fillColor: [1, 2, 3],
      lineColor: [4, 5, 6],
      lineWidth: 1,
      elevation: 10,
      radius: 5
    },
    geometry: {
      type: 'GeometryCollection',
      geometries: [
        {
          type: 'Point',
          coordinates: [-121.8, 37.6]
        },
        {
          type: 'MultiPoint',
          coordinates: [
            [-122.0, 37.4],
            [-121.9, 37.5]
          ]
        }
      ]
    }
  });

  const geoJsonWithNull = cloneDeep(geoJsonWithStyle);

  const geojsonPointDataset = processGeojson(geoJsonWithStyle);
  const geojsonPolygonDataset = processGeojson(geojsonData);
  const geojsonMultiPolygonDataset = processGeojson(geoJsonWithMultiPoint);
  const geojsonGeometryCollectionDataset = processGeojson(geoJsonWithGeometryCollection);

  // mockup invalid geojson object or string geojson object
  const geojsonPointWithNullDataset = processGeojson(geoJsonWithNull);
  geojsonPointWithNullDataset.rows.push([undefined, [7, 8, 9], [4, 5, 6], 3, 10, 5]);
  geojsonPointWithNullDataset.rows.push(['', [7, 8, 9], [4, 5, 6], 3, 10, 5]);

  const TEST_CASES = [
    {
      name: 'Geojson point.1',
      layer: {
        type: 'point',
        id: 'test_geojson_layer_1',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columnMode: 'geojson',
          columns: {
            geojson: '_geojson'
          }
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: geojsonPointDataset
      }),
      assert: result => {
        const {layerData} = result;
        // ! layerData is empty here
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [-122.1, 37.3]
            },
            {
              index: 1,
              position: [-122.2, 37.2]
            },
            {
              index: 2,
              position: [-122.3, 37.1]
            }
          ],
          getFilterValue: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );

        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [-122.1, 37.3],
          'getPosition should return correct lat lng'
        );
      }
    },
    {
      name: 'Geojson polygon.2',
      layer: {
        type: 'point',
        id: 'test_geojson_layer_2',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columnMode: 'geojson',
          columns: {
            geojson: '_geojson'
          }
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: geojsonPolygonDataset
      }),
      assert: result => {
        const {layerData} = result;
        const expectedLayerData = {
          data: [],
          getFilterValue: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        // empty data since Point layer only supports GeoJson column with Point geometries
        t.equal(layerData.data.length, 0, 'geojson layerData.data should be empty');
      }
    },
    {
      name: 'Geojson point.3',
      layer: {
        type: 'point',
        id: 'test_geojson_layer_3',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columnMode: 'geojson',
          columns: {
            geojson: '_geojson'
          }
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: geojsonMultiPolygonDataset
      }),
      assert: result => {
        const {layerData} = result;
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [-122.1, 37.3]
            },
            {
              index: 1,
              position: [-122.2, 37.2]
            },
            {
              index: 2,
              position: [-122.3, 37.1]
            },
            {
              index: 3,
              position: [-122.0, 37.4]
            },
            {
              index: 3,
              position: [-121.9, 37.5]
            }
          ],
          getFilterValue: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [-122.1, 37.3],
          'getPosition should return correct lat lng'
        );
      }
    },
    {
      name: 'Geojson GeometryCollection point.4',
      layer: {
        type: 'point',
        id: 'test_geojson_layer_4',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columnMode: 'geojson',
          columns: {
            geojson: '_geojson'
          }
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: geojsonGeometryCollectionDataset
      }),
      assert: result => {
        const {layerData} = result;
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [-122.1, 37.3]
            },
            {
              index: 1,
              position: [-122.2, 37.2]
            },
            {
              index: 2,
              position: [-122.3, 37.1]
            },
            {
              index: 3,
              position: [-121.8, 37.6]
            },
            {
              index: 3,
              position: [-122.0, 37.4]
            },
            {
              index: 3,
              position: [-121.9, 37.5]
            }
          ],
          getFilterValue: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [-122.1, 37.3],
          'getPosition should return correct lat lng'
        );
      }
    },
    {
      name: 'Geojson with null point.5',
      layer: {
        type: 'point',
        id: 'test_geojson_layer_5',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columnMode: 'geojson',
          columns: {
            geojson: '_geojson'
          }
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: geojsonPointWithNullDataset
      }),
      assert: result => {
        const {layerData} = result;
        const expectedLayerData = {
          data: [
            {
              index: 0,
              position: [-122.1, 37.3]
            },
            {
              index: 1,
              position: [-122.2, 37.2]
            },
            {
              index: 2,
              position: [-122.3, 37.1]
            }
          ],
          getFilterValue: () => {},
          getLineColor: () => {},
          getFillColor: () => {},
          getRadius: () => {},
          getPosition: () => {},
          textLabels: []
        };
        t.deepEqual(
          Object.keys(layerData).sort,
          Object.keys(expectedLayerData).sort,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        // getPosition
        t.deepEqual(
          layerData.getPosition(layerData.data[0]),
          [-122.1, 37.3],
          'getPosition should return correct lat lng'
        );
      }
    }
  ];

  testFormatLayerDataCases(t, PointLayer, TEST_CASES);
  t.end();
});

test('#PointLayer -> Glow and Pulse / Ripple rendering and saved settings', t => {
  const datasets = {[dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex: [0, 2, 4]})};
  const layer = testCreateLayerFromConfig(
    t,
    {
      layer: {
        type: 'point',
        id: 'pulse-point',
        config: {
          dataId,
          columns: {lat: 'lat', lng: 'lng'},
          colorField: {name: 'id', type: 'integer'},
          sizeField: {name: 'id', type: 'integer'},
          visConfig: {outline: true, opacity: 0.6},
          textLabel: [{field: {name: 'types', type: 'string'}}]
        }
      },
      datasets
    },
    {point: PointLayer}
  );
  const data = testFormatLayerData(t, layer, datasets);
  let filteredState = {...INITIAL_VIS_STATE, layers: [layer]};
  const onFilteredItemsChange = event => {
    filteredState = layerFilteredItemsChangeUpdater(filteredState, {layer, event});
  };
  // Simulate DataFilterExtension notifications in draw order, without requiring a GPU.
  const reportCounts = (deckLayers, count) => {
    deckLayers.forEach(deckLayer => {
      deckLayer.props.onFilteredItemsChange?.({id: deckLayer.id, count});
    });
  };
  const render = (globe = false, mapLayers) =>
    renderDeckGlLayer(
      {
        datasets,
        layer,
        layerIndex: 0,
        data,
        mapState: {...INITIAL_MAP_STATE, globe: {enabled: globe}},
        interactionConfig: {
          ...INITIAL_VIS_STATE.interactionConfig,
          brush: {...INITIAL_VIS_STATE.interactionConfig.brush, enabled: true}
        },
        hoverInfo: {picked: true, layer: {props: {id: layer.id}}, object: data.data[0], index: 0},
        mapLayers
      },
      {onFilteredItemsChange}
    );
  const hasAnimation = deckLayer =>
    deckLayer.props.extensions.some(extension => extension instanceof PulseRippleExtension);
  t.notOk(hasAnimation(render()[0]), 'default points use the unchanged renderer');
  for (const globe of [false, true]) {
    const viewport = new (globe ? _GlobeView : MapView)().makeViewport({
      width: 800,
      height: 600,
      viewState: {longitude: -122.4, latitude: 37.75, zoom: 10}
    });
    const manager = new LayerManager(device, {viewport});
    try {
      const regular = render(globe);
      testRenderDeckLayer(t, 'regular point before animation', regular, {layerManager: manager});
      const snapshot = deckLayers =>
        deckLayers
          .filter(deckLayer => deckLayer.id === layer.id || deckLayer.id === `${layer.id}-hovered`)
          .map(deckLayer => ({
            id: deckLayer.id,
            props: Object.fromEntries(
              [
                'data',
                'getPosition',
                'getRadius',
                'getFillColor',
                'getLineColor',
                'getFilterValue',
                'filterRange',
                'brushingEnabled',
                'brushingRadius',
                'radiusScale',
                'radiusMaxPixels',
                'radiusMinPixels',
                'radiusUnits',
                'lineWidthScale',
                'lineWidthUnits',
                'filled',
                'stroked',
                'billboard',
                'opacity',
                'pickable',
                'parameters'
              ].map(key => [key, deckLayer.props[key]])
            ),
            attributes: Object.fromEntries(
              [
                'instancePositions',
                'instanceRadius',
                'instanceFillColors',
                'instancePickingColors'
              ].map(key => [
                key,
                deckLayer.getAttributeManager().getAttributes()[key].value?.slice()
              ])
            ),
            vs: deckLayer.state.model.vs,
            fs: deckLayer.state.model.fs
          }));
      const baseline = snapshot(regular);
      t.equal(baseline.length, 2, 'regular points include the hover renderer');
      t.ok(regular[0].props.brushingEnabled, 'brushing is active in this regression case');
      const assertRegular = deckLayers => {
        t.deepEqual(
          snapshot(deckLayers),
          baseline,
          'restores regular point and hover shaders, attributes and rendering settings'
        );
        t.equal(
          deckLayers[0].getPickingInfo({info: {index: 0}}).object,
          data.data[0],
          'regular picking still returns the filtered point'
        );
        t.notOk(hasAnimation(deckLayers[0]), 'regular points have no animation extension');
        t.notOk(hasAnimation(deckLayers[1]), 'regular hover has no animation extension');
      };
      assertRegular(regular);
      t.equal(layer.config.visConfig.glowEnabled, false, 'glow is off for older maps');
      const assertGlow = deckLayers => {
        const halos = deckLayers.filter(deckLayer => deckLayer.id.endsWith('-glow'));
        t.equal(halos.length, 2, 'adds a halo behind the point and hover renderers');
        for (const halo of halos) {
          const core = deckLayers.find(deckLayer => `${deckLayer.id}-glow` === halo.id);
          t.ok(deckLayers.indexOf(halo) < deckLayers.indexOf(core), 'halo is behind its core');
          t.notOk(halo.props.pickable, 'halo does not expand the picking area');
          t.notOk(halo.props.onFilteredItemsChange, 'halo does not report data counts');
          if (core.id === layer.id) {
            t.equal(
              core.props.onFilteredItemsChange,
              onFilteredItemsChange,
              'core keeps count reporting'
            );
          }
          t.notOk(halo.props.parameters.depthWriteEnabled, 'halo does not occlude other points');
          t.notOk(hasAnimation(halo), 'halo stays static with either animation mode');
          for (const key of [
            'data',
            'getPosition',
            'getRadius',
            'getFillColor',
            'getLineColor',
            'getFilterValue',
            'filterRange',
            'brushingEnabled',
            'brushingRadius',
            'radiusScale',
            'radiusMinPixels',
            'radiusMaxPixels',
            'radiusUnits',
            'lineWidthScale',
            'lineWidthUnits',
            'stroked',
            'billboard',
            'opacity',
            'visible'
          ]) {
            // Both halo channels use the point fill; outline width is still respected.
            if (key !== 'getLineColor') {
              t.deepEqual(halo.props[key], core.props[key], `halo preserves ${key}`);
            }
          }
          t.ok(
            halo.props.extensions.some(e => e instanceof PointGlowExtension),
            'halo shader enabled'
          );
          t.notOk(
            core.props.extensions.some(e => e instanceof PointGlowExtension),
            'ordinary core shader unchanged'
          );
        }
        const labels = deckLayers.filter(deckLayer => deckLayer.id.includes('-label-'));
        t.ok(labels.length, 'labels remain available');
        labels.forEach(label =>
          t.notOk(
            label.props.extensions.some(e => e instanceof PointGlowExtension),
            'labels have no glow'
          )
        );
      };
      // A saved map can first draw with glow enabled, before any core count is recorded.
      layer.filteredItemCount = {};
      layer.updateLayerVisConfig({glowEnabled: true, glowExtent: 3, glowStrength: 0.7});
      const glowing = render(globe);
      testRenderDeckLayer(t, 'glowing points', glowing, {layerManager: manager});
      assertGlow(glowing);
      reportCounts(glowing, 3);
      t.equal(layer.getFilteredItemCount(), 3, 'initial count is correct with glow enabled');
      t.deepEqual(
        snapshot(glowing),
        baseline,
        'glow leaves core/hover shaders, attributes and props unchanged'
      );
      const core = glowing.find(deckLayer => deckLayer.id === layer.id);
      t.equal(
        core.getPickingInfo({info: {index: 0}}).object,
        data.data[0],
        'glow preserves core picking'
      );
      t.ok(
        render(globe, {[layer.id]: false}).every(deckLayer => !deckLayer.props.visible),
        'hidden points and halos stay hidden'
      );
      layer.updateLayerVisConfig({glowEnabled: false});
      const disabledGlow = render(globe);
      testRenderDeckLayer(t, 'disabled glow', disabledGlow, {layerManager: manager});
      assertRegular(disabledGlow);
      reportCounts(disabledGlow, 1);
      t.equal(
        layer.getFilteredItemCount(),
        1,
        'count updates after glow is removed and GPU filters change'
      );
      t.equal(disabledGlow.length, regular.length, 'disabled glow removes its renderers');
      t.equal(layer.config.visConfig.glowExtent, 3, 'disabling retains extent');
      t.equal(layer.config.visConfig.glowStrength, 0.7, 'disabling retains strength');
      for (const pulseMode of ['pulse', 'ripple']) {
        layer.updateLayerVisConfig({
          pulseEnabled: true,
          pulseMode,
          pulseSpeed: 2,
          pulseExpansion: 3
        });
        const deckLayers = render(globe);
        testRenderDeckLayer(t, `point ${pulseMode}`, deckLayers, {layerManager: manager});
        const points = deckLayers[0];
        t.ok(hasAnimation(points), 'point renderer enables the effect');
        t.ok(hasAnimation(deckLayers[1]), 'hover renderer enables the same effect');
        t.equal(
          points.getNumInstances(),
          regular[0].props.data.length,
          'all filtered points remain drawable'
        );
        t.equal(
          points.getPickingInfo({info: {index: 0}}).object,
          data.data[0],
          'animated picking returns the same filtered point'
        );
        t.equal(points.props.pulseMode, pulseMode, 'selected effect reaches the renderer');
        t.equal(points.props.data, data.data, 'animation reuses filtered point data');
        t.equal(points.props.getRadius, data.getRadius, 'animation preserves radius mapping');
        t.equal(points.props.getFillColor, data.getFillColor, 'animation preserves color mapping');
        t.equal(
          points.props.getFilterValue,
          data.getFilterValue,
          'animation preserves GPU filters'
        );
        const labels = deckLayers.filter(deckLayer => deckLayer.id.includes('-label-'));
        t.ok(labels.length, 'text labels remain available');
        labels.forEach(label => t.notOk(hasAnimation(label), 'labels do not pulse'));
        t.equal(
          render(globe, {[layer.id]: false})[0].props.visible,
          false,
          'hidden points stay hidden'
        );
        const animatedBaseline = snapshot(deckLayers);
        layer.updateLayerVisConfig({glowEnabled: true});
        const combined = render(globe);
        testRenderDeckLayer(t, 'glow with animation', combined, {layerManager: manager});
        assertGlow(combined);
        reportCounts(combined, 2);
        t.equal(layer.getFilteredItemCount(), 2, 'count updates after glow is reenabled');
        t.deepEqual(snapshot(combined), animatedBaseline, 'glow preserves existing animation');
        layer.updateLayerVisConfig({glowEnabled: false, pulseEnabled: false});
        const staticLayers = render(globe);
        testRenderDeckLayer(t, 'disabled pulse', staticLayers, {layerManager: manager});
        assertRegular(staticLayers);
        reportCounts(staticLayers, 0);
        t.equal(
          layer.getFilteredItemCount(),
          0,
          'empty filter results update after glow is disabled again'
        );
        t.equal(layer.config.visConfig.pulseExpansion, 3, 'turning off retains effect settings');
      }
    } finally {
      manager.finalize();
    }
  }
  layer.updateLayerVisConfig({pulseEnabled: true, glowEnabled: true});
  const saved = visStateSchemaV1.save({
    ...INITIAL_VIS_STATE,
    layers: [layer],
    layerOrder: [layer.id]
  }).visState;
  const loaded = visStateSchemaV1.load(JSON.parse(JSON.stringify(saved))).visState;
  const restored = testCreateLayerFromConfig(
    t,
    {layer: loaded.layers[0], datasets},
    {point: PointLayer}
  );
  for (const key of [
    'pulseEnabled',
    'pulseMode',
    'pulseSpeed',
    'pulseExpansion',
    'glowEnabled',
    'glowExtent',
    'glowStrength'
  ]) {
    t.equal(restored.config.visConfig[key], layer.config.visConfig[key], `restores ${key}`);
  }
  layer.updateLayerVisConfig({filled: false, outline: true, fixedRadius: true, billboard: true});
  const outlined = render();
  const halo = outlined.find(deckLayer => deckLayer.id === `${layer.id}-glow`);
  const point = outlined.find(deckLayer => deckLayer.id === layer.id);
  t.equal(halo.props.getFillColor, point.props.getLineColor, 'unfilled halo uses outline colors');
  t.deepEqual(
    halo.props.updateTriggers.getFillColor,
    point.props.updateTriggers.getLineColor,
    'outline color changes refresh the halo'
  );
  t.equal(
    halo.props.radiusMaxPixels,
    point.props.radiusMaxPixels,
    'fixed radii retain pixel limits'
  );
  t.equal(halo.props.radiusUnits, point.props.radiusUnits, 'fixed radii retain units');
  t.equal(halo.props.billboard, true, 'halo follows billboard orientation');
  layer.updateLayerVisConfig({outline: false});
  t.notOk(
    render().some(deckLayer => deckLayer.id.endsWith('-glow')),
    'invisible fill and outline have no halo'
  );
  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();
});