fix: Don't serialize GeoJSON vector tiles from the worker to support undefined properties

src/data/feature_index.ts

@@ -23,7 +23,7 @@ import type {MapGeoJSONFeature} from '../util/vectortile_to_geojson';
 import type {StyleLayer} from '../style/style_layer';
 import type {FeatureFilter, FeatureState, FilterSpecification, PromoteIdSpecification} from '@maplibre/maplibre-gl-style-spec';
 import type {IReadonlyTransform} from '../geo/transform_interface';
-import {type VectorTileFeatureLike, type VectorTileLayerLike, GEOJSON_TILE_LAYER_NAME} from '@maplibre/vt-pbf';
+import {type VectorTileFeatureLike, type VectorTileLayerLike, type Feature, GeoJSONWrapper, GEOJSON_TILE_LAYER_NAME} from '@maplibre/vt-pbf';
 import {VectorTile} from '@mapbox/vector-tile';
 
 export {GEOJSON_TILE_LAYER_NAME};
@@ -69,6 +69,7 @@ export class FeatureIndex {
     promoteId?: PromoteIdSpecification;
     encoding: string;
     rawTileData: ArrayBuffer;
+    geoJsonFeatureData: Feature[];
     bucketLayerIDs: Array<Array<string>>;
 
     vtLayers: {[_: string]: VectorTileLayerLike};
@@ -114,9 +115,13 @@ export class FeatureIndex {
 
     loadVTLayers(): {[_: string]: VectorTileLayerLike} {
         if (!this.vtLayers) {
-            this.vtLayers = this.encoding !== 'mlt' 
-                ? new VectorTile(new Protobuf(this.rawTileData)).layers
-                : new MLTVectorTile(this.rawTileData).layers;
+            if (this.geoJsonFeatureData) {
+                this.vtLayers = new GeoJSONWrapper(this.geoJsonFeatureData, {version: 2, extent: EXTENT}).layers;
+            } else {
+                this.vtLayers = this.encoding !== 'mlt' ?
+                    new VectorTile(new Protobuf(this.rawTileData)).layers :
+                    new MLTVectorTile(this.rawTileData).layers;
+            }
             this.sourceLayerCoder = new DictionaryCoder(this.vtLayers ? Object.keys(this.vtLayers).sort() : [GEOJSON_TILE_LAYER_NAME]);
         }
         return this.vtLayers;

src/source/geojson_worker_source.test.ts

@@ -32,6 +32,11 @@ describe('reloadTile', () => {
             'geometry': {
                 'type': 'Point',
                 'coordinates': [0, 0]
+            },
+            'properties': {
+                'property1': 10,
+                'property2': undefined,
+                'property3': false
             }
         };
         const tileParams = {
@@ -41,27 +46,36 @@ describe('reloadTile', () => {
             maxZoom: 10
         };
 
-        await source.loadData({source: 'sourceId', data: geoJson} as LoadGeoJSONParameters);
+        await source.loadData({type: 'geojson', source: 'sourceId', data: geoJson} as LoadGeoJSONParameters);
 
         // first call should load vector data from geojson
         const firstData = await source.reloadTile(tileParams as any as WorkerTileParameters);
         expect(spy).toHaveBeenCalledTimes(1);
 
-        // second call won't give us new rawTileData
+        // geojson shouldn't encode any tile data, just provide features
+        expect(firstData.rawTileData).toBeUndefined();
+
+        // geojson should support undefined properties
+        expect(firstData.geoJsonFeatures[0].tags).toStrictEqual({
+            'property1': 10,
+            'property2': undefined,
+            'property3': false
+        });
+
+        // second data should return the same features
         let data = await source.reloadTile(tileParams as any as WorkerTileParameters);
         expect('rawTileData' in data).toBeFalsy();
-        data.rawTileData = firstData.rawTileData;
         expect(data).toEqual(firstData);
 
         // also shouldn't call loadVectorData again
         expect(spy).toHaveBeenCalledTimes(1);
 
         // replace geojson data
-        await source.loadData({source: 'sourceId', data: geoJson} as LoadGeoJSONParameters);
+        await source.loadData({type: 'geojson', source: 'sourceId', data: geoJson} as LoadGeoJSONParameters);
 
         // should call loadVectorData again after changing geojson data
         data = await source.reloadTile(tileParams as any as WorkerTileParameters);
-        expect('rawTileData' in data).toBeTruthy();
+        expect(data.geoJsonFeatures).toBeTruthy();
         expect(data).toEqual(firstData);
         expect(spy).toHaveBeenCalledTimes(2);
     });

src/source/geojson_worker_source.ts

@@ -8,7 +8,6 @@ import geojsonvt, {type Options as GeoJSONVTOptions} from 'geojson-vt';
 import {VectorTileWorkerSource} from './vector_tile_worker_source';
 import {createExpression} from '@maplibre/maplibre-gl-style-spec';
 import {isAbortError} from '../util/abort_error';
-import {toVirtualVectorTile} from './vector_tile_overzoomed';
 import {isUpdateableGeoJSON, type GeoJSONSourceDiff, applySourceDiff, toUpdateable, type GeoJSONFeatureId} from './geojson_source_diff';
 import type {WorkerTileParameters, WorkerTileResult} from './worker_source';
 import type {LoadVectorTileResult} from './vector_tile_worker_source';
@@ -92,9 +91,9 @@ export class GeoJSONWorkerSource extends VectorTileWorkerSource {
             return null;
         }
 
-        const geojsonWrapper = new GeoJSONWrapper(geoJSONTile.features, {version: 2, extent: EXTENT});
-
-        return toVirtualVectorTile(geojsonWrapper);
+        return {
+            vectorTile: new GeoJSONWrapper(geoJSONTile.features, {version: 2, extent: EXTENT})
+        };
     }
 
     /**

src/source/vector_tile_worker_source.test.ts

@@ -12,7 +12,6 @@ import {setPerformance, sleep} from '../util/test/util';
 import {ABORT_ERROR} from '../util/abort_error';
 import {SubdivisionGranularitySetting} from '../render/subdivision_granularity_settings';
 import {VectorTile} from '@mapbox/vector-tile';
-import {VectorTileLike} from '@maplibre/vt-pbf';
 import Point from '@mapbox/point-geometry';
 
 describe('vector tile worker source', () => {

src/source/vector_tile_worker_source.ts

@@ -16,11 +16,11 @@ import type {
 import type {IActor} from '../util/actor';
 import type {StyleLayer} from '../style/style_layer';
 import type {StyleLayerIndex} from '../style/style_layer_index';
-import type {VectorTileLayerLike, VectorTileLike} from '@maplibre/vt-pbf';
+import {type VectorTileLayerLike, type VectorTileLike, GeoJSONWrapper} from '@maplibre/vt-pbf';
 
 export type LoadVectorTileResult = {
     vectorTile: VectorTileLike;
-    rawData: ArrayBufferLike;
+    rawData?: ArrayBufferLike;
     resourceTiming?: Array<PerformanceResourceTiming>;
 } & ExpiryData;
 
@@ -148,7 +148,11 @@ export class VectorTileWorkerSource implements WorkerSource {
             try {
                 const result = await parsePromise;
                 // Transferring a copy of rawTileData because the worker needs to retain its copy.
-                return extend({rawTileData: rawTileData.slice(0), encoding: params.encoding}, result, cacheControl, resourceTiming);
+                return extend({
+                    rawTileData: rawTileData?.slice(0),
+                    geoJsonFeatures: workerTile.vectorTile instanceof GeoJSONWrapper ? (workerTile.vectorTile as GeoJSONWrapper).features : null,
+                    encoding: params.encoding
+                }, result, cacheControl, resourceTiming);
             } finally {
                 delete this.fetching[tileUid];
             }
@@ -214,7 +218,11 @@ export class VectorTileWorkerSource implements WorkerSource {
             if (this.fetching[uid]) {
                 const {rawTileData, cacheControl, resourceTiming} = this.fetching[uid];
                 delete this.fetching[uid];
-                parseResult = extend({rawTileData: rawTileData.slice(0), encoding: params.encoding}, result, cacheControl, resourceTiming);
+                parseResult = extend({
+                    rawTileData: rawTileData?.slice(0),
+                    geoJsonFeatures: workerTile.vectorTile instanceof GeoJSONWrapper ? (workerTile.vectorTile as GeoJSONWrapper).features : null,
+                    encoding: params.encoding
+                }, result, cacheControl, resourceTiming);
             } else {
                 parseResult = result;
             }
@@ -224,7 +232,9 @@ export class VectorTileWorkerSource implements WorkerSource {
         // if there was no vector tile data on the initial load, don't try and re-parse tile
         if (workerTile.status === 'done' && workerTile.vectorTile) {
             // this seems like a missing case where cache control is lost? see #3309
-            return workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, params.subdivisionGranularity);
+            return extend({
+                geoJsonFeatures: workerTile.vectorTile instanceof GeoJSONWrapper ? (workerTile.vectorTile as GeoJSONWrapper).features : null,
+            }, await workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, params.subdivisionGranularity));
         }
     }
 

src/source/worker_source.ts

@@ -15,6 +15,7 @@ import type {IActor} from '../util/actor';
 import type {StyleLayerIndex} from '../style/style_layer_index';
 import type {SubdivisionGranularitySetting} from '../render/subdivision_granularity_settings';
 import type {DashEntry} from '../render/line_atlas';
+import type {Feature} from '@maplibre/vt-pbf';
 
 /**
  * Parameters to identify a tile
@@ -79,6 +80,7 @@ export type WorkerTileResult = ExpiryData & {
     featureIndex: FeatureIndex;
     collisionBoxArray: CollisionBoxArray;
     rawTileData?: ArrayBuffer;
+    geoJsonFeatures?: Feature[];
     encoding?: string;
     resourceTiming?: Array<PerformanceResourceTiming>;
     // Only used for benchmarking:

src/tile/tile.ts

@@ -218,7 +218,11 @@ export class Tile {
 
         if (data.featureIndex) {
             this.latestFeatureIndex = data.featureIndex;
-            if (data.rawTileData) {
+            if (data.geoJsonFeatures) {
+                // GeoJSON sources provide feature data directly instead of encoded
+                // tile data
+                this.latestFeatureIndex.geoJsonFeatureData = data.geoJsonFeatures;
+            } else if (data.rawTileData) {
                 // Only vector tiles have rawTileData, and they won't update it for
                 // 'reloadTile'
                 this.latestRawTileData = data.rawTileData;
@@ -350,7 +354,7 @@ export class Tile {
         pixelPosMatrix: mat4,
         getElevation: undefined | ((x: number, y: number) => number)
     ): QueryResults {
-        if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData)
+        if (!this.latestFeatureIndex || !(this.latestFeatureIndex.rawTileData || this.latestFeatureIndex.geoJsonFeatureData))
             return {};
 
         return this.latestFeatureIndex.query({
@@ -466,7 +470,7 @@ export class Tile {
 
     setFeatureState(states: LayerFeatureStates, painter: any) {
         if (!this.latestFeatureIndex ||
-            !this.latestFeatureIndex.rawTileData ||
+            !(this.latestFeatureIndex.rawTileData || this.latestFeatureIndex.geoJsonFeatureData) ||
             Object.keys(states).length === 0) {
             return;
         }

src/util/vectortile_to_geojson.ts

@@ -75,7 +75,9 @@ export class GeoJSONFeature {
             case 1: {
                 const points = [];
                 for (const line of vtCoords) {
-                    points.push(line[0]);
+                    for (const point of line) {
+                        points.push(point);
+                    }
                 }
                 const coordinates = this.projectLine(points, x0, y0, size);
                 this._geometry = points.length === 1 ?