@maplibre/geojson-vt 5.0.4 → 6.0.0

package/src/tile-index.ts

@@ -0,0 +1,310 @@
+import { AxisType, clip } from "./clip";
+import { createTile } from "./tile";
+import { transformTile } from "./transform";
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, ClusterOrPointFeature, GeoJSONVTTileIndex, GeoJSONVTInternalTile, GeoJSONVTTile } from "./definitions";
+
+export class TileIndex implements GeoJSONVTTileIndex {
+
+    private tileCoords: {z: number, x: number, y: number, id: number}[];
+
+    /** @internal */
+    public tiles: {[key: string]: GeoJSONVTInternalTile};
+    /** @internal */
+    public stats: {[key: string]: number} = {};
+    /** @internal */
+    public total: number = 0;
+
+    constructor(private options: GeoJSONVTOptions) {
+        this.tiles = {};
+        this.tileCoords = [];
+        this.stats = {};
+        this.total = 0;
+    }
+
+    initialize(features: GeoJSONVTInternalFeature[]): void {
+        // start slicing from the top tile down
+        this.splitTile(features, 0, 0, 0);
+
+        if (this.options.debug) {
+            if (features.length) console.log('features: %d, points: %d', this.tiles[0].numFeatures, this.tiles[0].numPoints);
+            console.timeEnd('generate tiles');
+            console.log('tiles generated:', this.total, JSON.stringify(this.stats));
+        }
+    }
+
+    /** {@inheritdoc} */
+    updateIndex(source: GeoJSONVTInternalFeature[], affected: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): void {
+        if (options.debug > 1) {
+            console.log('invalidating tiles');
+            console.time('invalidating');
+        }
+
+        this.invalidateTiles(affected);
+
+        if (options.debug > 1) console.timeEnd('invalidating');
+
+        // re-generate root tile with updated feature set
+        const [z, x, y] = [0, 0, 0];
+        const rootTile = createTile(source, z, x, y, options);
+        rootTile.source = source;
+
+        // update tile index with new root tile - ready for getTile calls
+        const id = toID(z, x, y);
+        this.tiles[id] = rootTile;
+        this.tileCoords.push({z, x, y, id});
+
+        if (options.debug) {
+            const key = `z${  z}`;
+            this.stats[key] = (this.stats[key] || 0) + 1;
+            this.total++;
+        }
+    }
+
+    /** {@inheritdoc} */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getClusterExpansionZoom(_clusterId: number): number | null {
+        return null;
+    }
+
+    /** {@inheritdoc} */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getChildren(_clusterId: number): ClusterOrPointFeature[] | null {
+        return null;
+    }
+
+    /** {@inheritdoc} */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getLeaves(_clusterId: number, _limit?: number, _offset?: number): GeoJSON.Feature<GeoJSON.Point>[] | null {
+        return null;
+    }
+
+    /** {@inheritdoc} */
+    getTile(z: number, x: number, y: number): GeoJSONVTTile | null {
+        const {extent, debug} = this.options;
+        
+        const z2 = 1 << z;
+        x = (x + z2) & (z2 - 1); // wrap tile x coordinate
+
+        const id = toID(z, x, y);
+        if (this.tiles[id]) {
+            return transformTile(this.tiles[id], extent);
+        }
+
+        if (debug > 1) console.log('drilling down to z%d-%d-%d', z, x, y);
+
+        let z0 = z;
+        let x0 = x;
+        let y0 = y;
+        let parent;
+
+        while (!parent && z0 > 0) {
+            z0--;
+            x0 = x0 >> 1;
+            y0 = y0 >> 1;
+            parent = this.tiles[toID(z0, x0, y0)];
+        }
+
+        if (!parent?.source) return null;
+
+        // if we found a parent tile containing the original geometry, we can drill down from it
+        if (debug > 1) {
+            console.log('found parent tile z%d-%d-%d', z0, x0, y0);
+            console.time('drilling down');
+        }
+        this.splitTile(parent.source, z0, x0, y0, z, x, y);
+        if (debug > 1) console.timeEnd('drilling down');
+
+        if (!this.tiles[id]) return null;
+
+        return transformTile(this.tiles[id], extent);
+    }
+
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * z, x, and y are the coordinates of the parent tile
+     * cz, cx, and cy are the coordinates of the target tile
+     * 
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the options.
+     * @internal
+     * @param features - features to split
+     * @param z - tile zoom level
+     * @param x - tile x coordinate
+     * @param y - tile y coordinate
+     * @param cz - target tile zoom level
+     * @param cx - target tile x coordinate
+     * @param cy - target tile y coordinate
+     */
+    private splitTile(features: GeoJSONVTInternalFeature[], z: number, x: number, y: number, cz?: number, cx?: number, cy?: number) {
+
+        const stack = [features, z, x, y];
+        const options = this.options;
+        const debug = options.debug;
+
+        // avoid recursion by using a processing queue
+        while (stack.length) {
+            y = stack.pop() as number;
+            x = stack.pop() as number;
+            z = stack.pop() as number;
+            features = stack.pop() as GeoJSONVTInternalFeature[];
+
+            const z2 = 1 << z;
+            const id = toID(z, x, y);
+            let tile = this.tiles[id];
+
+            if (!tile) {
+                if (debug > 1) console.time('creation');
+
+                tile = this.tiles[id] = createTile(features, z, x, y, options);
+                this.tileCoords.push({z, x, y, id});
+
+                if (debug) {
+                    if (debug > 1) {
+                        console.log('tile z%d-%d-%d (features: %d, points: %d, simplified: %d)',
+                            z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);
+                        console.timeEnd('creation');
+                    }
+                    const key = `z${  z}`;
+                    this.stats[key] = (this.stats[key] || 0) + 1;
+                    this.total++;
+                }
+            }
+
+            // save reference to original geometry in tile so that we can drill down later if we stop now
+            tile.source = features;
+
+            // if it's the first-pass tiling
+            if (cz == null) {
+                // stop tiling if we reached max zoom, or if the tile is too simple
+                if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) continue;
+            // if a drilldown to a specific tile
+            } else if (z === options.maxZoom || z === cz) {
+                // stop tiling if we reached base zoom or our target tile zoom
+                continue;
+            } else if (cz != null) {
+                // stop tiling if it's not an ancestor of the target tile
+                const zoomSteps = cz - z;
+                if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) continue;
+            }
+
+            // if we slice further down, no need to keep source geometry
+            tile.source = null;
+
+            if (!features.length) continue;
+
+            if (debug > 1) console.time('clipping');
+
+            // values we'll use for clipping
+            const k1 = 0.5 * options.buffer / options.extent;
+            const k2 = 0.5 - k1;
+            const k3 = 0.5 + k1;
+            const k4 = 1 + k1;
+
+            let tl = null;
+            let bl = null;
+            let tr = null;
+            let br = null;
+
+            const left  = clip(features, z2, x - k1, x + k3, AxisType.X, tile.minX, tile.maxX, options);
+            const right = clip(features, z2, x + k2, x + k4, AxisType.X, tile.minX, tile.maxX, options);
+
+            if (left) {
+                tl = clip(left, z2, y - k1, y + k3, AxisType.Y, tile.minY, tile.maxY, options);
+                bl = clip(left, z2, y + k2, y + k4, AxisType.Y, tile.minY, tile.maxY, options);
+            }
+
+            if (right) {
+                tr = clip(right, z2, y - k1, y + k3, AxisType.Y, tile.minY, tile.maxY, options);
+                br = clip(right, z2, y + k2, y + k4, AxisType.Y, tile.minY, tile.maxY, options);
+            }
+
+            if (debug > 1) console.timeEnd('clipping');
+
+            stack.push(tl || [], z + 1, x * 2,     y * 2);
+            stack.push(bl || [], z + 1, x * 2,     y * 2 + 1);
+            stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
+            stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
+        }
+    }
+
+    /**
+     * Invalidates (removes) tiles affected by the provided features
+     * @internal
+     * @param features 
+     */
+    private invalidateTiles(features: GeoJSONVTInternalFeature[]) {
+        if (!features.length) return;
+        const options = this.options;
+        const {debug} = options;
+
+        // calculate bounding box of all features for trivial reject
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minY = Infinity;
+        let maxY = -Infinity;
+
+        for (const feature of features) {
+            minX = Math.min(minX, feature.minX);
+            maxX = Math.max(maxX, feature.maxX);
+            minY = Math.min(minY, feature.minY);
+            maxY = Math.max(maxY, feature.maxY);
+        }
+
+        // tile buffer clipping value - not halved as in splitTile above because checking against tile's own extent
+        const k1 = options.buffer / options.extent;
+
+        // track removed tile ids for o(1) lookup
+        const removedLookup = new Set();
+
+        // iterate through existing tiles and remove ones that are affected by features
+        for (const id in this.tiles) {
+            const tile = this.tiles[id];
+
+            // calculate tile bounds including buffer
+            const z2 = 1 << tile.z;
+            const tileMinX = (tile.x     - k1) / z2;
+            const tileMaxX = (tile.x + 1 + k1) / z2;
+            const tileMinY = (tile.y     - k1) / z2;
+            const tileMaxY = (tile.y + 1 + k1) / z2;
+
+            // trivial reject if feature bounds don't intersect tile
+            if (maxX < tileMinX || minX >= tileMaxX ||
+                maxY < tileMinY || minY >= tileMaxY) {
+                continue;
+            }
+
+            // check if any feature intersects with the tile
+            let intersects = false;
+            for (const feature of features) {
+                if (feature.maxX >= tileMinX && feature.minX < tileMaxX &&
+                    feature.maxY >= tileMinY && feature.minY < tileMaxY) {
+                    intersects = true;
+                    break;
+                }
+            }
+            if (!intersects) continue;
+
+            if (debug) {
+                if (debug > 1) {
+                    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}`;
+                this.stats[key] = (this.stats[key] || 0) - 1;
+                this.total--;
+            }
+
+            delete this.tiles[id];
+            removedLookup.add(id);
+        }
+
+        // remove tile coords that are no longer in the index
+        if (removedLookup.size) {
+            this.tileCoords = this.tileCoords.filter(c => !removedLookup.has(c.id));
+        }
+    }
+}
+
+function toID(z: number, x: number, y: number): number {
+    return (((1 << z) * y + x) * 32) + z;
+}

package/src/tile.ts

@@ -1,35 +1,6 @@
-import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
 
-export type GeoJSONVTInternalTileFeaturePoint = {
-    id? : number | string | undefined;
-    type: 1;
-    tags: GeoJSON.GeoJsonProperties | null;
-    geometry: number[];
-}
 
-export type GeoJSONVTInternalTileFeaturNonPoint = {
-    id? : number | string | undefined;
-    type: 2 | 3;
-    tags: GeoJSON.GeoJsonProperties | null;
-    geometry: number[][];
-}
-export type GeoJSONVTInternalTileFeature = GeoJSONVTInternalTileFeaturePoint | GeoJSONVTInternalTileFeaturNonPoint;
-
-export type GeoJSONVTInternalTile = {
-    features: GeoJSONVTInternalTileFeature[];
-    numPoints: number;
-    numSimplified: number;
-    numFeatures: number;
-    x: number;
-    y: number;
-    z: number;
-    transformed: boolean;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    source: GeoJSONVTInternalFeature[] | null;
-}
 
 /**
  * Creates a tile object from the given features
@@ -44,19 +15,19 @@ export function createTile(features: GeoJSONVTInternalFeature[], z: number, tx:
     const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
 
     const tile = {
+        transformed: false,
         features: [] as GeoJSONVTInternalTileFeature[],
-        numPoints: 0,
-        numSimplified: 0,
-        numFeatures: features.length,
-        source: null as GeoJSONVTInternalFeature[] | null,
+        source: null as GeoJSONVTInternalFeature[],
         x: tx,
         y: ty,
-        z,
-        transformed: false,
+        z: z,
         minX: 2,
         minY: 1,
         maxX: -1,
-        maxY: 0
+        maxY: 0,
+        numPoints: 0,
+        numSimplified: 0,
+        numFeatures: features.length
     };
 
     for (const feature of features) {
@@ -72,81 +43,99 @@ function addFeature(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalFeatu
     tile.maxX = Math.max(tile.maxX, feature.maxX);
     tile.maxY = Math.max(tile.maxY, feature.maxY);
 
-    let tags = feature.tags || null;
-
-    let tileFeature: GeoJSONVTInternalTileFeature;
-
     switch (feature.type) {
         case 'Point':
-        case 'MultiPoint': {
-            const geometry: number[] = [];
-            for (let i = 0; i < feature.geometry.length; i += 3) {
-                geometry.push(feature.geometry[i] , feature.geometry[i + 1]);
-                tile.numPoints++;
-                tile.numSimplified++;
-            }
-            if (!geometry.length) return;
-            tileFeature = {
-                type: 1,
-                tags: tags,
-                geometry: geometry
-            }
-            break;
-        }
-        case 'LineString': {
-            const geometry: number[][] = [];
-            addLine(geometry, feature.geometry, tile, tolerance, false, false);
-            if (!geometry.length) return;
-            if (options.lineMetrics) {
-                tags = {};
-                for (const key in feature.tags) tags[key] = feature.tags[key];
-                // HM TODO: replace with geojsonvt
-                tags['mapbox_clip_start'] = feature.geometry.start / feature.geometry.size;
-                tags['mapbox_clip_end'] = feature.geometry.end / feature.geometry.size;
-            }
-            tileFeature = {
-                type: 2,
-                tags: tags,
-                geometry: geometry
-            }
-            break;
-        }
+        case 'MultiPoint': 
+            addPointsTileFeature(tile, feature);
+            return;
+        case 'LineString':
+            addLineTileFeautre(tile, feature, tolerance, options);
+            return;
         case 'MultiLineString':
-        case 'Polygon': {
-            const geometry: number[][] = [];
-            for (let i = 0; i < feature.geometry.length; i++) {
-                addLine(geometry, feature.geometry[i], tile, tolerance, feature.type === 'Polygon', i === 0);
-            }
-            if (!geometry.length) return;
-            tileFeature = {
-                type: feature.type === 'Polygon' ? 3 : 2,
-                tags: tags,
-                geometry: geometry
-            }
-            break;
-        }
-        case 'MultiPolygon': {
-            const geometry: number[][] = [];
-            for (let k = 0; k < feature.geometry.length; k++) {
-                const polygon = feature.geometry[k];
-                for (let i = 0; i < polygon.length; i++) {
-                    addLine(geometry, polygon[i], tile, tolerance, true, i === 0);
-                }
-            }
-            if (!geometry.length) return;
-            tileFeature = {
-                type: 3,
-                tags: tags,
-                geometry: geometry
-            }
-            break;
-        }
+        case 'Polygon':
+            addLinesTileFeature(tile, feature, tolerance);
+            return;
+        case 'MultiPolygon': 
+            addMultiPolygonTileFeature(tile, feature, tolerance);
+            return;
     }
+}
 
+function addPointsTileFeature(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalPointFeature | GeoJSONVTInternalMultiPointFeature) {
+    const geometry: number[] = [];
+    for (let i = 0; i < feature.geometry.length; i += 3) {
+        geometry.push(feature.geometry[i] , feature.geometry[i + 1]);
+        tile.numPoints++;
+        tile.numSimplified++;
+    }
+    if (!geometry.length) return;
+    const tileFeature: GeoJSONVTInternalTileFeature = {
+        type: 1,
+        tags: feature.tags || null,
+        geometry: geometry
+    };
     if (feature.id !== null) {
         tileFeature.id = feature.id;
     }
+    tile.features.push(tileFeature);
+}
 
+function addLineTileFeautre(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalLineStringFeature, tolerance: number, options: GeoJSONVTOptions) {
+    const geometry: number[][] = [];
+    addLine(geometry, feature.geometry, tile, tolerance, false, false);
+    if (!geometry.length) return;
+    let tags = feature.tags || null;
+    if (options.lineMetrics) {
+        tags = {};
+        for (const key in feature.tags) tags[key] = feature.tags[key];
+        tags['geojsonvt_clip_start'] = feature.geometry.start / feature.geometry.size;
+        tags['geojsonvt_clip_end'] = feature.geometry.end / feature.geometry.size;
+    }
+    const tileFeature: GeoJSONVTInternalTileFeature = {
+        type: 2,
+        tags: tags,
+        geometry: geometry
+    }
+    if (feature.id !== null) {
+        tileFeature.id = feature.id;
+    }
+    tile.features.push(tileFeature);
+}
+
+function addLinesTileFeature(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalPolygonFeature | GeoJSONVTInternalMultiLineStringFeature, tolerance: number) {
+    const geometry: number[][] = [];
+    for (let i = 0; i < feature.geometry.length; i++) {
+        addLine(geometry, feature.geometry[i], tile, tolerance, feature.type === 'Polygon', i === 0);
+    }
+    if (!geometry.length) return;
+    const tileFeature: GeoJSONVTInternalTileFeature = {
+        type: feature.type === 'Polygon' ? 3 : 2,
+        tags: feature.tags || null,
+        geometry: geometry
+    }
+    if (feature.id !== null) {
+        tileFeature.id = feature.id;
+    }
+    tile.features.push(tileFeature);
+}
+
+function addMultiPolygonTileFeature(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalMultiPolygonFeature, tolerance: number) {
+    const geometry: number[][] = [];
+    for (let k = 0; k < feature.geometry.length; k++) {
+        const polygon = feature.geometry[k];
+        for (let i = 0; i < polygon.length; i++) {
+            addLine(geometry, polygon[i], tile, tolerance, true, i === 0);
+        }
+    }
+    if (!geometry.length) return;
+    const tileFeature: GeoJSONVTInternalTileFeature = {
+        type: 3,
+        tags: feature.tags || null,
+        geometry: geometry
+    }
+    if (feature.id !== null) {
+        tileFeature.id = feature.id;
+    }
     tile.features.push(tileFeature);
 }
 

package/src/transform.ts

@@ -1,25 +1,4 @@
-import type { GeoJSONVTInternalTile } from "./tile";
-
-export type GeoJSONVTFeaturePoint = {
-    id? : number | string | undefined;
-    type: 1;
-    tags: GeoJSON.GeoJsonProperties | null;
-    geometry: [number, number][]
-}
-
-export type GeoJSONVTFeatureNonPoint = {
-    id? : number | string | undefined;
-    type: 2 | 3;
-    tags: GeoJSON.GeoJsonProperties | null;
-    geometry: [number, number][][]
-}
-
-export type GeoJSONVTFeature = GeoJSONVTFeaturePoint | GeoJSONVTFeatureNonPoint;
-
-export type GeoJSONVTTile = GeoJSONVTInternalTile & {
-    transformed: true;
-    features: GeoJSONVTFeature[]
-}
+import type { GeoJSONVTFeatureNonPoint, GeoJSONVTFeaturePoint, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTTile } from "./definitions";
 
 /**
  * Transforms the coordinates of each feature in the given tile from
@@ -39,29 +18,52 @@ export function transformTile(tile: GeoJSONVTInternalTile, extent: number): GeoJ
 
     for (const feature of tile.features) {
         if (feature.type === 1) {
-            const pointGeometry: [number, number][] = []
-            for (let j = 0; j < feature.geometry.length; j += 2) {
-                pointGeometry.push(transformPoint(feature.geometry[j], feature.geometry[j + 1], extent, z2, tx, ty));
-            }
-            (feature as unknown as GeoJSONVTFeaturePoint).geometry = pointGeometry;
-            continue;
-        }
-
-        const geometry: [number, number][][] = [];
-        for (const singleGeom of feature.geometry) {
-            const ring: [number, number][] = [];
-            for (let k = 0; k < singleGeom.length; k += 2) {
-                ring.push(transformPoint(singleGeom[k], singleGeom[k + 1], extent, z2, tx, ty));
-            }
-            geometry.push(ring);
-        }
-        (feature as unknown as GeoJSONVTFeatureNonPoint).geometry = geometry;
+            transformPointFeature(feature, extent, z2, tx, ty);
+        } else {
+            transformNonPointFeature(feature, extent, z2, tx, ty);
+        }   
     }
     tile.transformed = true;
 
     return tile as GeoJSONVTTile;
 }
 
+/**
+ * Transforms a single point feature from mercator-projected space into (extent x extent) tile space.
+ */
+function transformPointFeature(feature: GeoJSONVTInternalTileFeaturePoint, extent: number, z2: number, tx: number, ty: number): GeoJSONVTFeaturePoint {
+    const transformed = feature as unknown as GeoJSONVTFeaturePoint;
+
+    const geometry = feature.geometry;
+    const point: GeoJSONVTFeaturePoint["geometry"] = [];
+    for (let i = 0; i < geometry.length; i += 2) {
+        point.push(transformPoint(geometry[i], geometry[i + 1], extent, z2, tx, ty));
+    }
+    transformed.geometry = point;
+
+    return transformed;
+}
+
+/**
+ * Transforms a single non-point feature from mercator-projected space into (extent x extent) tile space.
+ */
+function transformNonPointFeature(feature: GeoJSONVTInternalTileFeatureNonPoint, extent: number, z2: number, tx: number, ty: number): GeoJSONVTFeatureNonPoint {
+    const transformed = feature as unknown as GeoJSONVTFeatureNonPoint;
+
+    const geometry = feature.geometry;
+    const nonPoint: GeoJSONVTFeatureNonPoint["geometry"] = [];
+    for (const geom of geometry) {
+        const ring: GeoJSONVTFeaturePoint["geometry"] = [];
+        for (let i = 0; i < geom.length; i += 2) {
+            ring.push(transformPoint(geom[i], geom[i + 1], extent, z2, tx, ty));
+        }
+        nonPoint.push(ring);
+    }
+    transformed.geometry = nonPoint;
+
+    return transformed;
+}
+
 function transformPoint(x: number, y: number, extent: number, z2: number, tx: number, ty: number): [number, number] {
     return [
         Math.round(extent * (x * z2 - tx)),

package/src/wrap.ts

@@ -1,5 +1,5 @@
 
-import {clip} from './clip';
+import {AxisType, clip} from './clip';
 import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 import {createFeature} from './feature';
 
@@ -7,12 +7,12 @@ export function wrap(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOpt
     const buffer = options.buffer / options.extent;
     let merged = features;
 
-    const left  = clip(features, 1, -1 - buffer, buffer,     0, -1, 2, options); // left world copy
-    const right = clip(features, 1,  1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
+    const left  = clip(features, 1, -1 - buffer, buffer,     AxisType.X, -1, 2, options); // left world copy
+    const right = clip(features, 1,  1 - buffer, 2 + buffer, AxisType.X, -1, 2, options); // right world copy
 
     if (!left && !right) return merged;
 
-    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
+    merged = clip(features, 1, -buffer, 1 + buffer, AxisType.X, -1, 2, options) || []; // center world copy
 
     if (left) merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
     if (right) merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center