@maplibre/geojson-vt 6.1.2 → 6.3.0

package/src/geojsonvt.test.ts

@@ -36,4 +36,390 @@ 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('a unit square without wrap 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, {coordinates: 'unitSquare', wrap: false});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[[2770, -64], [3072, 2048], [4160, 2048]]]]);
+});
+
+test('a unit square without wrap 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]}, {coordinates: 'unitSquare', wrap: false, 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('a unit square without wrap returns the data in the unit square', () => {
+    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}, {coordinates: 'unitSquare', wrap: false, updateable: true});
+
+    expect(index.getData()).toEqual({type: 'FeatureCollection', features});
+});
+
+test('a unit square without wrap keeps a MultiLineString it splits for lineMetrics in the unit square', () => {
+    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, {coordinates: 'unitSquare', wrap: false, 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('a unit square without wrap hands the update filter features in the unit square', () => {
+    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]}, {coordinates: 'unitSquare', wrap: false, 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('a unit square without wrap 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, {coordinates: 'unitSquare', wrap: false, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+});
+
+test('a unit square without wrap 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, {coordinates: 'unitSquare', wrap: false, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features).toHaveLength(2);
+});
+
+test('a unit square without wrap returns cluster children and leaves in the unit square', () => {
+    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, {coordinates: 'unitSquare', wrap: false, 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('a unit square without wrap stays without wrap for clusters after updateData', () => {
+    const point = (id: string, x: number) => ({type: 'Feature' as const, id, properties: {}, geometry: {type: 'Point' as const, coordinates: [x, 0.5]}});
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [point('a', 0.01)]}, {coordinates: 'unitSquare', wrap: false, cluster: true, updateable: true});
+
+    index.updateData({add: [point('b', 0.99)]});
+
+    expect(index.getTile(1, -1, 0)).toBeNull();
+});
+
+test('wraps positions in the unit square around the antimeridian by default', () => {
+    const nearTheEastEdge = {type: 'Feature' as const, properties: {}, geometry: {type: 'Point' as const, coordinates: [0.999, 0.25]}};
+    const index = new GeoJSONVT(nearTheEastEdge, {coordinates: 'unitSquare'});
+
+    expect(index.getTile(1, 0, 0).features.map(feature => feature.geometry)).toEqual([[[-8, 2048]]]);
+});
+
+test('cuts the top tile above and below for positions in a unit square that wraps', () => {
+    const fromThreeBelowToThreeAbove = {type: 'Feature' as const, properties: {}, geometry: {type: 'LineString' as const, coordinates: [[0.25, -3], [0.75, 3]]}};
+    const index = new GeoJSONVT(fromThreeBelowToThreeAbove, {coordinates: 'unitSquare'});
+
+    expect(index.getTile(0, 0, 0).features[0].geometry).toEqual([[[2043, -64], [2395, 4160]]]);
+});
+
+test('copies no lng/lat features across the antimeridian without wrap', () => {
+    const nearTheAntimeridian = {type: 'Feature' as const, properties: {}, geometry: {type: 'Point' as const, coordinates: [179.9, -10]}};
+    const index = new GeoJSONVT(nearTheAntimeridian, {wrap: false});
+
+    expect(index.getTile(1, 0, 1)?.features ?? []).toEqual([]);
+    expect(index.getTile(1, 1, 1).features).toHaveLength(1);
+});
+
+test('a unit square without wrap 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, {coordinates: 'unitSquare', wrap: false});
+
+    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('updateData draws a feature again when an update gives back the coordinates an earlier one took away', () => {
+    const line = {type: 'Feature' as const, id: 'line', properties: {name: 'line'}, geometry: {type: 'LineString' as const, coordinates: [[0, 0], [10, 10]]}};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [line]}, {updateable: true});
+
+    index.updateData({update: [{id: 'line', newGeometry: {type: 'LineString', coordinates: []}}]});
+    index.updateData({update: [{id: 'line', newGeometry: line.geometry}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'line'}]);
+});
+
+test('updateData draws a feature loaded without a geometry once an update gives it one', () => {
+    const later: GeoJSON.Feature = {type: 'Feature', id: 'later', properties: {name: 'later'}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [later]}, {updateable: true});
+
+    index.updateData({update: [{id: 'later', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'later'}]);
+});
+
+test('updateData draws a feature added without coordinates once an update gives it some', () => {
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: []}, {updateable: true});
+
+    index.updateData({add: [{type: 'Feature', id: 'added', properties: {name: 'added'}, geometry: {type: 'Polygon', coordinates: []}}]});
+    index.updateData({update: [{id: 'added', newGeometry: {type: 'Polygon', coordinates: [[[0, 0], [10, 0], [10, 10], [0, 0]]]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'added'}]);
+});
+
+test('updateData leaves a feature without a geometry removed when an update gives it one', () => {
+    const kept = {type: 'Feature' as const, id: 'kept', properties: {}, geometry: {type: 'Point' as const, coordinates: [0, 0]}};
+    const removed: GeoJSON.Feature = {type: 'Feature', id: 'removed', properties: {}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [kept, removed]}, {updateable: true});
+
+    index.updateData({remove: ['removed']});
+    index.updateData({update: [{id: 'removed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+});
+
+test('updateData leaves a feature without a geometry removed by removeAll when an update gives it one', () => {
+    const kept = {type: 'Feature' as const, id: 'kept', properties: {}, geometry: {type: 'Point' as const, coordinates: [0, 0]}};
+    const removed: GeoJSON.Feature = {type: 'Feature', id: 'removed', properties: {}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [removed]}, {updateable: true});
+
+    index.updateData({removeAll: true, add: [kept]});
+    index.updateData({update: [{id: 'removed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+});
+
+test('updateData keeps the property changes made to a feature while it has no geometry', () => {
+    const renamed: GeoJSON.Feature = {type: 'Feature', id: 'renamed', properties: {name: 'before'}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [renamed]}, {updateable: true});
+
+    index.updateData({update: [{id: 'renamed', addOrUpdateProperties: [{key: 'name', value: 'after'}]}]});
+    index.updateData({update: [{id: 'renamed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'after'}]);
+});
+
+test('updateData does not bring back a feature the update filter took out after an update gave it a geometry', () => {
+    const kept = {type: 'Feature' as const, id: 'kept', properties: {}, geometry: {type: 'Point' as const, coordinates: [0, 0]}};
+    const hidden: GeoJSON.Feature = {type: 'Feature', id: 'hidden', properties: {hidden: true}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [kept, hidden]}, {updateable: true});
+
+    index.updateData({update: [{id: 'hidden', newGeometry: {type: 'Point', coordinates: [10, 10]}}]}, feature => !feature.properties.hidden);
+    index.updateData({update: [{id: 'hidden', newGeometry: {type: 'Point', coordinates: [20, 20]}}]});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+});
+
+test('updateData does not bring back a feature the update filter took out while it had no coordinates', () => {
+    const point = {type: 'Feature' as const, id: 'point', properties: {keep: true}, geometry: {type: 'Point' as const, coordinates: [0, 0]}};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [point]}, {updateable: true});
+    const keepIfMarked = (feature: GeoJSON.Feature) => feature.properties?.keep === true;
+
+    index.updateData({update: [{id: 'point', newGeometry: {type: 'Point', coordinates: []}, addOrUpdateProperties: [{key: 'keep', value: false}]}]}, keepIfMarked);
+    index.updateData({update: [{id: 'point', newGeometry: {type: 'Point', coordinates: [10, 10]}, addOrUpdateProperties: [{key: 'keep', value: true}]}]}, keepIfMarked);
+
+    expect(index.getData()).toEqual({type: 'FeatureCollection', features: []});
+});
+
+test('updateData draws a bare geometry loaded without coordinates once an update gives it some', () => {
+    const index = new GeoJSONVT({type: 'LineString', coordinates: []}, {updateable: true, generateId: true});
+
+    index.updateData({update: [{id: 0, newGeometry: {type: 'LineString', coordinates: [[0, 0], [10, 10]]}}]});
+
+    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual([0]);
+});
+
+test('updateData keeps a feature loaded without a geometry away from the update filter', () => {
+    const point = {type: 'Feature' as const, id: 'point', properties: {}, geometry: {type: 'Point' as const, coordinates: [0, 0]}};
+    const later: GeoJSON.Feature = {type: 'Feature', id: 'later', properties: {}, geometry: null};
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [point, later]}, {updateable: true});
+    const pointsOnly = (feature: GeoJSON.Feature) => feature.geometry.type === 'Point';
+
+    index.updateData({update: [{id: 'point', addOrUpdateProperties: [{key: 'name', value: 'p'}]}]}, pointsOnly);
+    index.updateData({update: [{id: 'later', newGeometry: {type: 'Point', coordinates: [10, 10]}}]}, pointsOnly);
+
+    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id).sort()).toEqual(['later', 'point']);
+});
+
+test('updateData hands the filter a feature without coordinates with its promoted id', () => {
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [{type: 'Feature', id: 'raw', properties: {key: 'promoted'}, geometry: {type: 'Point', coordinates: []}}]}, {updateable: true, promoteId: 'key'});
+
+    index.updateData({}, feature => feature.id === 'promoted');
+    index.updateData({update: [{id: 'promoted', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual(['promoted']);
+});
+
+test('updateData hands the filter a feature without coordinates with its generated id', () => {
+    const index = new GeoJSONVT({type: 'FeatureCollection', features: [{type: 'Feature', properties: {}, geometry: {type: 'Point', coordinates: []}}]}, {updateable: true, generateId: true});
+
+    index.updateData({}, feature => feature.id === 0);
+    index.updateData({update: [{id: 0, newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
+
+    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual([0]);
+});
+
+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('a unit square without wrap 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, {coordinates: 'unitSquare', wrap: false, cluster: true});
+
+    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+});

package/src/geojsonvt.ts

@@ -1,10 +1,11 @@
 import {convertToInternal} from './convert';
 import {convertToGeoJSON, featureToGeoJSON} from './deconvert';
+import {getWorldCoordinateHelper, type WorldCoordinateHelper} from './world-coordinate-helper';
 import {wrap} from './wrap';
 import {applySourceDiff, type GeoJSONVTSourceDiff} from './difference';
 import {ClusterTileIndex, defaultClusterOptions} from './cluster-tile-index';
 import {TileIndex} from './tile-index';
-import type {ClusterOrPointFeature, GeoJSONVTTileIndex, GeoJSONVTInternalFeature, GeoJSONVTOptions, GeoJSONVTTile, SuperclusterOptions} from './definitions';
+import type {ClusterOrPointFeature, GeoJSONVTTileIndex, GeoJSONVTInternalFeature, GeoJSONVTOptions, GeoJSONVTTile} from './definitions';
 
 export const defaultOptions: GeoJSONVTOptions = {
     maxZoom: 14,
@@ -19,7 +20,9 @@ export const defaultOptions: GeoJSONVTOptions = {
     updateable: false,
     cluster: false,
     clusterOptions: defaultClusterOptions,
-    debug: 0
+    debug: 0,
+    coordinates: 'lngLat',
+    wrap: true
 };
 
 /**
@@ -27,12 +30,15 @@ export const defaultOptions: GeoJSONVTOptions = {
  */
 export class GeoJSONVT {
     private options: GeoJSONVTOptions;
+    private worldCoordinateHelper: WorldCoordinateHelper;
     
     private source?: GeoJSONVTInternalFeature[];
+    private unlocated?: Map<string | number, GeoJSON.Feature>;
     private tileIndex: GeoJSONVTTileIndex;
 
     constructor(data: GeoJSON.GeoJSON, options?: GeoJSONVTOptions) {
         options = this.options = Object.assign({}, defaultOptions, options);
+        this.worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 
         const debug = options.debug;
 
@@ -41,8 +47,11 @@ export class GeoJSONVT {
         if (options.maxZoom < 0 || options.maxZoom > 24) throw new Error('maxZoom should be in the 0-24 range');
         if (options.promoteId && options.generateId) throw new Error('promoteId and generateId cannot be used together.');
 
+        // for updateable indexes, keep the properties of the features without coordinates, so that an update can give them some
+        if (options.updateable) this.unlocated = new Map();
+
         // projects and adds simplification info
-        let features = convertToInternal(data, options);
+        let features = convertToInternal(data, options, this.unlocated);
 
         if (debug) {
             console.timeEnd('preprocess data');
@@ -62,7 +71,7 @@ export class GeoJSONVT {
     }
 
     private initializeIndex(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions) {
-        this.tileIndex = options.cluster ? new ClusterTileIndex(options.clusterOptions) : new TileIndex(options);
+        this.tileIndex = options.cluster ? new ClusterTileIndex({...options.clusterOptions, coordinates: options.coordinates, wrap: options.wrap}) : new TileIndex(options);
         if (!features.length) return;
         this.tileIndex.initialize(features);
     }
@@ -94,7 +103,7 @@ export class GeoJSONVT {
         if (!options.updateable) throw new Error('to update tile geojson `updateable` option must be set to true');
 
         // apply diff and collect affected features and updated source that will be used to invalidate tiles
-        let {affected, source} = applySourceDiff(this.source, diff, options);
+        let {affected, source} = applySourceDiff(this.source, diff, options, this.unlocated);
 
         if (filter) {
             ({affected, source} = this.filterUpdate(source, affected, filter));
@@ -110,19 +119,25 @@ export class GeoJSONVT {
     }
 
     /**
-     * Filter an update using a predicate function. Returns the affected and updated source features.
+     * Filter an update using a predicate function, the features an update emptied included, so that one the filter
+     * rejects can't come back with a later update. A feature without a geometry at all isn't passed to the predicate.
+     * Returns the affected and updated source features.
      */
     private filterUpdate(source: GeoJSONVTInternalFeature[], affected: GeoJSONVTInternalFeature[], predicate: (feature: GeoJSON.Feature) => boolean) {
         const removeIds = new Set();
 
         for (const feature of source) {
             if (feature.id == undefined) continue;
-            if (predicate(featureToGeoJSON(feature))) continue;
+            if (predicate(featureToGeoJSON(feature, this.worldCoordinateHelper))) continue;
             affected.push(feature);
             removeIds.add(feature.id);
         }
         source = source.filter(feature => !removeIds.has(feature.id));
 
+        for (const [id, feature] of this.unlocated ?? []) {
+            if (feature.geometry && !predicate(feature)) this.unlocated.delete(id);
+        }
+
         return {affected, source};
     }
 
@@ -131,15 +146,15 @@ export class GeoJSONVT {
      */
     getData(): GeoJSON.GeoJSON {
         if (!this.options.updateable) throw new Error('to retrieve data the `updateable` option must be set to true');
-        return convertToGeoJSON(this.source);
+        return convertToGeoJSON(this.source, this.worldCoordinateHelper);
     }
     
     /**
      * Update supercluster options and regenerate the index.
      * @param cluster - whether to enable clustering
-     * @param clusterOptions - {@link SuperclusterOptions}
+     * @param clusterOptions - {@link SuperclusterOptions} without `coordinates` and `wrap`, which come from the index options
      */
-    updateClusterOptions(cluster: boolean, clusterOptions: SuperclusterOptions) {
+    updateClusterOptions(cluster: boolean, clusterOptions: GeoJSONVTOptions['clusterOptions']) {
         const wasCluster = this.options.cluster;
         this.options.cluster = cluster;
         this.options.clusterOptions = clusterOptions;

package/src/index.ts

@@ -1,6 +1,6 @@
 
 import type {GeoJSONVTFeatureDiff, GeoJSONVTSourceDiff} from './difference';
-import type {GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTOptions, GeoJSONToTileOptions, PartialGeoJSONVTFeature, SliceArray, SliceFixedArray, ClusterProperties, ClusterFeature, ClusterOrPointFeature, GeoJSONVTTile, GeoJSONVTFeature, GeoJSONVTFeaturePoint, GeoJSONVTFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, GeoJSONVTTileIndex, SuperclusterOptions} from './definitions';
+import type {GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTOptions, GeoJSONToTileOptions, PartialGeoJSONVTFeature, SliceArray, SliceFixedArray, ClusterProperties, ClusterFeature, ClusterOrPointFeature, GeoJSONVTTile, GeoJSONVTFeature, GeoJSONVTFeaturePoint, GeoJSONVTFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, GeoJSONVTTileIndex, SuperclusterOptions, GeoJSONVTCoordinatesType} from './definitions';
 import type {KDBushWithData} from './cluster-tile-index';
 import {GeoJSONVT} from './geojsonvt';
 import {ClusterTileIndex} from './cluster-tile-index';
@@ -39,6 +39,7 @@ export type {
     GeoJSONVTInternalPolygonFeature,
     GeoJSONVTInternalMultiPolygonFeature,
     SuperclusterOptions,
+    GeoJSONVTCoordinatesType,
     ClusterProperties,
     ClusterFeature,
     ClusterOrPointFeature,

package/src/tile-index.ts

@@ -23,7 +23,7 @@ export class TileIndex implements GeoJSONVTTileIndex {
 
     initialize(features: GeoJSONVTInternalFeature[]): void {
         // start slicing from the top tile down
-        this.splitTile(features, 0, 0, 0);
+        this.splitTile(this.clipToWorld(features), 0, 0, 0);
 
         if (this.options.debug) {
             if (features.length) console.log('features: %d, points: %d', this.tiles[0].numFeatures, this.tiles[0].numPoints);
@@ -45,8 +45,9 @@ export class TileIndex implements GeoJSONVTTileIndex {
 
         // re-generate root tile with updated feature set
         const [z, x, y] = [0, 0, 0];
-        const rootTile = createTile(source, z, x, y, options);
-        rootTile.source = source;
+        const rootSource = this.clipToWorld(source);
+        const rootTile = createTile(rootSource, z, x, y, options);
+        rootTile.source = rootSource;
 
         // update tile index with new root tile - ready for getTile calls
         const id = toID(z, x, y);
@@ -83,6 +84,7 @@ export class TileIndex implements GeoJSONVTTileIndex {
         const {extent, debug} = this.options;
         
         const z2 = 1 << z;
+        if (!this.options.wrap && (x < 0 || x >= z2)) return null; // a row outside the world has no tile either
         x = (x + z2) & (z2 - 1); // wrap tile x coordinate
 
         const id = toID(z, x, y);
@@ -119,6 +121,20 @@ export class TileIndex implements GeoJSONVTTileIndex {
         return transformTile(this.tiles[id], extent);
     }
 
+    /**
+     * The features the top tile starts from. A world that wraps keeps them all left and right, where wrapping already
+     * put them inside, and one that doesn't only what lies inside the world square and its buffer. Positions in the
+     * unit square are also cut above and below in a world that wraps, where lng/lat is clamped already. The index keeps
+     * the rest, so an update can still move a feature in from outside.
+     */
+    private clipToWorld(features: GeoJSONVTInternalFeature[]): GeoJSONVTInternalFeature[] {
+        const {wrap, coordinates} = this.options;
+        if (wrap && coordinates !== 'unitSquare') return features;
+        const buffer = this.options.buffer / this.options.extent;
+        const inX = wrap ? features : clip(features, 1, -buffer, 1 + buffer, AxisType.X, -Infinity, Infinity, this.options) || [];
+        return clip(inX, 1, -buffer, 1 + buffer, AxisType.Y, -Infinity, Infinity, this.options) || [];
+    }
+
     /**
      * splits features from a parent tile to sub-tiles.
      * z, x, and y are the coordinates of the parent tile

package/src/world-coordinate-helper.ts

@@ -0,0 +1,63 @@
+import type {GeoJSONVTCoordinatesType} from './definitions';
+
+/**
+ * How the positions of the input relate to the world square the tiles cover, in which x and y run from 0 to 1.
+ */
+export interface WorldCoordinateHelper {
+    projectX(x: number): number;
+    projectY(y: number): number;
+    unprojectX(x: number): number;
+    unprojectY(y: number): number;
+}
+
+/**
+ * Longitude and latitude, which spherical mercator puts in the world square.
+ */
+class MercatorWorldCoordinateHelper implements WorldCoordinateHelper {
+    projectX(lng: number): number {
+        return lng / 360 + 0.5;
+    }
+
+    projectY(lat: number): number {
+        const sin = Math.sin(lat * Math.PI / 180);
+        const y = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+        return y < 0 ? 0 : y > 1 ? 1 : y;
+    }
+
+    unprojectX(x: number): number {
+        return (x - 0.5) * 360;
+    }
+
+    unprojectY(y: number): number {
+        const y2 = (180 - y * 360) * Math.PI / 180;
+        return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+    }
+}
+
+/**
+ * Positions in the unit square already, see `coordinates` in {@link GeoJSONVTOptions}.
+ */
+class IdentityWorldCoordinateHelper implements WorldCoordinateHelper {
+    projectX(x: number): number {
+        return x;
+    }
+
+    projectY(y: number): number {
+        return y;
+    }
+
+    unprojectX(x: number): number {
+        return x;
+    }
+
+    unprojectY(y: number): number {
+        return y;
+    }
+}
+
+export const mercatorWorldCoordinateHelper: WorldCoordinateHelper = new MercatorWorldCoordinateHelper();
+const identityWorldCoordinateHelper: WorldCoordinateHelper = new IdentityWorldCoordinateHelper();
+
+export function getWorldCoordinateHelper(coordinates?: GeoJSONVTCoordinatesType): WorldCoordinateHelper {
+    return coordinates === 'unitSquare' ? identityWorldCoordinateHelper : mercatorWorldCoordinateHelper;
+}

package/src/wrap.ts

@@ -4,6 +4,8 @@ import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, SliceArray, SliceFixed
 import {createFeature, optimizeLineMemory} from './feature';
 
 export function wrap(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
+    if (!options.wrap) return features;
+
     const buffer = options.buffer / options.extent;
     let merged = features;