@maplibre/geojson-vt 6.0.5 → 6.1.1

package/dist/geojsonvt.d.ts

@@ -5,21 +5,6 @@ export declare const defaultOptions: GeoJSONVTOptions;
  * Main class for creating and managing a vector tile index from GeoJSON data.
  */
 export declare class GeoJSONVT {
-    /**
-     * @internal
-     * This is for the tests
-     */
-    get tiles(): any;
-    /**
-     * @internal
-     * This is for the tests
-     */
-    get stats(): any;
-    /**
-    * @internal
-    * This is for the tests
-    */
-    get total(): any;
     private options;
     private source?;
     private tileIndex;

package/dist/geojsonvt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geojsonvt.d.ts","sourceRoot":"","sources":["../src/geojsonvt.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,KAAK,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAC,qBAAqB,EAAgD,gBAAgB,EAAE,aAAa,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAE7J,eAAO,MAAM,cAAc,EAAE,gBAc5B,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAElB;;;OAGG;IACH,IAAW,KAAK,QAGf;IACD;;;OAGG;IACH,IAAW,KAAK,QAGf;IACA;;;MAGE;IACH,IAAW,KAAK,QAGf;IAED,OAAO,CAAC,OAAO,CAAmB;IAElC,OAAO,CAAC,MAAM,CAAC,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAqB;gBAE1B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB;IA8B7D,OAAO,CAAC,eAAe;IAMvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,IAAI;IAUzF;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO;IAqBpF;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,OAAO;IAK1B;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,mBAAmB;IAa1E;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIzD;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAIrE;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;CAG9G"}
+{"version":3,"file":"geojsonvt.d.ts","sourceRoot":"","sources":["../src/geojsonvt.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,KAAK,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAC,qBAAqB,EAAgD,gBAAgB,EAAE,aAAa,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAE7J,eAAO,MAAM,cAAc,EAAE,gBAc5B,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAClB,OAAO,CAAC,OAAO,CAAmB;IAElC,OAAO,CAAC,MAAM,CAAC,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAqB;gBAE1B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB;IA8B7D,OAAO,CAAC,eAAe;IAMvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,IAAI;IAUzF;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO;IAqBpF;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,OAAO;IAK1B;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,mBAAmB;IAa1E;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIzD;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAIrE;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;CAG9G"}

package/dist/tile-index.d.ts

@@ -2,6 +2,7 @@ import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, ClusterOrPointFeature,
 export declare class TileIndex implements GeoJSONVTTileIndex {
     private options;
     private tileCoords;
+    private total;
     /** @internal */
     tiles: {
         [key: string]: GeoJSONVTInternalTile;
@@ -10,8 +11,6 @@ export declare class TileIndex implements GeoJSONVTTileIndex {
     stats: {
         [key: string]: number;
     };
-    /** @internal */
-    total: number;
     constructor(options: GeoJSONVTOptions);
     initialize(features: GeoJSONVTInternalFeature[]): void;
     /** {@inheritdoc} */

package/dist/tile-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tile-index.d.ts","sourceRoot":"","sources":["../src/tile-index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjK,qBAAa,SAAU,YAAW,kBAAkB;IAWpC,OAAO,CAAC,OAAO;IAT3B,OAAO,CAAC,UAAU,CAAkD;IAEpE,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;KAAC,CAAC;IACrD,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAM;IAC3C,gBAAgB;IACT,KAAK,EAAE,MAAM,CAAK;gBAEL,OAAO,EAAE,gBAAgB;IAO7C,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,GAAG,IAAI;IAWtD,oBAAoB;IACpB,WAAW,CAAC,MAAM,EAAE,wBAAwB,EAAE,EAAE,QAAQ,EAAE,wBAAwB,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IA2BtH,oBAAoB;IAEpB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI1D,oBAAoB;IAEpB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAI/D,oBAAoB;IAEpB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;IAIzG,oBAAoB;IACpB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAwC9D;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS;IA4FjB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAuE1B"}
+{"version":3,"file":"tile-index.d.ts","sourceRoot":"","sources":["../src/tile-index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjK,qBAAa,SAAU,YAAW,kBAAkB;IAWpC,OAAO,CAAC,OAAO;IAT3B,OAAO,CAAC,UAAU,CAAkD;IACpE,OAAO,CAAC,KAAK,CAAa;IAE1B,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;KAAC,CAAC;IACrD,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAM;gBAGvB,OAAO,EAAE,gBAAgB;IAO7C,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,GAAG,IAAI;IAWtD,oBAAoB;IACpB,WAAW,CAAC,MAAM,EAAE,wBAAwB,EAAE,EAAE,QAAQ,EAAE,wBAAwB,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IA2BtH,oBAAoB;IAEpB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI1D,oBAAoB;IAEpB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAI/D,oBAAoB;IAEpB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;IAIzG,oBAAoB;IACpB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAwC9D;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS;IA4FjB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAuE1B"}

package/dist/tile-index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tile-index.test.d.ts.map

package/dist/tile-index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-index.test.d.ts","sourceRoot":"","sources":["../src/tile-index.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maplibre/geojson-vt",
-  "version": "6.0.5",
+  "version": "6.1.1",
   "description": "Slice GeoJSON data into vector tiles efficiently",
   "type": "module",
   "exports": {
@@ -25,30 +25,26 @@
   "unpkg": "dist/geojson-vt.js",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-terser": "^1.0.0",
-    "@rollup/plugin-typescript": "^12.3.0",
     "@types/benchmark": "^2.1.5",
     "@types/geojson": "^7946.0.16",
-    "@types/node": "^25.5.2",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@types/node": "^26.0.1",
+    "@vitest/coverage-v8": "^4.1.8",
     "benchmark": "^2.1.4",
-    "eslint": "^10.2.0",
-    "rollup": "^4.60.1",
-    "tslib": "^2.8.1",
-    "tsx": "^4.21.0",
-    "typedoc": "^0.28.18",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^4.0.17"
+    "eslint": "^10.6.0",
+    "rolldown": "^1.1.3",
+    "tsx": "^4.22.4",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.9"
   },
   "license": "ISC",
   "scripts": {
     "lint": "eslint",
     "test": "vitest",
     "coverage": "vitest run --coverage",
-    "build": "rollup -c && tsc -p tsconfig.declaration.json",
-    "watch": "rollup -cw",
+    "build": "rolldown -c && tsc -p tsconfig.declaration.json",
+    "watch": "rolldown -cw",
     "start": "npm run watch",
     "bench": "tsx bench/benchmark.ts && tsx --expose-gc bench/memory-bench.ts",
     "docs": "typedoc && mkdir -p docs/debug && cp -r debug/* docs/debug && find docs/debug -name '*.html' -exec sed -i 's|../dist/geojson-vt-dev.js|https://unpkg.com/@maplibre/geojson-vt@latest/dist/geojson-vt.js|g' {} +",
@@ -63,6 +59,6 @@
     "url": "https://github.com/maplibre/geojson-vt"
   },
   "dependencies": {
-    "kdbush": "^4.0.2"
+    "kdbush": "^4.1.0"
   }
 }

package/src/convert.test.ts

@@ -0,0 +1,40 @@
+import {test, expect, describe} from 'vitest';
+import {convertToInternal} from './convert';
+import {defaultOptions} from './geojsonvt';
+
+/**
+ * Wraps a geometry in `depth` nested GeometryCollections.
+ */
+function nestGeometryCollections(depth: number, inner: GeoJSON.Geometry): GeoJSON.Geometry {
+    let geometry = inner;
+    for (let i = 0; i < depth; i++) {
+        geometry = {type: 'GeometryCollection', geometries: [geometry]};
+    }
+    return geometry;
+}
+
+const point: GeoJSON.Point = {type: 'Point', coordinates: [0, 0]};
+
+function feature(geometry: GeoJSON.Geometry): GeoJSON.Feature {
+    return {type: 'Feature', geometry, properties: null};
+}
+describe('convertToInternal', () => {
+    test('converts a geometry nested in GeometryCollections', () => {
+        const features = convertToInternal(feature(nestGeometryCollections(3, point)), defaultOptions);
+
+        expect(features).toHaveLength(1);
+        expect(features[0].type).toBe('Point');
+    });
+
+    test('allows nesting up to the supported depth', () => {
+        const features = convertToInternal(feature(nestGeometryCollections(1024, point)), defaultOptions);
+
+        expect(features).toHaveLength(1);
+        expect(features[0].type).toBe('Point');
+    });
+
+    test('throws when GeometryCollection nesting exceeds the supported depth', () => {
+        expect(() => convertToInternal(feature(nestGeometryCollections(1025, point)), defaultOptions))
+            .toThrow('GeometryCollection nesting exceeds supported depth: 1024');
+    });
+})

package/src/convert.ts

@@ -3,6 +3,8 @@ import {simplify} from './simplify';
 import {createFeature, optimizeLineMemory} from './feature';
 import type {GeoJSONVTInternalFeature, GeoJSONVTOptions, SliceArray} from './definitions';
 
+const MAX_GEOMETRY_COLLECTION_DEPTH = 1024;
+
 /**
  * converts GeoJSON to internal source features (an intermediate projected JSON vector format with simplification data)
  * @param data
@@ -28,11 +30,15 @@ export function convertToInternal(data: GeoJSON.GeoJSON, options: GeoJSONVTOptio
     return features;
 }
 
-function featureToInternal(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number) {
+function featureToInternal(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number, depth = 0) {
     if (!geojson.geometry) return;
 
+    if (depth > MAX_GEOMETRY_COLLECTION_DEPTH) {
+        throw new Error('GeometryCollection nesting exceeds supported depth: ' + MAX_GEOMETRY_COLLECTION_DEPTH);
+    }
+
     if (geojson.geometry.type === 'GeometryCollection') {
-        convertGeometryCollection(features, geojson, geojson.geometry, options, index);
+        convertGeometryCollection(features, geojson, geojson.geometry, options, index, depth + 1);
         return;
     }
 
@@ -82,14 +88,14 @@ function getFeatureId(geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index
     return geojson.id;
 }
 
-function convertGeometryCollection(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, geometry: GeoJSON.GeometryCollection, options: GeoJSONVTOptions, index?: number) {
+function convertGeometryCollection(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, geometry: GeoJSON.GeometryCollection, options: GeoJSONVTOptions, index?: number, depth = 0) {
     for (const geom of geometry.geometries) {
         featureToInternal(features, {
             id: geojson.id,
             type: 'Feature',
             geometry: geom,
             properties: geojson.properties
-        }, options, index);
+        }, options, index, depth);
     }
 }
 

package/src/difference.ts

@@ -95,7 +95,7 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
         }
 
         if (removeFeatures.length) {
-            affected.push(...removeFeatures);
+            affected = affected.concat(removeFeatures);
             const removeIds = new Set(removeFeatures.map(f => f.id));
             source = source.filter(f => !removeIds.has(f.id));
         }
@@ -103,33 +103,31 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
         if (diff.add.size) {
             let addFeatures = convertToInternal({type: 'FeatureCollection', features: Array.from(diff.add.values())}, options);
             addFeatures = wrap(addFeatures, options);
-            affected.push(...addFeatures);
-            source.push(...addFeatures);
+            affected = affected.concat(addFeatures);
+            source = source.concat(addFeatures);
         }
     }
 
     if (diff.update.size) {
         // Features can be duplicated across the antimeridian (wrap) in a single tile, so must update all instances with the same id
-        for (const [id, update] of diff.update) {
-            const oldFeatures = [];
-            const keepFeatures = [];
-
-            for (const feature of source) {
-                if (feature.id === id) {
-                    oldFeatures.push(feature);
-                } else {
-                    keepFeatures.push(feature);
-                }
+        const oldFeaturesMap = new Map<string | number, GeoJSONVTInternalFeature[]>();
+        let keepFeatures: GeoJSONVTInternalFeature[] = [];
+        for (const feature of source) {
+            if (diff.update.has(feature.id)) {
+                oldFeaturesMap.set(feature.id, [...(oldFeaturesMap.get(feature.id) || []), feature]);
+            } else {
+                keepFeatures.push(feature);
             }
-            if (!oldFeatures.length) continue;
-
+        }
+        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 (!updatedFeatures.length) continue;
 
-            affected.push(...oldFeatures, ...updatedFeatures);
-            keepFeatures.push(...updatedFeatures);
-            source = keepFeatures;
+            affected = affected.concat(oldFeatures, updatedFeatures);
+            keepFeatures = keepFeatures.concat(updatedFeatures);
         }
+        source = keepFeatures;
     }
 
     return {affected, source};
@@ -174,7 +172,7 @@ function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJ
         return updated;
     }
 
-    return [];
+    return vtFeatures;
 }
 
 /**

package/src/geojsonvt.ts

@@ -26,32 +26,6 @@ export const defaultOptions: GeoJSONVTOptions = {
  * Main class for creating and managing a vector tile index from GeoJSON data.
  */
 export class GeoJSONVT {
-
-    /** 
-     * @internal
-     * This is for the tests
-     */
-    public get tiles() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return (this.tileIndex as any)?.tiles ?? {};
-    }
-    /** 
-     * @internal
-     * This is for the tests
-     */
-    public get stats() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return (this.tileIndex as any).stats;
-    }
-     /** 
-     * @internal
-     * This is for the tests
-     */
-    public get total() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return (this.tileIndex as any).total;
-    }
-
     private options: GeoJSONVTOptions;
     
     private source?: GeoJSONVTInternalFeature[];

package/src/tile-index.test.ts

@@ -0,0 +1,270 @@
+import {describe, expect, test} from "vitest";
+import {TileIndex} from "./tile-index";
+import {convertToInternal} from "./convert";
+import {applySourceDiff} from "./difference";
+import {wrap} from "./wrap";
+import {defaultOptions} from "./geojsonvt";
+
+function toID(z: number, x: number, y: number): number {
+    return (((1 << z) * y + x) * 32) + z;
+}
+
+describe('TileIndex', () => {
+    test('updateData: invalidates empty tiles', () => {
+        const initialData = {
+            type: 'FeatureCollection' as const,
+            features: [
+                {
+                    type: 'Feature' as const,
+                    id: 'nw-only',
+                    geometry: {
+                        type: 'Point' as const,
+                        coordinates: [-90, 45]  // top left quadrant only
+                    },
+                    properties: {}
+                }
+            ]
+        };
+        const options = {
+            ...defaultOptions,
+            updateable: true,
+            indexMaxZoom: 1,
+            indexMaxPoints: 0,
+            debug: 2
+        };
+        const index = new TileIndex(options);
+        let sourceFeatures = convertToInternal(initialData, options);
+        sourceFeatures = wrap(sourceFeatures, options);
+        index.initialize(sourceFeatures);
+        expect(index.stats.z1).toBe(4);
+
+        const globalFeature = {
+            type: 'Feature' as const,
+            id: 'global',
+            geometry: {
+                type: 'LineString' as const,
+                coordinates: [[-180, -85], [180, 85]]  // spans whole world
+            },
+            properties: {}
+        };
+        const {source, affected} = applySourceDiff(sourceFeatures, {add: [globalFeature]}, options);
+        index.updateIndex(source, affected, options);
+        expect(index.stats.z1).toBe(0);
+    });
+
+    test('updateData: invalidates tiles when feature is within the buffer edge', () => {
+        const initialData = {
+            type: 'FeatureCollection' as const,
+            features: [{
+                type: 'Feature' as const,
+                id: 'feature1',
+                geometry: {
+                    type: 'Point' as const,
+                    coordinates: [-45, 45] // inside tile 1-0-0
+                },
+                properties: {}
+            }]
+        };
+    
+        const options = {
+            ...defaultOptions,
+            updateable: true,
+            indexMaxZoom: 1,
+            indexMaxPoints: 0
+        };
+        const index = new TileIndex(options);
+        let sourceFeatures = convertToInternal(initialData, options);
+        sourceFeatures = wrap(sourceFeatures, options);
+        index.initialize(sourceFeatures);
+    
+        const tileId = toID(1, 0, 0);
+        index.getTile(1, 0, 0);
+        expect(index.tiles[tileId]).toBeTruthy();
+    
+        const featureWithinBuffer = {
+            type: 'Feature' as const,
+            id: 'buffer-feature',
+            geometry: {
+                type: 'Point' as const,
+                coordinates: [2, 0] // feature within tile buffer edge
+            },
+            properties: {}
+        };
+        const {source, affected} = applySourceDiff(sourceFeatures, {add: [featureWithinBuffer]}, options);
+        index.updateIndex(source, affected, options);
+        expect(index.tiles[tileId]).toBeUndefined();
+    });
+
+    test('updateData: invalidates tiles at deeper zoom', () => {
+        const initialData = {
+            type: 'FeatureCollection' as const,
+            features: [{
+                type: 'Feature' as const,
+                id: 'feature1',
+                geometry: {
+                    type: 'Polygon' as const,
+                    coordinates: [[
+                        [0, 0], [5, 0], [5, 5], [0, 5], [0, 0]
+                    ]]
+                },
+                properties: {name: 'Original'}
+            }]
+        };
+    
+        const options = {
+            ...defaultOptions,
+            updateable: true,
+            indexMaxZoom: 5,
+            indexMaxPoints: 0
+        };
+        const index = new TileIndex(options);
+        let sourceFeatures = convertToInternal(initialData, options);
+        sourceFeatures = wrap(sourceFeatures, options);
+        index.initialize(sourceFeatures);
+    
+        const tileId = toID(5, 16, 16);
+    
+        const tileBefore = index.tiles[tileId];
+        expect(tileBefore).toBeTruthy();
+        expect(tileBefore.numFeatures).toBe(1);
+    
+        const updatedFeature = {
+            type: 'Feature' as const,
+            id: 'feature1',
+            geometry: {
+                type: 'Polygon' as const,
+                coordinates: [[
+                    [0, 0], [10, 0], [10, 10], [0, 10], [0, 0]
+                ]]
+            },
+            properties: {name: 'Updated'}
+        };
+    
+        const {source, affected} = applySourceDiff(sourceFeatures, {add: [updatedFeature]}, options);
+        index.updateIndex(source, affected, options);
+    
+        const tileAfter = index.tiles[tileId];
+        expect(tileAfter).toBeUndefined();
+    
+        const tileRegenerated = index.getTile(5, 16, 16);
+        expect(tileRegenerated).toBeTruthy();
+        expect(tileRegenerated.features[0].tags.name).toBe('Updated');
+    });
+
+    test('updateData: does not invalidate unaffected tiles', () => {
+        const initialData = {
+            type: 'FeatureCollection' as const,
+            features: [
+                {
+                    type: 'Feature' as const,
+                    id: 'northwest',
+                    geometry: {
+                        type: 'Point' as const,
+                        coordinates: [-90, 45]  // NW quadrant only
+                    },
+                    properties: {}
+                },
+                {
+                    type: 'Feature' as const,
+                    id: 'southeast',
+                    geometry: {
+                        type: 'Point' as const,
+                        coordinates: [90, -45]  // SE quadrant only
+                    },
+                    properties: {}
+                }
+            ]
+        };
+    
+        const options = {
+            ...defaultOptions,
+            updateable: true,
+            indexMaxZoom: 2,
+            indexMaxPoints: 0
+        };
+        const index = new TileIndex(options);
+        let sourceFeatures = convertToInternal(initialData, options);
+        sourceFeatures = wrap(sourceFeatures, options);
+        index.initialize(sourceFeatures);
+    
+        const nwTileId = toID(1, 0, 0);
+        const seTileId = toID(1, 1, 1);
+    
+        const nwTileBefore = index.tiles[nwTileId];
+        const seTileBefore = index.tiles[seTileId];
+    
+        expect(nwTileBefore).toBeTruthy();
+        expect(seTileBefore).toBeTruthy();
+    
+        const updatedFeature = {
+            type: 'Feature' as const,
+            id: 'northwest',
+            geometry: {
+                type: 'Point' as const,
+                coordinates: [-85, 40]  // NW different coordinate
+            },
+            properties: {}
+        };
+    
+
+        const {source, affected} = applySourceDiff(sourceFeatures, {add: [updatedFeature]}, options);
+        index.updateIndex(source, affected, options);
+    
+        const nwTileAfter = index.tiles[nwTileId];
+        expect(nwTileAfter).toBeUndefined();
+    
+        const seTileAfter = index.tiles[seTileId];
+        expect(seTileAfter).toBe(seTileBefore);
+    });
+});
+
+describe('Multiworld test', () => {
+    const leftPoint = {
+        type: 'Feature' as const,
+        properties: {},
+        geometry: {
+            coordinates: [-540, 0],
+            type: 'Point' as const
+        }
+    };
+
+    const rightPoint = {
+        type: 'Feature' as const,
+        properties: {},
+        geometry: {
+            coordinates: [540, 0],
+            type: 'Point' as const
+        }
+    };
+
+    test('handle point only in the rightside world', () => {
+        const vt = new TileIndex(defaultOptions);
+        let sourceFeatures = convertToInternal(rightPoint, defaultOptions);
+        sourceFeatures = wrap(sourceFeatures, defaultOptions);
+        vt.initialize(sourceFeatures);
+        expect(vt.tiles[0].features[0].geometry[0]).toBe(1);
+        expect(vt.tiles[0].features[0].geometry[1]).toBe(.5);
+    });
+
+    test('handle point only in the leftside world', () => {
+        const vt = new TileIndex(defaultOptions);
+        let sourceFeatures = convertToInternal(leftPoint, defaultOptions);
+        sourceFeatures = wrap(sourceFeatures, defaultOptions);
+        vt.initialize(sourceFeatures);
+        expect(vt.tiles[0].features[0].geometry[0]).toBe(0);
+        expect(vt.tiles[0].features[0].geometry[1]).toBe(.5);
+    });
+
+    test('handle points in the leftside world and the rightside world', () => {
+        const vt = new TileIndex(defaultOptions);
+        let sourceFeatures = convertToInternal({type: 'FeatureCollection', features: [leftPoint, rightPoint]}, defaultOptions);
+        sourceFeatures = wrap(sourceFeatures, defaultOptions);
+        vt.initialize(sourceFeatures);
+
+        expect(vt.tiles[0].features[0].geometry[0]).toBe(0);
+        expect(vt.tiles[0].features[0].geometry[1]).toBe(.5);
+
+        expect(vt.tiles[0].features[1].geometry[0]).toBe(1);
+        expect(vt.tiles[0].features[1].geometry[1]).toBe(.5);
+    });
+})

package/src/tile-index.ts

@@ -6,13 +6,13 @@ import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, ClusterOrPointFeature,
 export class TileIndex implements GeoJSONVTTileIndex {
 
     private tileCoords: {z: number, x: number, y: number, id: number}[];
+    private total: number = 0;
 
     /** @internal */
     public tiles: {[key: string]: GeoJSONVTInternalTile};
     /** @internal */
     public stats: {[key: string]: number} = {};
-    /** @internal */
-    public total: number = 0;
+    
 
     constructor(private options: GeoJSONVTOptions) {
         this.tiles = {};
@@ -54,7 +54,7 @@ export class TileIndex implements GeoJSONVTTileIndex {
         this.tileCoords.push({z, x, y, id});
 
         if (options.debug) {
-            const key = `z${  z}`;
+            const key = `z${z}`;
             this.stats[key] = (this.stats[key] || 0) + 1;
             this.total++;
         }
@@ -164,7 +164,7 @@ export class TileIndex implements GeoJSONVTTileIndex {
                             z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);
                         console.timeEnd('creation');
                     }
-                    const key = `z${  z}`;
+                    const key = `z${z}`;
                     this.stats[key] = (this.stats[key] || 0) + 1;
                     this.total++;
                 }
@@ -289,7 +289,7 @@ export class TileIndex implements GeoJSONVTTileIndex {
                     console.log('invalidate tile z%d-%d-%d (features: %d, points: %d, simplified: %d)',
                         tile.z, tile.x, tile.y, tile.numFeatures, tile.numPoints, tile.numSimplified);
                 }
-                const key = `z${  tile.z}`;
+                const key = `z${tile.z}`;
                 this.stats[key] = (this.stats[key] || 0) - 1;
                 this.total--;
             }