Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
fix(layers): handle WKB GeometryCollection imports (#3870)
Igor Dykhta5a72e13c809b
diff --git a/src/layers/src/geojson-layer/geojson-utils.spec.ts b/src/layers/src/geojson-layer/geojson-utils.spec.tsindex 95bc13dc3..00d6523c7 100644--- a/src/layers/src/geojson-layer/geojson-utils.spec.ts+++ b/src/layers/src/geojson-layer/geojson-utils.spec.ts@@ -1,8 +1,363 @@// SPDX-License-Identifier: MIT// Copyright contributors to the kepler.gl project-import {Feature} from 'geojson';-import {featureToHoverOutline} from './geojson-utils';+import {Feature, Geometry} from 'geojson';+import {convertGeometryToWKB} from '@loaders.gl/gis';+import {GeoJsonLayer as DeckGLGeoJsonLayer} from '@deck.gl/layers';+import {GEOARROW_EXTENSIONS} from '@kepler.gl/constants';+import {GEOARROW_METADATA_KEY} from '@kepler.gl/constants';+import {KeplerTable, copyTableAndUpdate} from '@kepler.gl/table';+import {processFileData} from '@kepler.gl/processors';+import * as arrow from 'apache-arrow';+import GeoJsonLayer from './geojson-layer';+import {+ featureToHoverOutline,+ parseGeoJsonRawFeature,+ getGeojsonFeatureTypes,+ getGeojsonBounds+} from './geojson-utils';++// Exercise deck.gl's real data conversion without creating a WebGL context.+function renderGeojsonFeatures(data: Feature[]) {+ const layer = new DeckGLGeoJsonLayer({data});+ layer.initializeState();+ jest.spyOn(layer, 'setState').mockImplementation(update => {+ Object.assign(layer.state, update);+ });+ layer.updateState({+ props: layer.props,+ oldProps: layer.props,+ context: layer.context,+ changeFlags: {+ dataChanged: 'initial data',+ propsChanged: false,+ updateTriggersChanged: false,+ extensionsChanged: false,+ viewportChanged: false,+ stateChanged: false,+ propsOrDataChanged: true,+ somethingChanged: true+ }+ });+ return layer.state.features;+}++describe('WKB GeometryCollection', () => {+ test.each([null, {}, 'invalid'])(+ 'ignores malformed collection members in geometry-type metadata (%j)',+ geometries => {+ expect(+ getGeojsonFeatureTypes([+ {+ type: 'Feature',+ properties: {},+ geometry: {type: 'GeometryCollection', geometries}+ } as any+ ])+ ).toEqual({});+ }+ );+ const geometry: Geometry = {+ type: 'GeometryCollection',+ geometries: [+ {type: 'Point', coordinates: [1, 2]},+ {+ type: 'GeometryCollection',+ geometries: [+ {+ type: 'LineString',+ coordinates: [+ [3, 4],+ [5, 6]+ ]+ },+ {type: 'GeometryCollection', geometries: []}+ ]+ }+ ]+ };+ const bytes = () => new Uint8Array(convertGeometryToWKB(geometry));++ test.each(['bytes', 'buffer', 'hex', 'offset view', 'GeoArrow'])(+ 'preserves nested and empty collections from %s',+ format => {+ const wkb = bytes();+ const padded = new Uint8Array(wkb.length + 8);+ padded.set(wkb, 4);+ const value =+ format === 'hex'+ ? Buffer.from(wkb).toString('hex')+ : format === 'buffer'+ ? wkb.buffer+ : format === 'offset view'+ ? padded.subarray(4, -4)+ : wkb;+ expect(+ parseGeoJsonRawFeature(value, format === 'GeoArrow' ? GEOARROW_EXTENSIONS.WKB : undefined)+ ?.geometry+ ).toEqual(geometry);+ }+ );++ test('accepts a big-endian collection header and SRID metadata', () => {+ const littleEndian = bytes();+ const bigEndian = littleEndian.slice();+ const view = new DataView(bigEndian.buffer);+ view.setUint8(0, 0);+ view.setUint32(1, 7, false);+ view.setUint32(5, 2, false);+ expect(parseGeoJsonRawFeature(bigEndian)?.geometry).toEqual(geometry);++ const ewkb = new Uint8Array(littleEndian.length + 4);+ ewkb.set(littleEndian.subarray(0, 5));+ ewkb.set(littleEndian.subarray(5), 9);+ const ewkbView = new DataView(ewkb.buffer);+ ewkbView.setUint32(1, 0x20000007, true);+ ewkbView.setUint32(5, 4326, true);+ expect(parseGeoJsonRawFeature(ewkb)?.geometry).toEqual(geometry);+ });++ test('rejects malformed or excessively nested collections without throwing', () => {+ const wkb = bytes();+ const badOrder = wkb.slice();+ badOrder[0] = 2;+ const badCount = wkb.slice();+ new DataView(badCount.buffer).setUint32(5, 0xffffffff, true);+ const extra = new Uint8Array(wkb.length + 1);+ extra.set(wkb);+ let deep: Geometry = {type: 'Point', coordinates: [1, 2]};+ for (let i = 0; i < 40; i++) deep = {type: 'GeometryCollection', geometries: [deep]};+ for (const value of [+ new Uint8Array(),+ wkb.subarray(0, 8),+ wkb.subarray(0, -1),+ badOrder,+ badCount,+ extra,+ new Uint8Array(convertGeometryToWKB(deep))+ ]) {+ expect(() => parseGeoJsonRawFeature(value)).not.toThrow();+ expect(parseGeoJsonRawFeature(value)).toBeNull();+ }+ });++ test.each(['Arrow hex', 'Arrow WKB', 'GeoParquet'])(+ 'imports collections through %s with row IDs, hover, filters and cache reuse',+ async format => {+ const point: Geometry = {type: 'Point', coordinates: [50, 60]};+ const values = [geometry, point].map(value => new Uint8Array(convertGeometryToWKB(value)));+ let table = new arrow.Table({+ _geojson:+ format === 'Arrow hex'+ ? arrow.vectorFromArray(+ values.map(value => Buffer.from(value).toString('hex')),+ new arrow.Utf8()+ )+ : arrow.vectorFromArray(values, new arrow.Binary()),+ label: arrow.vectorFromArray(['collection', 'point'], new arrow.Utf8())+ });+ if (format === 'Arrow WKB')+ table.schema.fields[0].metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB);+ if (format === 'GeoParquet') {+ table.schema.metadata.set(+ 'geo',+ JSON.stringify({+ version: '1.1.0',+ primary_column: '_geojson',+ columns: {_geojson: {encoding: 'WKB'}}+ })+ );+ const specifier = 'parquet-wasm/node';+ const imported = await import(specifier);+ const wasm = imported.readParquet ? imported : imported.default;+ const properties = new wasm.WriterPropertiesBuilder()+ .setKeyValueMetadata(table.schema.metadata)+ .build();+ const parquet = wasm.writeParquet(+ wasm.Table.fromIPCStream(arrow.tableToIPC(table, 'stream')),+ properties+ );+ table = arrow.tableFromIPC(wasm.readParquet(parquet).intoIPCStream());+ } else table = arrow.tableFromIPC(arrow.tableToIPC(table, 'stream'));+ const [file] = await processFileData({+ content: {+ fileName: format === 'GeoParquet' ? 'collections.parquet' : 'collections.arrow',+ data: table.batches+ },+ fileCache: []+ } as any);+ const dataset = new KeplerTable({info: file.info, color: [0, 0, 0]});+ await dataset.importData({data: file.data as any});+ const {props} = GeoJsonLayer.findDefaultLayerProps(dataset);+ expect(props).toHaveLength(1);+ const layer = new GeoJsonLayer({...props[0], id: 'wkb-collection', dataId: dataset.id});+ layer.setInitialLayerConfig(dataset);+ const data = layer.formatLayerData({[dataset.id]: dataset}, {}) as any;+ expect(layer.centroids).toHaveLength(2);+ expect(layer.meta).toMatchObject({bounds: [1, 2, 50, 60]});+ expect(layer.meta.featureTypes).toMatchObject({point: true, line: true});+ if (layer.geoArrowMode) {+ expect(+ [+ ...new Set(+ data.data.flatMap(batch =>+ ['points', 'lines', 'polygons'].flatMap(type =>+ Array.from(batch[type]?.globalFeatureIds?.value || [])+ )+ )+ )+ ].sort()+ ).toEqual([0, 1]);+ } else {+ expect(data.data.map(feature => feature.properties.index)).toEqual([0, 1]);+ const rendered = renderGeojsonFeatures(data.data);+ expect(rendered.pointFeatures?.map(feature => feature.geometry.coordinates)).toEqual([+ [1, 2],+ [50, 60]+ ]);+ expect(rendered.lineFeatures?.map(feature => feature.geometry.coordinates)).toEqual([+ [+ [3, 4],+ [5, 6]+ ]+ ]);+ }+ const hover = {+ picked: true,+ index: 0,+ object: layer.geoArrowMode ? undefined : data.data[0],+ layer: {props: {id: layer.id}}+ };+ const overlay = layer._getHoverOverlayData(hover);+ expect(overlay?.[0]).toMatchObject({+ properties: {index: 0},+ geometry: {+ type: 'GeometryCollection',+ geometries: [+ {type: 'Point', coordinates: [1, 2]},+ {+ type: 'LineString',+ coordinates: [+ [3, 4],+ [5, 6]+ ]+ }+ ]+ }+ });+ const renderedOverlay = renderGeojsonFeatures(overlay!);+ expect(renderedOverlay.pointFeatures).toHaveLength(1);+ expect(renderedOverlay.lineFeatures).toHaveLength(1);+ if (layer.geoArrowMode)+ expect(layer.hasHoveredObject(hover)?.properties).toMatchObject({+ label: 'collection',+ index: 0+ });+ const parsed = layer.dataToFeature;+ layer.updateLayerVisConfig({opacity: 0.37});+ const updated = layer.formatLayerData(+ {[dataset.id]: copyTableAndUpdate(dataset, {filteredIndex: [1]})},+ data+ ) as any;+ expect(layer.dataToFeature).toBe(parsed);+ expect(layer.config.visConfig.opacity).toBe(0.37);+ if (layer.geoArrowMode) {+ expect(updated.getFiltered({properties: {index: 0}})).toBe(0);+ expect(updated.getFiltered({properties: {index: 1}})).toBe(1);+ } else expect(updated.data.map(feature => feature.properties.index)).toEqual([1]);+ }+ );++ test('skips invalid and empty WKB rows while preserving later Arrow row IDs', () => {+ const point: Geometry = {type: 'Point', coordinates: [50, 60]};+ const values = [+ bytes(),+ bytes().subarray(0, 8),+ new Uint8Array(),+ new Uint8Array(convertGeometryToWKB({type: 'GeometryCollection', geometries: []})),+ new Uint8Array(convertGeometryToWKB(point))+ ];+ const dataset = new KeplerTable({+ info: {id: 'invalid-collections'},+ color: [0, 0, 0]+ }).updateSchema({+ fields: [+ {+ name: 'geometry',+ type: 'geoarrow',+ analyzerType: 'GEOMETRY',+ metadata: new Map([[GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB]])+ }+ ],+ cols: [arrow.vectorFromArray(values, new arrow.Binary())],+ rows: []+ });+ const layer = new GeoJsonLayer({+ id: 'invalid-wkb',+ dataId: dataset.id,+ columns: {geojson: {value: 'geometry', fieldIdx: 0}}+ });+ expect(() => layer.setInitialLayerConfig(dataset)).not.toThrow();+ expect(layer.centroids).toEqual([[3, 4], null, null, null, [50, 60]]);+ const data = layer.formatLayerData({[dataset.id]: dataset}, {}) as any;+ expect(+ [+ ...new Set(+ data.data.flatMap(batch =>+ ['points', 'lines'].flatMap(type => Array.from(batch[type].globalFeatureIds.value))+ )+ )+ ].sort()+ ).toEqual([0, 4]);+ expect(+ layer._getHoverOverlayData({picked: true, index: 1, layer: {props: {id: layer.id}}})+ ).toBeNull();+ });+});++describe('getGeojsonBounds', () => {+ test.each([+ {type: 'Polygon'},+ {type: 'GeometryCollection', geometries: null},+ {type: 'GeometryCollection', geometries: [{type: 'Polygon'}]}+ ])('preserves valid rows when a collection contains %j', malformed => {+ const valid: Feature = {+ type: 'Feature',+ properties: {},+ geometry: {type: 'Point', coordinates: [1, 2]}+ };+ const invalid = {+ type: 'Feature',+ properties: {},+ geometry: {+ type: 'GeometryCollection',+ geometries: [{type: 'Point', coordinates: [50, 60]}, malformed]+ }+ } as Feature;+ expect(getGeojsonBounds([valid, invalid])).toEqual([1, 2, 1, 2]);+ });++ test('includes valid nested collections alongside empty collections', () => {+ expect(+ getGeojsonBounds([+ {+ type: 'Feature',+ properties: {},+ geometry: {+ type: 'GeometryCollection',+ geometries: [+ {type: 'GeometryCollection', geometries: []},+ {+ type: 'GeometryCollection',+ geometries: [{type: 'Point', coordinates: [50, 60]}]+ }+ ]+ }+ }+ ])+ ).toEqual([50, 60, 50, 60]);+ });+});describe('featureToHoverOutline', () => {test('converts Polygon rings to MultiLineString so hover overlay skips fill tessellation', () => {diff --git a/src/layers/src/geojson-layer/geojson-utils.ts b/src/layers/src/geojson-layer/geojson-utils.tsindex c413a5035..4e51e052f 100644--- a/src/layers/src/geojson-layer/geojson-utils.ts+++ b/src/layers/src/geojson-layer/geojson-utils.ts@@ -2,7 +2,7 @@// Copyright contributors to the kepler.gl projectimport {Buffer} from 'buffer';-import {Feature, Position, BBox} from 'geojson';+import {Feature, Geometry, Position, BBox} from 'geojson';import normalize from '@mapbox/geojson-normalize';import {bbox} from '@turf/bbox';import {ascending, extent} from 'd3-array';@@ -130,6 +130,78 @@ function isBinaryGeometry(value: unknown): value is Uint8Array | ArrayBuffer {return ArrayBuffer.isView(value) && (value as Uint8Array).BYTES_PER_ELEMENT === 1;}+/** Keep the existing decoder for ordinary WKB; decode collection envelopes here. */+function parseWkbGeometry(buffer: ArrayBuffer): Geometry | null {+ try {+ return convertWKBToGeometry(buffer);+ } catch {+ // loaders.gl does not yet decode WKB GeometryCollection (type 7).+ }+ const view = new DataView(buffer);+ const header = (offset: number) => {+ const order = view.getUint8(offset);+ if (order !== 0 && order !== 1) throw new Error('Invalid WKB byte order');+ const littleEndian = order === 1;+ const rawType = view.getUint32(offset + 1, littleEndian);+ const type = rawType & 0x1fffffff;+ const kind = type % 1000;+ if (kind < 1 || kind > 7 || type >= 4000) throw new Error('Unsupported WKB type');+ const dimensions =+ 2 ++ Number(Boolean(rawType & 0x80000000) || [1, 3].includes(Math.floor(type / 1000))) ++ Number(Boolean(rawType & 0x40000000) || [2, 3].includes(Math.floor(type / 1000)));+ return {kind, littleEndian, dimensions, start: offset + 5 + (rawType & 0x20000000 ? 4 : 0)};+ };+ const endOfGeometry = (offset: number, depth: number): number => {+ if (depth > 32) throw new Error('WKB nesting limit exceeded');+ const {kind, start, dimensions, littleEndian} = header(offset);+ let cursor = start;+ if (kind === 1) cursor += dimensions * 8;+ else {+ const count = view.getUint32(cursor, littleEndian);+ cursor += 4;+ if (kind === 2) cursor += count * dimensions * 8;+ else {+ if (count > (buffer.byteLength - cursor) / (kind === 3 ? 4 : 5))+ throw new Error('Truncated WKB');+ for (let i = 0; i < count; i++) {+ if (kind === 3) {+ const points = view.getUint32(cursor, littleEndian);+ cursor += 4 + points * dimensions * 8;+ } else cursor = endOfGeometry(cursor, depth + 1);+ }+ }+ }+ if (cursor > buffer.byteLength) throw new Error('Truncated WKB');+ return cursor;+ };+ const readGeometry = (offset: number, depth: number): {geometry: Geometry; end: number} => {+ if (depth > 32) throw new Error('WKB nesting limit exceeded');+ const {kind, start, littleEndian} = header(offset);+ if (kind !== 7) {+ const end = endOfGeometry(offset, depth);+ return {geometry: convertWKBToGeometry(buffer.slice(offset, end)), end};+ }+ const count = view.getUint32(start, littleEndian);+ let cursor = start + 4;+ if (count > (buffer.byteLength - cursor) / 5) throw new Error('Truncated WKB');+ const geometries: Geometry[] = [];+ for (let i = 0; i < count; i++) {+ const child = readGeometry(cursor, depth + 1);+ geometries.push(child.geometry);+ cursor = child.end;+ }+ return {geometry: {type: 'GeometryCollection', geometries}, end: cursor};+ };+ try {+ if (header(0).kind !== 7) return null;+ const {geometry, end} = readGeometry(0, 0);+ return end === buffer.byteLength ? geometry : null;+ } catch {+ return null;+ }+}+function isLngLat(pos: unknown): pos is number[] {const values = pos as {length?: number; 0?: unknown; 1?: unknown} | null;return (@@ -198,6 +270,22 @@ function featureFromGeometry(parsedGeo: unknown, properties: null): Feature | nureturn {properties, ...normalized.features[0]};}+/** deck.gl accepts one collection level; keep one feature per source row. */+function flattenGeometryCollection(geometry: Geometry): Geometry {+ if (geometry?.type !== 'GeometryCollection' || !Array.isArray(geometry.geometries)) {+ return geometry;+ }+ return {+ ...geometry,+ geometries: geometry.geometries.flatMap(child => {+ const flattened = flattenGeometryCollection(child);+ return flattened?.type === 'GeometryCollection' && Array.isArray(flattened.geometries)+ ? flattened.geometries+ : [flattened];+ })+ };+}+/*** Convert a hovered feature to outline-only geometry for the hover overlay.* The overlay is stroked and not filled, so polygon tessellation (earcut) is wasted@@ -227,6 +315,9 @@ export function featureToHoverOutline(feature: Feature): Feature {}};}+ if (geometry.type === 'GeometryCollection') {+ return {...feature, geometry: flattenGeometryCollection(geometry)};+ }return feature;}@@ -263,8 +354,8 @@ export function parseGeoJsonRawFeature(// Support WKB geometry provided as binary (e.g., from Parquet/GeoParquet/DuckDB)if (isBinaryGeometry(rawFeature)) {try {- const parsedGeo = convertWKBToGeometry(toArrayBuffer(rawFeature));- return featureFromGeometry(parsedGeo, properties);+ const parsedGeo = parseWkbGeometry(toArrayBuffer(rawFeature));+ return parsedGeo ? featureFromGeometry(parsedGeo, properties) : null;} catch (e) {return null;}@@ -381,6 +472,7 @@ export function getGeojsonDataMaps(if (feature && feature.geometry && acceptableTypes.includes(feature.geometry.type)) {const cleaned = Object.assign({}, feature);+ cleaned.geometry = flattenGeometryCollection(feature.geometry);// store index of the data in feature propertiescleaned.properties = Object.assign({}, feature.properties ?? {}, {index});@@ -460,7 +552,7 @@ function parseGeometryFromString(geoString: string): Feature | null {// try parse as WKB hex stringtry {const buffer = Buffer.from(geoString, 'hex');- parsedGeo = convertWKBToGeometry(toArrayBuffer(buffer));+ parsedGeo = parseWkbGeometry(toArrayBuffer(buffer));} catch (e) {return null;}@@ -492,12 +584,11 @@ export function getGeojsonBounds(features: GeojsonDataMaps = []): BBox | null {const maxCount = 10000;const samples = features.length > maxCount ? getSampleData(features, maxCount) : features;- const validSingleGeometry = geom => geom.coordinates && geom.coordinates.length;- const validGeometryCollection = geom =>- geom.geometries && geom.geometries.length && geom.geometries.every(validSingleGeometry);- const nonEmpty = samples.filter(- d => d && d.geometry && (validSingleGeometry(d.geometry) || validGeometryCollection(d.geometry))- );+ const validGeometry = geom =>+ geom?.type === 'GeometryCollection'+ ? Array.isArray(geom.geometries) && geom.geometries.every(validGeometry)+ : geom?.coordinates && geom.coordinates.length;+ const nonEmpty = samples.filter(d => d && d.geometry && validGeometry(d.geometry));try {return bbox({@@ -530,13 +621,18 @@ export type DeckGlGeoTypes = {export function getGeojsonFeatureTypes(allFeatures: GeojsonDataMaps): DeckGlGeoTypes {// @ts-expect-error some test cases only have 1 geotypeconst featureTypes: DeckGlGeoTypes = {};+ const addGeometry = geometry => {+ if (geometry?.type === 'GeometryCollection') {+ if (Array.isArray(geometry.geometries)) geometry.geometries.forEach(addGeometry);+ } else {+ const geoType = featureToDeckGlGeoType[geometry?.type];+ if (geoType) featureTypes[geoType] = true;+ }+ };for (let f = 0; f < allFeatures.length; f++) {const feature = allFeatures[f];if (feature && 'geometry' in feature) {- const geoType = featureToDeckGlGeoType[feature.geometry && feature.geometry.type];- if (geoType) {- featureTypes[geoType] = true;- }+ addGeometry(feature.geometry);}}diff --git a/src/layers/src/layer-utils.ts b/src/layers/src/layer-utils.tsindex a5db34cdf..550ee0f6e 100644--- a/src/layers/src/layer-utils.ts+++ b/src/layers/src/layer-utils.ts@@ -19,10 +19,6 @@ import {import {DataContainerInterface, ArrowDataContainer} from '@kepler.gl/utils';import {getBinaryGeometriesFromArrow, BinaryGeometriesFromArrowOptions} from '@loaders.gl/gis';import {updateBoundsFromGeoArrowSamples} from '@loaders.gl/geoarrow';-import {convertGeoArrowGeometryToGeoJSON} from '@loaders.gl/gis';--import {parseSync} from '@loaders.gl/core';-import {WKBLoader} from '@loaders.gl/wkt';import {geojsonToBinary} from '@loaders.gl/gis';import {Geometry,@@ -34,7 +30,8 @@ import {import {DeckGlGeoTypes,GeojsonDataMaps,- getCentroidFromGeometry+ getCentroidFromGeometry,+ parseGeoJsonRawFeature} from './geojson-layer/geojson-utils';export type FindDefaultLayerProps = {@@ -107,27 +104,25 @@ function getBinaryGeometriesFromWKBArrow(let bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];const geojsonFeatures: Feature[] = [];+ const addGeometry = (geometry: Geometry, index: number) => {+ if (geometry.type === 'GeometryCollection') {+ geometry.geometries.forEach(child => addGeometry(child, index));+ } else {+ geojsonFeatures.push({type: 'Feature', geometry, properties: {index}});+ featureTypes.polygon ||= geometry.type === 'Polygon' || geometry.type === 'MultiPolygon';+ featureTypes.point ||= geometry.type === 'Point' || geometry.type === 'MultiPoint';+ featureTypes.line ||= geometry.type === 'LineString' || geometry.type === 'MultiLineString';+ }+ };chunks.forEach(chunk => {for (let i = 0; i < chunk.length; ++i) {// ignore features without any geometryif (chunk.valueOffsets[i + 1] - chunk.valueOffsets[i] > 0) {const valuesSlice = chunk.values.slice(chunk.valueOffsets[i], chunk.valueOffsets[i + 1]);- const geometry = parseSync(valuesSlice.buffer, WKBLoader, {- wkb: {shape: 'geojson-geometry'}- }) as Geometry;- const feature: Feature = {- type: 'Feature',- geometry,- properties: {index: featureIndex}- };- geojsonFeatures.push(feature);- centroids.push(getCentroidFromGeometry(geometry));-- const {type} = geometry;- featureTypes.polygon = type === 'Polygon' || type === 'MultiPolygon';- featureTypes.point = type === 'Point' || type === 'MultiPoint';- featureTypes.line = type === 'LineString' || type === 'MultiLineString';+ const geometry = parseGeoJsonRawFeature(valuesSlice)?.geometry;+ if (geometry) addGeometry(geometry, featureIndex);+ centroids.push(geometry ? getCentroidFromGeometry(geometry) : null);} else {centroids.push(null);}@@ -266,7 +261,7 @@ export function getHoveredObjectFromArrow(const field = fieldAccessor(dataContainer);const encoding = field?.metadata?.get(GEOARROW_METADATA_KEY);- const hoveredFeature = convertGeoArrowGeometryToGeoJSON(rawGeometry, encoding);+ const hoveredFeature = parseGeoJsonRawFeature(rawGeometry, encoding)?.geometry;const properties = dataContainer.rowAsArray(objectInfo.index).reduce((prev, cur, i) => {const fieldName = dataContainer?.getField?.(i).name;