@maplibre/geojson-vt 6.1.2 → 6.2.0

package/src/convert.ts

@@ -47,30 +47,31 @@ function featureToInternal(features: GeoJSONVTInternalFeature[], geojson: GeoJSO
 
     const id = getFeatureId(geojson, options, index);
     const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+    const worldCoordinates = options.worldCoordinates === true;
 
     switch (geojson.geometry.type) {
         case 'Point':
-            convertPointFeature(features, id, geojson.geometry, geojson.properties);
+            convertPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
             return;
 
         case 'MultiPoint':
-            convertMultiPointFeature(features, id, geojson.geometry, geojson.properties);
+            convertMultiPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
             return;
 
         case 'LineString':
-            convertLineStringFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
             return;
 
         case 'MultiLineString':
-            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, options, geojson.properties);
+            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, options, geojson.properties);
             return;
 
         case 'Polygon':
-            convertPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
             return;
 
         case 'MultiPolygon':
-            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
             return;
 
         default:
@@ -99,64 +100,68 @@ function convertGeometryCollection(features: GeoJSONVTInternalFeature[], geojson
     }
 }
 
-function convertPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Point, properties: GeoJSON.GeoJsonProperties) {
+function convertPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Point, worldCoordinates: boolean, properties: GeoJSON.GeoJsonProperties) {
     const out: number[] = [];
-    out.push(projectX(geom.coordinates[0]), projectY(geom.coordinates[1]), 0);
+    out.push(projectX(geom.coordinates[0], worldCoordinates), projectY(geom.coordinates[1], worldCoordinates), 0);
     features.push(createFeature(id, 'Point', out, properties));
 }
 
-function convertMultiPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPoint, properties: GeoJSON.GeoJsonProperties) {
+function convertMultiPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPoint, worldCoordinates: boolean, properties: GeoJSON.GeoJsonProperties) {
     const out: number[] = [];
     for (const coords of geom.coordinates) {
-        out.push(projectX(coords[0]), projectY(coords[1]), 0);
+        out.push(projectX(coords[0], worldCoordinates), projectY(coords[1], worldCoordinates), 0);
     }
     features.push(createFeature(id, 'MultiPoint', out, properties));
 }
 
-function convertLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.LineString, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+function convertLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.LineString, tolerance: number, worldCoordinates: boolean, properties: GeoJSON.GeoJsonProperties) {
     const out: SliceArray = {points: []};
-    convertLine(geom.coordinates, out, tolerance, false);
+    convertLine(geom.coordinates, out, tolerance, false, worldCoordinates);
     features.push(createFeature(id, 'LineString', out, properties));
 }
 
-function convertMultiLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiLineString, tolerance: number, options: GeoJSONVTOptions, properties: GeoJSON.GeoJsonProperties) {
+function convertMultiLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiLineString, tolerance: number, worldCoordinates: boolean, options: GeoJSONVTOptions, properties: GeoJSON.GeoJsonProperties) {
     if (options.lineMetrics) {
         // explode into linestrings to be able to track metrics
         for (const line of geom.coordinates) {
             const out: SliceArray = {points: []};
-            convertLine(line, out, tolerance, false);
+            convertLine(line, out, tolerance, false, worldCoordinates);
             features.push(createFeature(id, 'LineString', out, properties));
         }
     } else {
         const out: SliceArray[] = [];
-        convertLines(geom.coordinates, out, tolerance, false);
+        convertLines(geom.coordinates, out, tolerance, false, worldCoordinates);
         features.push(createFeature(id, 'MultiLineString', out, properties));
     }
 }
 
-function convertPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Polygon, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+function convertPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Polygon, tolerance: number, worldCoordinates: boolean, properties: GeoJSON.GeoJsonProperties) {
     const out: SliceArray[] = [];
-    convertLines(geom.coordinates, out, tolerance, true);
+    convertLines(geom.coordinates, out, tolerance, true, worldCoordinates);
     features.push(createFeature(id, 'Polygon', out, properties));
 }
 
-function convertMultiPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPolygon, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+function convertMultiPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPolygon, tolerance: number, worldCoordinates: boolean, properties: GeoJSON.GeoJsonProperties) {
     const out: SliceArray[][] = [];
     for (const polygon of geom.coordinates) {
         const polygonOut: SliceArray[] = [];
-        convertLines(polygon, polygonOut, tolerance, true);
+        convertLines(polygon, polygonOut, tolerance, true, worldCoordinates);
+        if (!polygonOut.length) continue;
+
         out.push(polygonOut);
     }
+    if (!out.length) return;
+
     features.push(createFeature(id, 'MultiPolygon', out, properties));
 }
 
-function convertLine(ring: GeoJSON.Position[], out: SliceArray, tolerance: number, isPolygon: boolean) {
+function convertLine(ring: GeoJSON.Position[], out: SliceArray, tolerance: number, isPolygon: boolean, worldCoordinates: boolean) {
     let x0, y0;
     let size = 0;
 
     for (let j = 0; j < ring.length; j++) {
-        const x = projectX(ring[j][0]);
-        const y = projectY(ring[j][1]);
+        const x = projectX(ring[j][0], worldCoordinates);
+        const y = projectY(ring[j][1], worldCoordinates);
 
         out.points.push(x, y, 0);
 
@@ -182,25 +187,27 @@ function convertLine(ring: GeoJSON.Position[], out: SliceArray, tolerance: numbe
     out.end = out.size;
 }
 
-function convertLines(rings: GeoJSON.Position[][], out: SliceArray[], tolerance: number, isPolygon: boolean) {
+function convertLines(rings: GeoJSON.Position[][], out: SliceArray[], tolerance: number, isPolygon: boolean, worldCoordinates: boolean) {
     for (let i = 0; i < rings.length; i++) {
         const geom: SliceArray = {points: []};
-        convertLine(rings[i], geom, tolerance, isPolygon);
+        convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinates);
         out.push(geom);
     }
 }
 
 /**
- * Convert longitude to spherical mercator in [0..1] range
+ * Convert longitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
  */
-export function projectX(x: number) {
+export function projectX(x: number, worldCoordinates = false) {
+    if (worldCoordinates) return x;
     return x / 360 + 0.5;
 }
 
 /**
- * Convert latitude to spherical mercator in [0..1] range
+ * Convert latitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
  */
-export function projectY(y: number) {
+export function projectY(y: number, worldCoordinates = false) {
+    if (worldCoordinates) return y;
     const sin = Math.sin(y * Math.PI / 180);
     const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
     return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;

package/src/deconvert.ts

@@ -3,10 +3,10 @@ import type {GeoJSONVTInternalFeature} from './definitions';
 /**
  * Converts internal source features back to GeoJSON format.
  */
-export function convertToGeoJSON(source: GeoJSONVTInternalFeature[]): GeoJSON.GeoJSON {
+export function convertToGeoJSON(source: GeoJSONVTInternalFeature[], worldCoordinates = false): GeoJSON.GeoJSON {
     const geojson: GeoJSON.GeoJSON = {
         type: 'FeatureCollection',
-        features: source.map(feature => featureToGeoJSON(feature))
+        features: source.map(feature => featureToGeoJSON(feature, worldCoordinates))
     };
 
     return geojson;
@@ -15,10 +15,10 @@ export function convertToGeoJSON(source: GeoJSONVTInternalFeature[]): GeoJSON.Ge
 /**
  * Converts a single internal feature to GeoJSON format.
  */
-export function featureToGeoJSON(feature: GeoJSONVTInternalFeature): GeoJSON.Feature {
+export function featureToGeoJSON(feature: GeoJSONVTInternalFeature, worldCoordinates = false): GeoJSON.Feature {
     const geojsonFeature: GeoJSON.Feature = {
         type: 'Feature',
-        geometry: geometryToGeoJSON(feature),
+        geometry: geometryToGeoJSON(feature, worldCoordinates),
         properties: feature.tags
     };
     if (feature.id != null) {
@@ -31,66 +31,68 @@ export function featureToGeoJSON(feature: GeoJSONVTInternalFeature): GeoJSON.Fea
 /**
  * Converts a single internal feature geometry to GeoJSON format.
  */
-function geometryToGeoJSON(feature: GeoJSONVTInternalFeature): GeoJSON.Geometry {
+function geometryToGeoJSON(feature: GeoJSONVTInternalFeature, worldCoordinates: boolean): GeoJSON.Geometry {
     const {type, geometry} = feature;
 
     switch (type) {
         case 'Point':
             return {
                 type: type,
-                coordinates: unprojectPoint(geometry[0], geometry[1])
+                coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinates)
             };
         case 'MultiPoint':
             return {
                 type: type,
-                coordinates: unprojectPoints(geometry)
+                coordinates: unprojectPoints(geometry, worldCoordinates)
             };
         case 'LineString':
             return {
                 type: type,
-                coordinates: unprojectPoints(geometry.points)
+                coordinates: unprojectPoints(geometry.points, worldCoordinates)
             };
         case 'MultiLineString':
         case 'Polygon':
             return {
                 type: type,
-                coordinates: geometry.map(ring => unprojectPoints(ring.points))
+                coordinates: geometry.map(ring => unprojectPoints(ring.points, worldCoordinates))
             };
         case 'MultiPolygon':
             return {
                 type: type,
                 coordinates: geometry.map(polygon =>
-                    polygon.map(ring => unprojectPoints(ring.points))
+                    polygon.map(ring => unprojectPoints(ring.points, worldCoordinates))
                 )
             };
     }
 }
 
-export function unprojectPoints(coords: number[] | Float64Array): GeoJSON.Position[] {
+export function unprojectPoints(coords: number[] | Float64Array, worldCoordinates = false): GeoJSON.Position[] {
     const result: GeoJSON.Position[] = [];
 
     for (let i = 0; i < coords.length; i += 3) {
-        result.push(unprojectPoint(coords[i], coords[i + 1]));
+        result.push(unprojectPoint(coords[i], coords[i + 1], worldCoordinates));
     }
 
     return result;
 }
 
-function unprojectPoint(x: number, y: number): GeoJSON.Position {
-    return [unprojectX(x), unprojectY(y)];
+function unprojectPoint(x: number, y: number, worldCoordinates: boolean): GeoJSON.Position {
+    return [unprojectX(x, worldCoordinates), unprojectY(y, worldCoordinates)];
 }
 
 /**
- * Convert spherical mercator in [0..1] range to longitude
+ * Convert spherical mercator in [0..1] range to longitude, or keep a world coordinate as it is
  */
-export function unprojectX(x: number): number {
+export function unprojectX(x: number, worldCoordinates = false): number {
+    if (worldCoordinates) return x;
     return (x - 0.5) * 360;
 }
 
 /**
- * Convert spherical mercator in [0..1] range to latitude
+ * Convert spherical mercator in [0..1] range to latitude, or keep a world coordinate as it is
  */
-export function unprojectY(y: number): number {
+export function unprojectY(y: number, worldCoordinates = false): number {
+    if (worldCoordinates) return y;
     const y2 = (180 - y * 360) * Math.PI / 180;
     return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
 }

package/src/definitions.ts

@@ -54,7 +54,18 @@ export type GeoJSONVTOptions = {
      */
     debug?: number;
     /**
-     * Enable Supercluster for point features.
+     * Whether positions are world coordinates instead of lng/lat: x and y from 0 to 1 across the world square, y growing
+     * downward, where web mercator would put a lng/lat. The world is then a square that ends at its edges, for data in a
+     * world of its own such as a map projection's: positions are neither projected nor wrapped around or clamped,
+     * features are cut at the tile buffer around the square, points outside it are left out of the clusters, `getTile`
+     * returns `null` outside it, and `getData` and the cluster methods return world coordinates too.
+     * @experimental
+     * @default false
+     */
+    worldCoordinates?: boolean;
+    /**
+     * Enable Supercluster for point features. Each position of a MultiPoint feature is clustered as a point of its own.
+     * Other geometry types are left out.
      * @default false
      */
     cluster?: boolean;
@@ -67,7 +78,7 @@ export type GeoJSONVTOptions = {
 
 export type GeoJSONToTileOptions = GeoJSONVTOptions & {
     /**
-     * Whether to wrap features around the antimeridian
+     * Whether to wrap features around the antimeridian. Has no effect with `worldCoordinates`.
      * @default false
      */
     wrap?: boolean;
@@ -214,12 +225,12 @@ export interface GeoJSONVTTileIndex {
 
 export type SuperclusterOptions = {
     /**
-     * Min zoom to generate clusters on
+     * Min zoom to generate clusters on. A value above 30 is limited to 30.
      * @default 0
      */
     minZoom?: number;
     /**
-     * Max zoom level to cluster the points on
+     * Max zoom level to cluster the points on. A value above 30 is limited to 30.
      * @default 16
      */
     maxZoom?: number;
@@ -249,7 +260,8 @@ export type SuperclusterOptions = {
      */
     log?: boolean;
     /**
-     * Whether to generate numeric ids for input features (in vector tiles)
+     * Whether to generate numeric ids for input features (in vector tiles). Each position of a MultiPoint feature
+     * gets an id of its own.
      * @default false
      */
     generateId?: boolean;

package/src/difference.test.ts

@@ -50,6 +50,24 @@ test('applySourceDiff: adds a feature using the promoteId', () => {
     expect(source[0].id).toBe('point2');
 });
 
+test('applySourceDiff: adds a feature without properties when promoteId is set', () => {
+    const point = {
+        type: 'Feature' as const,
+        geometry: {
+            type: 'Point' as const,
+            coordinates: [0, 0],
+        },
+        properties: null as GeoJSON.GeoJsonProperties,
+    };
+
+    const {source} = applySourceDiff([], {
+        add: [point]
+    }, {promoteId: 'promoteId'});
+
+    expect(source.length).toBe(1);
+    expect(source[0].geometry).toEqual([0.5, 0.5, 0]);
+});
+
 test('applySourceDiff: removes a feature by its id', () => {
     const point = {
         type: 'Point' as const,
@@ -141,6 +159,59 @@ test('applySourceDiff: updates a feature geometry', () => {
     expect((source[0].geometry as number[])[1]).toBe(0.5);
 });
 
+test('applySourceDiff: keeps a generated id when updating a feature geometry', () => {
+    const point = {
+        type: 'Point' as const,
+        id: 1,
+        geometry: [0, 0],
+        tags: {},
+        minX: 0,
+        minY: 0,
+        maxX: 0,
+        maxY: 0
+    };
+
+    const {source} = applySourceDiff([point], {
+        update: [{
+            id: 1,
+            newGeometry: {
+                type: 'Point',
+                coordinates: [1, 0]
+            }
+        }]
+    }, {...options, generateId: true});
+
+    expect(source.length).toBe(1);
+    expect(source[0].id).toBe(1);
+});
+
+test('applySourceDiff: keeps a promoted id when updating a feature geometry and the promoted property', () => {
+    const point = {
+        type: 'Point' as const,
+        id: 'point',
+        geometry: [0, 0],
+        tags: {name: 'point'},
+        minX: 0,
+        minY: 0,
+        maxX: 0,
+        maxY: 0
+    };
+
+    const {source} = applySourceDiff([point], {
+        update: [{
+            id: 'point',
+            newGeometry: {
+                type: 'Point',
+                coordinates: [1, 0]
+            },
+            addOrUpdateProperties: [{key: 'name', value: 'renamed'}]
+        }]
+    }, {...options, promoteId: 'name'});
+
+    expect(source.length).toBe(1);
+    expect(source[0].id).toBe('point');
+});
+
 test('applySourceDiff: adds properties', () => {
     const point = {
         type: 'Point' as const,

package/src/difference.ts

@@ -138,7 +138,7 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
  * @param vtFeatures - the original features
  * @param update - the update object to apply
  * @param options - the options to use for the wrap method
- * @returns Updated features. If geometry is updated, returns new feature(s) converted from geojson and wrapped. If only properties are updated, returns feature(s) with tags updated.
+ * @returns Updated features. If geometry is updated, returns new feature(s) converted from geojson and wrapped, with the id the feature already has. If only properties are updated, returns feature(s) with tags updated.
  */
 function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJSONVTFeatureDiff, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
     const changeGeometry = !!update.newGeometry;
@@ -157,7 +157,7 @@ function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJ
             properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
         };
 
-        let features = convertToInternal({type: 'FeatureCollection', features: [geojsonFeature]}, options);
+        let features = convertToInternal({type: 'FeatureCollection', features: [geojsonFeature]}, {...options, promoteId: undefined, generateId: false});
         features = wrap(features, options);
         return features;
     }
@@ -213,7 +213,7 @@ export function diffToHashed(diff: GeoJSONVTSourceDiff, options: GeoJSONVTOption
     const hashed: HashedGeoJSONVTSourceDiff = {
         removeAll: diff.removeAll,
         remove: new Set(diff.remove || []),
-        add: new Map(diff.add?.map(feature => [options.promoteId ? feature.properties[options.promoteId] : feature.id, feature])),
+        add: new Map(diff.add?.map(feature => [options.promoteId ? feature.properties?.[options.promoteId] : feature.id, feature])),
         update: new Map(diff.update?.map(update => [update.id, update]))
     };
 

package/src/geojsonvt.test.ts

@@ -36,4 +36,239 @@ test('publicly exposed cluster methods: return undefined when clustering is disa
     expect(index.getClusterExpansionZoom(123)).toBeNull();
     expect(index.getClusterChildren(123)).toBeNull();
     expect(index.getClusterLeaves(123, 10, 0)).toBeNull();
-});
+});
+
+test('worldCoordinates cuts a line at the buffer around the world instead of wrapping or clamping it', () => {
+    const fromThreeWorldsNorthToEast = {type: 'LineString' as const, coordinates: [[0.25, -3], [0.75, 0.5], [1.25, 0.5]]};
+
+    const index = new GeoJSONVT(fromThreeWorldsNorthToEast, {worldCoordinates: true});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[[2770, -64], [3072, 2048], [4160, 2048]]]]);
+});
+
+test('worldCoordinates cuts the top tile at the world again on update, so a feature can move in from outside', () => {
+    const movingIn = {type: 'Feature' as const, id: 'moving in', geometry: {type: 'Point' as const, coordinates: [1.25, 0.5]}, properties: {}};
+    const stayingOut = {type: 'Feature' as const, id: 'staying out', geometry: {type: 'Point' as const, coordinates: [1.5, 0.5]}, properties: {}};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [movingIn, stayingOut]}, {worldCoordinates: true, updateable: true});
+
+    index.updateData({update: [{id: 'moving in', newGeometry: {type: 'Point', coordinates: [0.5, 0.5]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['moving in']);
+});
+
+test('worldCoordinates returns the data in world coordinates', () => {
+    const features: GeoJSON.Feature[] = [
+        {type: 'Feature', id: 'point', geometry: {type: 'Point', coordinates: [0.25, 0.75]}, properties: {}},
+        {type: 'Feature', id: 'multi point', geometry: {type: 'MultiPoint', coordinates: [[0.25, 0.75], [0.5, 0.5]]}, properties: {}},
+        {type: 'Feature', id: 'line', geometry: {type: 'LineString', coordinates: [[0.25, 0.75], [0.5, 0.5]]}, properties: {}},
+        {type: 'Feature', id: 'multi line', geometry: {type: 'MultiLineString', coordinates: [[[0.25, 0.75], [0.5, 0.5]], [[0.5, 0.25], [0.75, 0.25]]]}, properties: {}},
+        {type: 'Feature', id: 'polygon', geometry: {type: 'Polygon', coordinates: [[[0.25, 0.25], [0.75, 0.25], [0.75, 0.75], [0.25, 0.25]]]}, properties: {}},
+        {type: 'Feature', id: 'multi polygon', geometry: {type: 'MultiPolygon', coordinates: [[[[0.25, 0.25], [0.75, 0.25], [0.75, 0.75], [0.25, 0.25]]]]}, properties: {}}
+    ];
+    const index = new GeoJSONVT({type: 'FeatureCollection', features}, {worldCoordinates: true, updateable: true});
+
+    expect(index.getData()).toEqual({type: 'FeatureCollection', features});
+});
+
+test('worldCoordinates keeps a MultiLineString it splits for lineMetrics in world coordinates', () => {
+    const multiLine = {type: 'MultiLineString' as const, coordinates: [[[0.25, 0.75], [0.5, 0.5]], [[0.5, 0.25], [0.75, 0.25]]]};
+    const index = new GeoJSONVT(multiLine, {worldCoordinates: true, lineMetrics: true, updateable: true});
+
+    expect(index.getData()).toEqual({type: 'FeatureCollection', features: [
+        {type: 'Feature', geometry: {type: 'LineString', coordinates: [[0.25, 0.75], [0.5, 0.5]]}},
+        {type: 'Feature', geometry: {type: 'LineString', coordinates: [[0.5, 0.25], [0.75, 0.25]]}}
+    ]});
+});
+
+test('worldCoordinates hands the update filter features in world coordinates', () => {
+    const point = {type: 'Feature' as const, id: 'p', geometry: {type: 'Point' as const, coordinates: [0.25, 0.75]}, properties: {}};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [point]}, {worldCoordinates: true, updateable: true});
+    const filtered: GeoJSON.Geometry[] = [];
+
+    index.updateData({add: [{...point, id: 'q'}]}, feature => {
+        filtered.push(feature.geometry);
+        return true;
+    });
+
+    expect(filtered).toContainEqual({type: 'Point', coordinates: [0.25, 0.75]});
+});
+
+test('worldCoordinates leaves points outside the world out of the clusters', () => {
+    const data = {
+        type: 'FeatureCollection' as const,
+        features: [
+            {type: 'Feature' as const, id: 'inside', geometry: {type: 'Point' as const, coordinates: [0.99, 0.5]}, properties: {}},
+            {type: 'Feature' as const, id: 'east', geometry: {type: 'Point' as const, coordinates: [1.03, 0.5]}, properties: {}},
+            {type: 'Feature' as const, id: 'north', geometry: {type: 'Point' as const, coordinates: [0.5, -0.03]}, properties: {}}
+        ]
+    };
+
+    const index = new GeoJSONVT(data, {worldCoordinates: true, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+});
+
+test('worldCoordinates keeps points at either edge out of the clustered tile at the other edge', () => {
+    const data = {
+        type: 'FeatureCollection' as const,
+        features: [
+            {type: 'Feature' as const, id: 'west', geometry: {type: 'Point' as const, coordinates: [0.001, 0.5]}, properties: {}},
+            {type: 'Feature' as const, id: 'east', geometry: {type: 'Point' as const, coordinates: [0.999, 0.5]}, properties: {}}
+        ]
+    };
+
+    const index = new GeoJSONVT(data, {worldCoordinates: true, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features).toHaveLength(2);
+});
+
+test('worldCoordinates returns cluster children and leaves in world coordinates', () => {
+    const points = {
+        type: 'FeatureCollection' as const,
+        features: Array.from({length: 20}, (_, i) => ({
+            type: 'Feature' as const,
+            geometry: {type: 'Point' as const, coordinates: [0.5 + i * 0.000001, 0.5]},
+            properties: {name: `Point ${i}`}
+        }))
+    };
+    const index = new GeoJSONVT(points, {worldCoordinates: true, cluster: true, clusterOptions: {radius: 100}});
+    const cluster = index.getTile(0, 0, 0).features.find(f => (f.tags as {cluster?: boolean})?.cluster);
+    const clusterId = (cluster.tags as {cluster_id: number}).cluster_id;
+
+    const childPositions = index.getClusterChildren(clusterId).map(child => (child.geometry as GeoJSON.Point).coordinates);
+    const leafPositions = index.getClusterLeaves(clusterId, 20, 0).map(leaf => (leaf.geometry as GeoJSON.Point).coordinates);
+
+    expect(childPositions.every(([x, y]) => Math.abs(x - 0.50001) < 0.00001 && y === 0.5)).toBe(true);
+    expect(leafPositions).toEqual(expect.arrayContaining(points.features.map(point => point.geometry.coordinates)));
+});
+
+test('worldCoordinates returns no tile for a column on either side of the world', () => {
+    const inTheTwoTopTiles = {type: 'MultiPoint' as const, coordinates: [[0.25, 0.25], [0.75, 0.25]]};
+
+    const index = new GeoJSONVT(inTheTwoTopTiles, {worldCoordinates: true});
+
+    expect([index.getTile(1, -1, 0), index.getTile(1, 2, 0)]).toEqual([null, null]);
+});
+
+const weightedPoints = {
+    type: 'FeatureCollection' as const,
+    features: [[0, 1], [0.01, 2], [100, 10], [100.01, 20]].map(([lng, weight]) => ({
+        type: 'Feature' as const,
+        geometry: {type: 'Point' as const, coordinates: [lng, 0]},
+        properties: {weight}
+    }))
+};
+
+const sumWeights = {
+    map: (props: GeoJSON.GeoJsonProperties) => ({sum: (props as {weight: number}).weight}),
+    reduce: (a: Record<string, unknown>, b: Record<string, unknown>) => { (a as {sum: number}).sum += (b as {sum: number}).sum; }
+};
+
+test('updateClusterOptions aggregates cluster properties when it adds a reduce function', () => {
+    const index = new GeoJSONVT(weightedPoints, {
+        updateable: true,
+        cluster: true,
+        clusterOptions: {maxZoom: 2}
+    });
+
+    index.updateClusterOptions(true, {maxZoom: 2, ...sumWeights});
+
+    expect(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum)).toEqual([3, 30]);
+});
+
+test('updateClusterOptions stops aggregating cluster properties when it removes the reduce function', () => {
+    const index = new GeoJSONVT(weightedPoints, {
+        updateable: true,
+        cluster: true,
+        clusterOptions: {maxZoom: 2, ...sumWeights}
+    });
+
+    index.updateClusterOptions(true, {maxZoom: 2});
+
+    expect(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum)).toEqual([undefined, undefined]);
+});
+
+test('skips an empty polygon of a MultiPolygon', () => {
+    const multiPolygon = {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[0, 0], [10, 0], [10, 10], [0, 0]]], []]
+    };
+
+    const index = new GeoJSONVT(multiPolygon, {maxZoom: 5});
+
+    expect(index.getTile(0, 0, 0).features[0].geometry).toEqual([[[2048, 2048], [2162, 1934], [2162, 2048], [2048, 2048]]]);
+});
+
+test('leaves out a MultiPolygon that has only empty polygons', () => {
+    const multiPolygon = {
+        type: 'MultiPolygon' as const,
+        coordinates: [[]] as GeoJSON.Position[][][]
+    };
+
+    const index = new GeoJSONVT(multiPolygon, {updateable: true});
+
+    expect(index.getData()).toEqual({type: 'FeatureCollection', features: []});
+});
+
+test('keeps the corner of a polygon whose vertex lies on the left edge of a tile', () => {
+    const polygon = {
+        type: 'Polygon' as const,
+        coordinates: [[[-90, -90], [0, -90], [90, -90], [0, 0], [-90, -90]]]
+    };
+
+    const index = new GeoJSONVT(polygon, {indexMaxZoom: 0, maxZoom: 24, tolerance: 1.5, buffer: 0});
+
+    expect(index.getTile(1, 1, 1).features[0].geometry).toEqual([[[0, 4096], [0, 0], [0, 0], [2048, 4096], [0, 4096]]]);
+});
+
+test('keeps the corner of a polygon whose vertex lies on the right edge of a tile', () => {
+    const polygon = {
+        type: 'Polygon' as const,
+        coordinates: [[[20, 34.365234375], [80, 4.34326171875], [45, 4.34326171875], [20, 4.34326171875], [20, 34.365234375]]]
+    };
+
+    const index = new GeoJSONVT(polygon, {maxZoom: 5, buffer: 0});
+
+    expect(index.getTile(3, 4, 3).features[0].geometry).toEqual([[[1820, 762], [4096, 1986], [4096, 3700], [1820, 3700], [1820, 762]]]);
+});
+
+test('keeps the part of a line that enters a tile exactly at a vertex', () => {
+    const line = {
+        type: 'LineString' as const,
+        coordinates: [[-90, 20], [0, 20], [90, 20]]
+    };
+
+    const index = new GeoJSONVT(line, {lineMetrics: true, buffer: 0});
+
+    const feature = index.getTile(1, 1, 0).features[0];
+    expect(feature.geometry).toEqual([[[0, 3631], [2048, 3631]]]);
+    expect(feature.tags).toEqual({geojsonvt_clip_start: 0.5, geojsonvt_clip_end: 1});
+});
+
+test('clusters each position of a MultiPoint feature when clustering is on', () => {
+    const multiPoint = {
+        type: 'Feature' as const,
+        id: 7,
+        properties: {name: 'multi'},
+        geometry: {type: 'MultiPoint' as const, coordinates: [[20, 20], [20.0001, 20], [60, 20]]}
+    };
+
+    const index = new GeoJSONVT(multiPoint, {cluster: true});
+
+    expect(index.getTile(0, 0, 0).features).toEqual([
+        {type: 1, geometry: [[284, 227]], tags: {cluster: true, cluster_id: 20, point_count: 2, point_count_abbreviated: 2}, id: 20},
+        {type: 1, geometry: [[341, 227]], tags: {name: 'multi'}, id: 7}
+    ]);
+});
+
+test('worldCoordinates leaves the positions of a MultiPoint outside the world out of the clusters', () => {
+    const multiPoint = {
+        type: 'Feature' as const,
+        properties: {},
+        geometry: {type: 'MultiPoint' as const, coordinates: [[0.99, 0.5], [1.03, 0.5], [0.5, -0.03]]}
+    };
+
+    const index = new GeoJSONVT(multiPoint, {worldCoordinates: true, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+});