@maplibre/geojson-vt 6.1.2 → 6.3.0

package/src/convert.ts

@@ -1,6 +1,7 @@
 
 import {simplify} from './simplify';
 import {createFeature, optimizeLineMemory} from './feature';
+import {getWorldCoordinateHelper, type WorldCoordinateHelper} from './world-coordinate-helper';
 import type {GeoJSONVTInternalFeature, GeoJSONVTOptions, SliceArray} from './definitions';
 
 const MAX_GEOMETRY_COLLECTION_DEPTH = 1024;
@@ -9,27 +10,42 @@ const MAX_GEOMETRY_COLLECTION_DEPTH = 1024;
  * converts GeoJSON to internal source features (an intermediate projected JSON vector format with simplification data)
  * @param data
  * @param options
+ * @param unlocated - the features without coordinates, by id: a feature with an id that converts to nothing is set in it, and one that converts to something is deleted from it
  * @returns
  */
-export function convertToInternal(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
+export function convertToInternal(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions, unlocated?: Map<string | number, GeoJSON.Feature>): GeoJSONVTInternalFeature[] {
     const features: GeoJSONVTInternalFeature[] = [];
 
     switch (data.type) {
         case 'FeatureCollection':
             for (let i = 0; i < data.features.length; i++) {
-                featureToInternal(features, data.features[i], options, i);
+                convertFeature(features, data.features[i], options, unlocated, i);
             }
             break;
         case 'Feature':
-            featureToInternal(features, data, options);
+            convertFeature(features, data, options, unlocated);
             break;
         default:
-            featureToInternal(features, {type: "Feature" as const, geometry: data, properties: undefined}, options);
+            convertFeature(features, {type: "Feature" as const, geometry: data, properties: undefined}, options, unlocated);
     }
 
     return features;
 }
 
+function convertFeature(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, unlocated?: Map<string | number, GeoJSON.Feature>, index?: number) {
+    const count = features.length;
+    featureToInternal(features, geojson, options, index);
+    if (!unlocated) return;
+
+    const id = getFeatureId(geojson, options, index);
+    if (id == null) return;
+    if (features.length > count) {
+        unlocated.delete(id);
+    } else {
+        unlocated.set(id, {...geojson, id});
+    }
+}
+
 function featureToInternal(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number, depth = 0) {
     if (!geojson.geometry) return;
 
@@ -47,30 +63,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 worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 
     switch (geojson.geometry.type) {
         case 'Point':
-            convertPointFeature(features, id, geojson.geometry, geojson.properties);
+            convertPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiPoint':
-            convertMultiPointFeature(features, id, geojson.geometry, geojson.properties);
+            convertMultiPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'LineString':
-            convertLineStringFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiLineString':
-            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, options, geojson.properties);
+            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, options, geojson.properties);
             return;
 
         case 'Polygon':
-            convertPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiPolygon':
-            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         default:
@@ -99,64 +116,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, worldCoordinateHelper: WorldCoordinateHelper, properties: GeoJSON.GeoJsonProperties) {
     const out: number[] = [];
-    out.push(projectX(geom.coordinates[0]), projectY(geom.coordinates[1]), 0);
+    out.push(worldCoordinateHelper.projectX(geom.coordinates[0]), worldCoordinateHelper.projectY(geom.coordinates[1]), 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, worldCoordinateHelper: WorldCoordinateHelper, properties: GeoJSON.GeoJsonProperties) {
     const out: number[] = [];
     for (const coords of geom.coordinates) {
-        out.push(projectX(coords[0]), projectY(coords[1]), 0);
+        out.push(worldCoordinateHelper.projectX(coords[0]), worldCoordinateHelper.projectY(coords[1]), 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, worldCoordinateHelper: WorldCoordinateHelper, properties: GeoJSON.GeoJsonProperties) {
     const out: SliceArray = {points: []};
-    convertLine(geom.coordinates, out, tolerance, false);
+    convertLine(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
     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, worldCoordinateHelper: WorldCoordinateHelper, 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, worldCoordinateHelper);
             features.push(createFeature(id, 'LineString', out, properties));
         }
     } else {
         const out: SliceArray[] = [];
-        convertLines(geom.coordinates, out, tolerance, false);
+        convertLines(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
         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, worldCoordinateHelper: WorldCoordinateHelper, properties: GeoJSON.GeoJsonProperties) {
     const out: SliceArray[] = [];
-    convertLines(geom.coordinates, out, tolerance, true);
+    convertLines(geom.coordinates, out, tolerance, true, worldCoordinateHelper);
     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, worldCoordinateHelper: WorldCoordinateHelper, 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, worldCoordinateHelper);
+        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, worldCoordinateHelper: WorldCoordinateHelper) {
     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 = worldCoordinateHelper.projectX(ring[j][0]);
+        const y = worldCoordinateHelper.projectY(ring[j][1]);
 
         out.points.push(x, y, 0);
 
@@ -182,26 +203,10 @@ 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, worldCoordinateHelper: WorldCoordinateHelper) {
     for (let i = 0; i < rings.length; i++) {
         const geom: SliceArray = {points: []};
-        convertLine(rings[i], geom, tolerance, isPolygon);
+        convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinateHelper);
         out.push(geom);
     }
 }
-
-/**
- * Convert longitude to spherical mercator in [0..1] range
- */
-export function projectX(x: number) {
-    return x / 360 + 0.5;
-}
-
-/**
- * Convert latitude to spherical mercator in [0..1] range
- */
-export function projectY(y: number) {
-    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.test.ts

@@ -1,7 +1,7 @@
 
 import {test, expect} from 'vitest';
-import {featureToGeoJSON, unprojectX, unprojectY} from './deconvert';
-import {projectX, projectY} from './convert';
+import {featureToGeoJSON} from './deconvert';
+import {mercatorWorldCoordinateHelper} from './world-coordinate-helper';
 import type {GeoJSONVTInternalFeature} from './definitions';
 
 test('project/unproject roundtrip retains precision', () => {
@@ -19,8 +19,8 @@ test('project/unproject roundtrip retains precision', () => {
     ];
 
     for (const {lng, lat} of coords) {
-        expect(unprojectX(projectX(lng))).toBeCloseTo(lng, 10);
-        expect(unprojectY(projectY(lat))).toBeCloseTo(lat, 10);
+        expect(mercatorWorldCoordinateHelper.unprojectX(mercatorWorldCoordinateHelper.projectX(lng))).toBeCloseTo(lng, 10);
+        expect(mercatorWorldCoordinateHelper.unprojectY(mercatorWorldCoordinateHelper.projectY(lat))).toBeCloseTo(lat, 10);
     }
 });
 

package/src/deconvert.ts

@@ -1,12 +1,13 @@
+import {mercatorWorldCoordinateHelper, type WorldCoordinateHelper} from './world-coordinate-helper';
 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[], worldCoordinateHelper: WorldCoordinateHelper = mercatorWorldCoordinateHelper): GeoJSON.GeoJSON {
     const geojson: GeoJSON.GeoJSON = {
         type: 'FeatureCollection',
-        features: source.map(feature => featureToGeoJSON(feature))
+        features: source.map(feature => featureToGeoJSON(feature, worldCoordinateHelper))
     };
 
     return geojson;
@@ -15,10 +16,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, worldCoordinateHelper: WorldCoordinateHelper = mercatorWorldCoordinateHelper): GeoJSON.Feature {
     const geojsonFeature: GeoJSON.Feature = {
         type: 'Feature',
-        geometry: geometryToGeoJSON(feature),
+        geometry: geometryToGeoJSON(feature, worldCoordinateHelper),
         properties: feature.tags
     };
     if (feature.id != null) {
@@ -31,66 +32,51 @@ 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, worldCoordinateHelper: WorldCoordinateHelper): 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], worldCoordinateHelper)
             };
         case 'MultiPoint':
             return {
                 type: type,
-                coordinates: unprojectPoints(geometry)
+                coordinates: unprojectPoints(geometry, worldCoordinateHelper)
             };
         case 'LineString':
             return {
                 type: type,
-                coordinates: unprojectPoints(geometry.points)
+                coordinates: unprojectPoints(geometry.points, worldCoordinateHelper)
             };
         case 'MultiLineString':
         case 'Polygon':
             return {
                 type: type,
-                coordinates: geometry.map(ring => unprojectPoints(ring.points))
+                coordinates: geometry.map(ring => unprojectPoints(ring.points, worldCoordinateHelper))
             };
         case 'MultiPolygon':
             return {
                 type: type,
                 coordinates: geometry.map(polygon =>
-                    polygon.map(ring => unprojectPoints(ring.points))
+                    polygon.map(ring => unprojectPoints(ring.points, worldCoordinateHelper))
                 )
             };
     }
 }
 
-export function unprojectPoints(coords: number[] | Float64Array): GeoJSON.Position[] {
+export function unprojectPoints(coords: number[] | Float64Array, worldCoordinateHelper: WorldCoordinateHelper = mercatorWorldCoordinateHelper): 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], worldCoordinateHelper));
     }
 
     return result;
 }
 
-function unprojectPoint(x: number, y: number): GeoJSON.Position {
-    return [unprojectX(x), unprojectY(y)];
-}
-
-/**
- * Convert spherical mercator in [0..1] range to longitude
- */
-export function unprojectX(x: number): number {
-    return (x - 0.5) * 360;
-}
-
-/**
- * Convert spherical mercator in [0..1] range to latitude
- */
-export function unprojectY(y: number): number {
-    const y2 = (180 - y * 360) * Math.PI / 180;
-    return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+function unprojectPoint(x: number, y: number, worldCoordinateHelper: WorldCoordinateHelper): GeoJSON.Position {
+    return [worldCoordinateHelper.unprojectX(x), worldCoordinateHelper.unprojectY(y)];
 }

package/src/definitions.ts

@@ -1,3 +1,9 @@
+/**
+ * The space positions are given in, see `coordinates` in {@link GeoJSONVTOptions}.
+ * @experimental
+ */
+export type GeoJSONVTCoordinatesType = 'lngLat' | 'unitSquare';
+
 export type GeoJSONVTOptions = {
     /**
      * Max zoom to preserve detail on
@@ -54,20 +60,39 @@ export type GeoJSONVTOptions = {
      */
     debug?: number;
     /**
-     * Enable Supercluster for point features.
+     * The space the positions are in. `'lngLat'` is longitude and latitude, which web mercator puts in the square from 0
+     * to 1 that tile 0/0/0 covers, with latitudes beyond ~85.05 degrees clamped onto its top and bottom. `'unitSquare'`
+     * is x and y in that square already, y growing downward, taken as they are, for data in another projection.
+     * `getData` and the cluster methods return positions in the same space.
+     * @experimental
+     * @default 'lngLat'
+     */
+    coordinates?: GeoJSONVTCoordinatesType;
+    /**
+     * Whether the world wraps around the antimeridian. With `true`, features near the left or right edge are copied
+     * across it, and the tiles at either edge include what lies past it. With `false`, the world is the square and ends
+     * at its edges. Features are cut at the tile buffer around it, points outside it are left out of the clusters, and
+     * `getTile` returns `null` outside it. `geoJSONToTile` doesn't wrap unless this is `true`.
+     * @experimental
+     * @default true
+     */
+    wrap?: 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;
     /**
-     * Options for the Supercluster point clustering algorithm.
+     * Options for the Supercluster point clustering algorithm. `coordinates` and `wrap` come from the options above.
      * @see {@link SuperclusterOptions}
      */
-    clusterOptions?: SuperclusterOptions;
+    clusterOptions?: Omit<SuperclusterOptions, 'coordinates' | 'wrap'>;
 };
 
 export type GeoJSONToTileOptions = GeoJSONVTOptions & {
     /**
-     * Whether to wrap features around the antimeridian
+     * Whether to wrap features around the antimeridian, see `wrap` in {@link GeoJSONVTOptions}.
      * @default false
      */
     wrap?: boolean;
@@ -214,12 +239,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 +274,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;
@@ -263,4 +289,19 @@ export type SuperclusterOptions = {
      * @default props => props
      */
     map?: (props: GeoJSON.GeoJsonProperties) => Record<string, unknown>;
+    /**
+     * The space the points are in, see `coordinates` in {@link GeoJSONVTOptions}. The bounding box of `getClusters` is
+     * in the same space.
+     * @experimental
+     * @default 'lngLat'
+     */
+    coordinates?: GeoJSONVTCoordinatesType;
+    /**
+     * Whether the world wraps around the antimeridian, see `wrap` in {@link GeoJSONVTOptions}. With `false`, points
+     * outside the square are left out of the clusters, the tiles at an edge get no points from the opposite one, and
+     * `getTile` returns `null` outside the square.
+     * @experimental
+     * @default true
+     */
+    wrap?: 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

@@ -70,9 +70,10 @@ type HashedGeoJSONVTSourceDiff = {
  * @param source 
  * @param dataDiff 
  * @param options 
+ * @param unlocated - the features without coordinates, by id, so that an update can give them some
  * @returns 
  */
-export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions): ApplySourceDiffResult {
+export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions, unlocated?: Map<string | number, GeoJSON.Feature>): ApplySourceDiffResult {
     // convert diff to sets/maps for o(1) lookups
     const diff = diffToHashed(dataDiff, options);
 
@@ -82,9 +83,12 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
     if (diff.removeAll) {
         affected = source;
         source = [];
+        unlocated?.clear();
     }
 
     if (diff.remove.size || diff.add.size) {
+        for (const id of diff.remove) unlocated?.delete(id);
+
         const removeFeatures = [];
 
         // Collect features to remove (explicit removals + replacements via add)
@@ -101,7 +105,7 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
         }
 
         if (diff.add.size) {
-            let addFeatures = convertToInternal({type: 'FeatureCollection', features: Array.from(diff.add.values())}, options);
+            let addFeatures = convertToInternal({type: 'FeatureCollection', features: Array.from(diff.add.values())}, options, unlocated);
             addFeatures = wrap(addFeatures, options);
             affected = affected.concat(addFeatures);
             source = source.concat(addFeatures);
@@ -121,8 +125,14 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
         }
         for (const [id, update] of diff.update) {
             const oldFeatures = oldFeaturesMap.get(id); 
-            if (!oldFeatures || oldFeatures.length === 0) continue;
-            const updatedFeatures = getUpdatedFeatures(oldFeatures, update, options);
+            if (!oldFeatures || oldFeatures.length === 0) {
+                if (!unlocated?.has(id)) continue;
+                const locatedFeatures = getUpdatedUnlocatedFeatures(id, update, options, unlocated);
+                affected = affected.concat(locatedFeatures);
+                keepFeatures = keepFeatures.concat(locatedFeatures);
+                continue;
+            }
+            const updatedFeatures = getUpdatedFeatures(oldFeatures, update, options, unlocated);
 
             affected = affected.concat(oldFeatures, updatedFeatures);
             keepFeatures = keepFeatures.concat(updatedFeatures);
@@ -138,28 +148,18 @@ 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.
+ * @param unlocated - the features without coordinates, by id, which a new geometry without coordinates adds the feature to
+ * @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[] {
+function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJSONVTFeatureDiff, options: GeoJSONVTOptions, unlocated?: Map<string | number, GeoJSON.Feature>): GeoJSONVTInternalFeature[] {
     const changeGeometry = !!update.newGeometry;
-    const changeProps =
-        update.removeAllProperties ||
-        update.removeProperties?.length > 0 ||
-        update.addOrUpdateProperties?.length > 0;
+    const changeProps = hasPropertyChanges(update);
 
     // if geometry changed, need to create a new geojson feature and convert to internal format
     if (changeGeometry) {
         const vtFeature = vtFeatures[0];
-        const geojsonFeature = {
-            type: 'Feature' as const,
-            id: vtFeature.id,
-            geometry: update.newGeometry,
-            properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
-        };
-
-        let features = convertToInternal({type: 'FeatureCollection', features: [geojsonFeature]}, options);
-        features = wrap(features, options);
-        return features;
+        const properties = changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags;
+        return convertNewGeometry(vtFeature.id, update.newGeometry, properties, options, unlocated);
     }
 
     if (changeProps) {
@@ -175,6 +175,35 @@ function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJ
     return vtFeatures;
 }
 
+/**
+ * Gets the features an update gives a feature without coordinates: none, unless its new geometry has some.
+ * Its property changes apply either way.
+ */
+function getUpdatedUnlocatedFeatures(id: string | number, update: GeoJSONVTFeatureDiff, options: GeoJSONVTOptions, unlocated: Map<string | number, GeoJSON.Feature>): GeoJSONVTInternalFeature[] {
+    const feature = unlocated.get(id);
+    const properties = hasPropertyChanges(update) ? applyPropertyUpdates(feature.properties, update) : feature.properties;
+    if (!update.newGeometry) {
+        unlocated.set(id, {...feature, properties});
+        return [];
+    }
+    return convertNewGeometry(id, update.newGeometry, properties, options, unlocated);
+}
+
+/**
+ * Converts the new geometry of a feature to internal format, keeping the id the feature already has
+ */
+function convertNewGeometry(id: GeoJSONVTInternalFeature['id'], geometry: GeoJSON.Geometry, properties: GeoJSON.GeoJsonProperties, options: GeoJSONVTOptions, unlocated?: Map<string | number, GeoJSON.Feature>): GeoJSONVTInternalFeature[] {
+    const geojsonFeature = {type: 'Feature' as const, id, geometry, properties};
+    const features = convertToInternal({type: 'FeatureCollection', features: [geojsonFeature]}, {...options, promoteId: undefined, generateId: false}, unlocated);
+    return wrap(features, options);
+}
+
+function hasPropertyChanges(update: GeoJSONVTFeatureDiff): boolean {
+    return update.removeAllProperties ||
+        update.removeProperties?.length > 0 ||
+        update.addOrUpdateProperties?.length > 0;
+}
+
 /**
  * helper to apply property updates from a diff update object to a properties object
  */
@@ -213,7 +242,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/geojson-to-tile.ts

@@ -40,8 +40,8 @@ import type {GeoJSONToTileOptions, GeoJSONVTTile} from './definitions';
  */
 
 export function geoJSONToTile(data: GeoJSON.GeoJSON, z: number, x: number, y: number, options: GeoJSONToTileOptions = {}): GeoJSONVTTile {
-    options = {...defaultOptions, ...options};
-    const {wrap: shouldWrap = false, clip: shouldClip = false} = options;
+    options = {...defaultOptions, wrap: false, ...options};
+    const {wrap: shouldWrap, clip: shouldClip = false} = options;
 
     let features = convertToInternal(data, options);
     if (shouldWrap) {