@maplibre/geojson-vt 6.2.0 → 6.3.0

package/dist/geojsonvt.d.ts

@@ -1,12 +1,14 @@
 import { type GeoJSONVTSourceDiff } from './difference';
-import type { ClusterOrPointFeature, GeoJSONVTOptions, GeoJSONVTTile, SuperclusterOptions } from './definitions';
+import type { ClusterOrPointFeature, GeoJSONVTOptions, GeoJSONVTTile } from './definitions';
 export declare const defaultOptions: GeoJSONVTOptions;
 /**
  * Main class for creating and managing a vector tile index from GeoJSON data.
  */
 export declare class GeoJSONVT {
     private options;
+    private worldCoordinateHelper;
     private source?;
+    private unlocated?;
     private tileIndex;
     constructor(data: GeoJSON.GeoJSON, options?: GeoJSONVTOptions);
     private initializeIndex;
@@ -24,7 +26,9 @@ export declare class GeoJSONVT {
      */
     updateData(diff: GeoJSONVTSourceDiff, filter?: (feature: GeoJSON.Feature) => boolean): void;
     /**
-     * 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;
     /**
@@ -34,9 +38,9 @@ export declare class GeoJSONVT {
     /**
      * 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): void;
+    updateClusterOptions(cluster: boolean, clusterOptions: GeoJSONVTOptions['clusterOptions']): void;
     /**
      * Returns the zoom level at which a cluster expands into multiple children.
      * @param clusterId - The target cluster id.

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,gBAe5B,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"}
+{"version":3,"file":"geojsonvt.d.ts","sourceRoot":"","sources":["../src/geojsonvt.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,KAAK,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAC,qBAAqB,EAAgD,gBAAgB,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AAExI,eAAO,MAAM,cAAc,EAAE,gBAgB5B,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAClB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,qBAAqB,CAAwB;IAErD,OAAO,CAAC,MAAM,CAAC,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAC,CAAwC;IAC1D,OAAO,CAAC,SAAS,CAAqB;gBAE1B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAkC7D,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;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAkBpB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,OAAO;IAK1B;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,CAAC,gBAAgB,CAAC;IAazF;;;;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/index.d.ts

@@ -1,10 +1,10 @@
 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';
 import { geoJSONToTile } from './geojson-to-tile';
 import { GEOJSONVT_CLIP_START, GEOJSONVT_CLIP_END } from './tile';
 export { GeoJSONVT, ClusterTileIndex as Supercluster, geoJSONToTile, GEOJSONVT_CLIP_START, GEOJSONVT_CLIP_END };
-export type { GeoJSONVTInternalFeature, GeoJSONVTOptions, GeoJSONToTileOptions, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, PartialGeoJSONVTFeature, SliceArray, SliceFixedArray, GeoJSONVTTile, GeoJSONVTFeature, GeoJSONVTSourceDiff, GeoJSONVTFeatureDiff, GeoJSONVTFeaturePoint, GeoJSONVTFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalPointFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalMultiPolygonFeature, SuperclusterOptions, ClusterProperties, ClusterFeature, ClusterOrPointFeature, KDBushWithData, GeoJSONVTTileIndex };
+export type { GeoJSONVTInternalFeature, GeoJSONVTOptions, GeoJSONToTileOptions, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, PartialGeoJSONVTFeature, SliceArray, SliceFixedArray, GeoJSONVTTile, GeoJSONVTFeature, GeoJSONVTSourceDiff, GeoJSONVTFeatureDiff, GeoJSONVTFeaturePoint, GeoJSONVTFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalPointFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalMultiPolygonFeature, SuperclusterOptions, GeoJSONVTCoordinatesType, ClusterProperties, ClusterFeature, ClusterOrPointFeature, KDBushWithData, GeoJSONVTTileIndex };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAC5E,OAAO,KAAK,EAAC,wBAAwB,EAAE,kCAAkC,EAAE,uCAAuC,EAAE,kCAAkC,EAAE,oCAAoC,EAAE,6BAA6B,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,cAAc,EAAE,qBAAqB,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,iCAAiC,EAAE,oCAAoC,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AACpqB,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,QAAQ,CAAC;AAEhE,OAAO,EACH,SAAS,EACT,gBAAgB,IAAI,YAAY,EAChC,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EACrB,CAAA;AAED,YAAY,EACR,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,uBAAuB,EACvB,UAAU,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,iCAAiC,EACjC,oCAAoC,EACpC,6BAA6B,EAC7B,kCAAkC,EAClC,kCAAkC,EAClC,uCAAuC,EACvC,+BAA+B,EAC/B,oCAAoC,EACpC,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EACrB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAC5E,OAAO,KAAK,EAAC,wBAAwB,EAAE,kCAAkC,EAAE,uCAAuC,EAAE,kCAAkC,EAAE,oCAAoC,EAAE,6BAA6B,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,cAAc,EAAE,qBAAqB,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,iCAAiC,EAAE,oCAAoC,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,wBAAwB,EAAC,MAAM,eAAe,CAAC;AAC9rB,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,QAAQ,CAAC;AAEhE,OAAO,EACH,SAAS,EACT,gBAAgB,IAAI,YAAY,EAChC,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EACrB,CAAA;AAED,YAAY,EACR,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,uBAAuB,EACvB,UAAU,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,iCAAiC,EACjC,oCAAoC,EACpC,6BAA6B,EAC7B,kCAAkC,EAClC,kCAAkC,EAClC,uCAAuC,EACvC,+BAA+B,EAC/B,oCAAoC,EACpC,mBAAmB,EACnB,wBAAwB,EACxB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EACrB,CAAC"}

package/dist/tile-index.d.ts

@@ -24,9 +24,10 @@ export declare class TileIndex implements GeoJSONVTTileIndex {
     /** {@inheritdoc} */
     getTile(z: number, x: number, y: number): GeoJSONVTTile | null;
     /**
-     * The features the top tile starts from: all of them in a wrapping world, where wrapping already put them inside,
-     * and only what lies inside the world square and its buffer with `worldCoordinates`. The index keeps the rest, so
-     * an update can still move a feature in from outside.
+     * 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;
     /**

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;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;IA4BtH,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;IAyC9D;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAOnB;;;;;;;;;;;;;;;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;IA4BtH,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;IAyC9D;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAQnB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS;IA4FjB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAuE1B"}

package/dist/world-coordinate-helper.d.ts

@@ -0,0 +1,13 @@
+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;
+}
+export declare const mercatorWorldCoordinateHelper: WorldCoordinateHelper;
+export declare function getWorldCoordinateHelper(coordinates?: GeoJSONVTCoordinatesType): WorldCoordinateHelper;
+//# sourceMappingURL=world-coordinate-helper.d.ts.map

package/dist/world-coordinate-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-coordinate-helper.d.ts","sourceRoot":"","sources":["../src/world-coordinate-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,eAAe,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AA+CD,eAAO,MAAM,6BAA6B,EAAE,qBAA2D,CAAC;AAGxG,wBAAgB,wBAAwB,CAAC,WAAW,CAAC,EAAE,wBAAwB,GAAG,qBAAqB,CAEtG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maplibre/geojson-vt",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Slice GeoJSON data into vector tiles efficiently",
   "type": "module",
   "exports": {

package/src/cluster-tile-index.test.ts

@@ -218,8 +218,8 @@ test('does not keep the cluster properties of an earlier load', () => {
     expect(index.clusterProps.length).toBe(count);
 });
 
-test('takes points and the getClusters bounding box in world coordinates with worldCoordinates', () => {
-    const index = new ClusterTileIndex({}, true);
+test('takes points and the getClusters bounding box in the unit square with unitSquare coordinates', () => {
+    const index = new ClusterTileIndex({coordinates: 'unitSquare', wrap: false});
     index.load([
         {type: 'Feature', properties: {name: 'a'}, geometry: {type: 'Point', coordinates: [0.25, 0.25]}},
         {type: 'Feature', properties: {name: 'b'}, geometry: {type: 'Point', coordinates: [0.75, 0.75]}}
@@ -228,8 +228,8 @@ test('takes points and the getClusters bounding box in world coordinates with wo
     expect(index.getClusters([0, 0, 0.5, 0.5], 0).map(f => f.geometry.coordinates)).toEqual([[0.25, 0.25]]);
 });
 
-test('leaves points outside the world out of load with worldCoordinates', () => {
-    const index = new ClusterTileIndex({}, true);
+test('leaves points outside the world out of load in a unit square without wrap', () => {
+    const index = new ClusterTileIndex({coordinates: 'unitSquare', wrap: false});
     index.load([
         {type: 'Feature', properties: {name: 'inside'}, geometry: {type: 'Point', coordinates: [0.99, 0.5]}},
         {type: 'Feature', properties: {name: 'outside'}, geometry: {type: 'Point', coordinates: [1.03, 0.5]}}
@@ -238,8 +238,8 @@ test('leaves points outside the world out of load with worldCoordinates', () =>
     expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
 });
 
-test('returns no tile outside the world with worldCoordinates', () => {
-    const index = new ClusterTileIndex({}, true);
+test('returns no tile outside the world in a unit square without wrap', () => {
+    const index = new ClusterTileIndex({coordinates: 'unitSquare', wrap: false});
     index.load([
         {type: 'Feature', properties: {name: 'west'}, geometry: {type: 'Point', coordinates: [0.01, 0.5]}},
         {type: 'Feature', properties: {name: 'east'}, geometry: {type: 'Point', coordinates: [0.99, 0.5]}},
@@ -293,8 +293,8 @@ test('does not cluster points that are farther apart than the radius on a high z
     expect(index.getClusters([-180, -90, 180, 90], 20)).toHaveLength(2);
 });
 
-test('returns a cluster within a step of the mean of its points with worldCoordinates', () => {
-    const index = new ClusterTileIndex({}, true);
+test('returns a cluster within a step of the mean of its points in a unit square without wrap', () => {
+    const index = new ClusterTileIndex({coordinates: 'unitSquare', wrap: false});
     index.load([
         {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [0.54, 0.42]}},
         {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [0.54, 0.42]}},
@@ -306,3 +306,23 @@ test('returns a cluster within a step of the mean of its points with worldCoordi
     expect(x).toBeCloseTo(0.5466666667, 9);
     expect(y).toBeCloseTo(0.4133333333, 9);
 });
+
+test('getClusters keeps only the part of a box inside a world that does not wrap', () => {
+    const index = new ClusterTileIndex({wrap: false});
+    index.load([
+        {type: 'Feature', properties: {name: 'west'}, geometry: {type: 'Point', coordinates: [-175, 0]}},
+        {type: 'Feature', properties: {name: 'east'}, geometry: {type: 'Point', coordinates: [175, 0]}}
+    ]);
+
+    expect(index.getClusters([170, -20, 190, 20], 17).map(f => f.properties.name)).toEqual(['east']);
+});
+
+test('getClusters repeats a box across the edge of a unit square that wraps', () => {
+    const index = new ClusterTileIndex({coordinates: 'unitSquare', wrap: true});
+    index.load([
+        {type: 'Feature', properties: {name: 'west'}, geometry: {type: 'Point', coordinates: [0.01, 0.5]}},
+        {type: 'Feature', properties: {name: 'east'}, geometry: {type: 'Point', coordinates: [0.99, 0.5]}}
+    ]);
+
+    expect(index.getClusters([0.95, 0, 1.05, 1], 17).map(f => f.properties.name).sort()).toEqual(['east', 'west']);
+});

package/src/cluster-tile-index.ts

@@ -1,6 +1,6 @@
 import KDBush from 'kdbush';
-import {projectX, projectY} from './convert';
-import {unprojectX, unprojectY, featureToGeoJSON} from './deconvert';
+import {getWorldCoordinateHelper, type WorldCoordinateHelper} from './world-coordinate-helper';
+import {featureToGeoJSON} from './deconvert';
 import type {ClusterFeature, ClusterOrPointFeature, ClusterProperties, GeoJSONVTTileIndex, GeoJSONVTFeature, GeoJSONVTInternalFeature, GeoJSONVTInternalPointFeature, GeoJSONVTOptions, GeoJSONVTTile, SuperclusterOptions} from './definitions';
 
 type ClusterFeatureInternal = GeoJSONVTInternalPointFeature & {
@@ -31,7 +31,9 @@ export const defaultClusterOptions: Required<SuperclusterOptions> = {
     log: false,
     generateId: false,
     reduce: null,
-    map: (props) => props as Record<string, unknown>
+    map: (props) => props as Record<string, unknown>,
+    coordinates: 'lngLat',
+    wrap: true
 };
 
 /**
@@ -87,17 +89,11 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
     stride: number;
     clusterProps: Record<string, unknown>[];
     points: GeoJSONVTInternalPointFeature[];
-    /**
-     * Whether points are in world coordinates, see `worldCoordinates` in {@link GeoJSONVTOptions}. Points outside the
-     * world are then left out of the clusters, tiles at an edge get no points from the opposite one, `getTile` returns
-     * `null` outside the world, and clusters come back in world coordinates.
-     * @experimental
-     */
-    worldCoordinates: boolean;
+    private worldCoordinateHelper: WorldCoordinateHelper;
 
-    constructor(options?: SuperclusterOptions, worldCoordinates = false) {
+    constructor(options?: SuperclusterOptions) {
         this.options = createOptions(options);
-        this.worldCoordinates = worldCoordinates;
+        this.worldCoordinateHelper = getWorldCoordinateHelper(this.options.coordinates);
         this.trees = new Array(this.options.maxZoom + 1);
         this.stride = this.options.reduce ? 5 : 4;
         this.clusterProps = [];
@@ -120,8 +116,8 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
 
             const positions = point.geometry.type === 'MultiPoint' ? point.geometry.coordinates : [point.geometry.coordinates];
             for (const [lng, lat] of positions) {
-                const [x, y] = [projectX(lng, this.worldCoordinates), projectY(lat, this.worldCoordinates)];
-                if (this.worldCoordinates && !isInWorld([x, y])) continue;
+                const [x, y] = [this.worldCoordinateHelper.projectX(lng), this.worldCoordinateHelper.projectY(lat)];
+                if (!this.options.wrap && !isInWorld([x, y])) continue;
 
                 const feature: GeoJSONVTInternalPointFeature = {
                     id: point.id,
@@ -148,7 +144,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
 
         for (const feature of features) {
             if (feature.type === 'Point') {
-                if (this.worldCoordinates && !isInWorld(feature.geometry)) continue;
+                if (!this.options.wrap && !isInWorld(feature.geometry)) continue;
                 points.push(feature);
                 continue;
             }
@@ -156,7 +152,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
 
             for (let i = 0; i < feature.geometry.length; i += 3) {
                 const geometry = [feature.geometry[i], feature.geometry[i + 1]];
-                if (this.worldCoordinates && !isInWorld(geometry)) continue;
+                if (!this.options.wrap && !isInWorld(geometry)) continue;
                 points.push({id: feature.id, type: 'Point', geometry, tags: feature.tags});
             }
         }
@@ -170,7 +166,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
      * @param features 
      */
     updateIndex(features: GeoJSONVTInternalFeature[], _affected: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions) {
-        this.options = createOptions(options.clusterOptions);
+        this.options = createOptions({...options.clusterOptions, coordinates: this.options.coordinates, wrap: this.options.wrap});
         this.initialize(features);
     }
 
@@ -242,12 +238,42 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
 
     /**
      * Returns clusters and/or points within a bounding box at a given zoom level.
-     * @param bbox - Bounding box in `[westLng, southLat, eastLng, northLat]` order, or `[minX, minY, maxX, maxY]` in world coordinates.
+     * @param bbox - Bounding box in `[westLng, southLat, eastLng, northLat]` order, or `[minX, minY, maxX, maxY]` in the unit square with `coordinates: 'unitSquare'`.
+     * In a world that wraps, the box can reach across the antimeridian. In one that doesn't, only its part inside the world counts.
      * @param zoom - Zoom level to query.
      */
     public getClusters(bbox: [number, number, number, number], zoom: number): ClusterOrPointFeature[] {
-        const clusterInternal = this.worldCoordinates ? this.getClustersInRange(bbox, zoom) : this.getClustersInternal(bbox, zoom);
-        return clusterInternal.map((f) => featureToGeoJSON(f, this.worldCoordinates) as ClusterOrPointFeature);
+        const clusterInternal =
+            !this.options.wrap ? this.getClustersInWorld(bbox, zoom) :
+                this.options.coordinates === 'unitSquare' ? this.getClustersAcrossEdge(bbox, zoom) :
+                    this.getClustersInternal(bbox, zoom);
+        return clusterInternal.map((f) => featureToGeoJSON(f, this.worldCoordinateHelper) as ClusterOrPointFeature);
+    }
+
+    /**
+     * The clusters and points in the part of a box inside a world that ends at its edges.
+     */
+    private getClustersInWorld(bbox: [number, number, number, number], zoom: number): ClusterOrPointFeatureInternal[] {
+        const lngLat = this.options.coordinates !== 'unitSquare';
+        const y1 = this.worldCoordinateHelper.projectY(lngLat ? Math.max(-90, Math.min(90, bbox[1])) : bbox[1]);
+        const y2 = this.worldCoordinateHelper.projectY(lngLat ? Math.max(-90, Math.min(90, bbox[3])) : bbox[3]);
+        const minX = Math.max(0, this.worldCoordinateHelper.projectX(bbox[0]));
+        const maxX = Math.min(1, this.worldCoordinateHelper.projectX(bbox[2]));
+        if (minX > maxX) return [];
+        return this.getClustersInRange([minX, Math.min(y1, y2), maxX, Math.max(y1, y2)], zoom);
+    }
+
+    /**
+     * The clusters and points in a box of a unit square that wraps, where the box can reach across its left or right edge.
+     */
+    private getClustersAcrossEdge([minX, minY, maxX, maxY]: [number, number, number, number], zoom: number): ClusterOrPointFeatureInternal[] {
+        if (maxX < minX) maxX += 1;
+        if (maxX - minX >= 1) return this.getClustersInRange([0, minY, 1, maxY], zoom);
+        const shift = Math.floor(minX);
+        const west = minX - shift;
+        const east = maxX - shift;
+        if (east <= 1) return this.getClustersInRange([west, minY, east, maxY], zoom);
+        return this.getClustersInRange([west, minY, 1, maxY], zoom).concat(this.getClustersInRange([0, minY, east - 1, maxY], zoom));
     }
 
     private getClustersInternal(bbox: [number, number, number, number], zoom: number): ClusterOrPointFeatureInternal[] {
@@ -265,7 +291,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
             return easternHem.concat(westernHem);
         }
 
-        return this.getClustersInRange([projectX(minLng), projectY(maxLat), projectX(maxLng), projectY(minLat)], zoom);
+        return this.getClustersInRange([this.worldCoordinateHelper.projectX(minLng), this.worldCoordinateHelper.projectY(maxLat), this.worldCoordinateHelper.projectX(maxLng), this.worldCoordinateHelper.projectY(minLat)], zoom);
     }
 
     /**
@@ -308,7 +334,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
         for (const id of ids) {
             const k = id * this.stride;
             if (data[k + OFFSET_PARENT] === clusterId) {
-                children.push(data[k + OFFSET_NUM] > 1 ? getClusterGeoJSON(coords, id, data, k, this.clusterProps, this.worldCoordinates) : featureToGeoJSON(this.points[data[k + OFFSET_ID]], this.worldCoordinates) as GeoJSON.Feature<GeoJSON.Point>);
+                children.push(data[k + OFFSET_NUM] > 1 ? getClusterGeoJSON(coords, id, data, k, this.clusterProps, this.worldCoordinateHelper) : featureToGeoJSON(this.points[data[k + OFFSET_ID]], this.worldCoordinateHelper) as GeoJSON.Feature<GeoJSON.Point>);
             }
         }
 
@@ -345,7 +371,7 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
             return null;
         }
         const z2 = Math.pow(2, z);
-        if (this.worldCoordinates && (x < 0 || x >= z2 || y < 0 || y >= z2)) return null;
+        if (!this.options.wrap && (x < 0 || x >= z2 || y < 0 || y >= z2)) return null;
         const {extent, radius} = this.options;
         const p = radius / extent;
         const top = encode((y - p) / z2);
@@ -364,12 +390,12 @@ export class ClusterTileIndex implements GeoJSONVTTileIndex {
             tree.range(encode((x - p) / z2), top, encode((x + 1 + p) / z2), bottom),
             tree, x, y, z2, tile);
 
-        if (!this.worldCoordinates && x === 0) {
+        if (this.options.wrap && x === 0) {
             this.addTileFeatures(
                 tree.range(encode(1 - p / z2), top, encode(1), bottom),
                 tree, z2, y, z2, tile);
         }
-        if (!this.worldCoordinates && x === z2 - 1) {
+        if (this.options.wrap && x === z2 - 1) {
             this.addTileFeatures(
                 tree.range(encode(0), top, encode(p / z2), bottom),
                 tree, -1, y, z2, tile);
@@ -628,14 +654,14 @@ function getClusterFeature(coords: Int32Array, index: number, data: Int32Array,
     };
 }
 
-function getClusterGeoJSON(coords: Int32Array, index: number, data: Int32Array, i: number, clusterProps: Record<string, unknown>[], worldCoordinates: boolean): ClusterFeature {
+function getClusterGeoJSON(coords: Int32Array, index: number, data: Int32Array, i: number, clusterProps: Record<string, unknown>[], worldCoordinateHelper: WorldCoordinateHelper): ClusterFeature {
     return {
         type: 'Feature',
         id: data[i + OFFSET_ID],
         properties: getClusterProperties(data, i, clusterProps),
         geometry: {
             type: 'Point',
-            coordinates: [unprojectX(decode(coords[index * 2]), worldCoordinates), unprojectY(decode(coords[index * 2 + 1]), worldCoordinates)]
+            coordinates: [worldCoordinateHelper.unprojectX(decode(coords[index * 2])), worldCoordinateHelper.unprojectY(decode(coords[index * 2 + 1]))]
         }
     };
 }

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,31 +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 worldCoordinates = options.worldCoordinates === true;
+    const worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 
     switch (geojson.geometry.type) {
         case 'Point':
-            convertPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
+            convertPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiPoint':
-            convertMultiPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
+            convertMultiPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'LineString':
-            convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+            convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiLineString':
-            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, options, geojson.properties);
+            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, options, geojson.properties);
             return;
 
         case 'Polygon':
-            convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+            convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         case 'MultiPolygon':
-            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
             return;
 
         default:
@@ -100,52 +116,52 @@ function convertGeometryCollection(features: GeoJSONVTInternalFeature[], geojson
     }
 }
 
-function convertPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Point, worldCoordinates: boolean, 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], worldCoordinates), projectY(geom.coordinates[1], worldCoordinates), 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, worldCoordinates: boolean, 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], worldCoordinates), projectY(coords[1], worldCoordinates), 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, worldCoordinates: boolean, 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, worldCoordinates);
+    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, worldCoordinates: boolean, 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, worldCoordinates);
+            convertLine(line, out, tolerance, false, worldCoordinateHelper);
             features.push(createFeature(id, 'LineString', out, properties));
         }
     } else {
         const out: SliceArray[] = [];
-        convertLines(geom.coordinates, out, tolerance, false, worldCoordinates);
+        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, worldCoordinates: boolean, 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, worldCoordinates);
+    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, worldCoordinates: boolean, 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, worldCoordinates);
+        convertLines(polygon, polygonOut, tolerance, true, worldCoordinateHelper);
         if (!polygonOut.length) continue;
 
         out.push(polygonOut);
@@ -155,13 +171,13 @@ function convertMultiPolygonFeature(features: GeoJSONVTInternalFeature[], id: nu
     features.push(createFeature(id, 'MultiPolygon', out, properties));
 }
 
-function convertLine(ring: GeoJSON.Position[], out: SliceArray, tolerance: number, isPolygon: boolean, worldCoordinates: 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], worldCoordinates);
-        const y = projectY(ring[j][1], worldCoordinates);
+        const x = worldCoordinateHelper.projectX(ring[j][0]);
+        const y = worldCoordinateHelper.projectY(ring[j][1]);
 
         out.points.push(x, y, 0);
 
@@ -187,28 +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, worldCoordinates: 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, worldCoordinates);
+        convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinateHelper);
         out.push(geom);
     }
 }
-
-/**
- * Convert longitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
- */
-export function projectX(x: number, worldCoordinates = false) {
-    if (worldCoordinates) return x;
-    return x / 360 + 0.5;
-}
-
-/**
- * Convert latitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
- */
-export function projectY(y: number, worldCoordinates = false) {
-    if (worldCoordinates) return y;
-    const sin = Math.sin(y * Math.PI / 180);
-    const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
-    return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
-}

package/src/deconvert.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);
     }
 });