@maplibre/geojson-vt 6.0.4 → 6.1.0

package/src/difference.ts

@@ -74,7 +74,7 @@ type HashedGeoJSONVTSourceDiff = {
  */
 export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions): ApplySourceDiffResult {
     // convert diff to sets/maps for o(1) lookups
-    const diff = diffToHashed(dataDiff);
+    const diff = diffToHashed(dataDiff, options);
 
     // collection for features that will be affected by this update and used to invalidate tiles
     let affected: GeoJSONVTInternalFeature[] = [];
@@ -110,26 +110,24 @@ export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: Ge
 
     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[]>();
+        const keepFeatures = [];
+        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;
         }
+        source = keepFeatures;
     }
 
     return {affected, source};
@@ -174,7 +172,7 @@ function getUpdatedFeatures(vtFeatures: GeoJSONVTInternalFeature[], update: GeoJ
         return updated;
     }
 
-    return [];
+    return vtFeatures;
 }
 
 /**
@@ -205,7 +203,7 @@ function applyPropertyUpdates(tags: GeoJSON.GeoJsonProperties, update: GeoJSONVT
 /**
  * Convert a GeoJSON Source Diff to an idempotent hashed representation using Sets and Maps
  */
-export function diffToHashed(diff: GeoJSONVTSourceDiff): HashedGeoJSONVTSourceDiff {
+export function diffToHashed(diff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions): HashedGeoJSONVTSourceDiff {
     if (!diff) return {
         remove: new Set(),
         add: new Map(),
@@ -215,7 +213,7 @@ export function diffToHashed(diff: GeoJSONVTSourceDiff): HashedGeoJSONVTSourceDi
     const hashed: HashedGeoJSONVTSourceDiff = {
         removeAll: diff.removeAll,
         remove: new Set(diff.remove || []),
-        add: new Map(diff.add?.map(feature => [feature.id, feature])),
+        add: new Map(diff.add?.map(feature => [options.promoteId ? feature.properties[options.promoteId] : feature.id, feature])),
         update: new Map(diff.update?.map(update => [update.id, update]))
     };
 

package/src/feature.ts

@@ -1,4 +1,4 @@
-import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature } from "./definitions";
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, SliceArray, SliceFixedArray } from "./definitions";
 
 type FeatureTypeMap = {
     Point: GeoJSONVTInternalPointFeature["geometry"];
@@ -35,25 +35,28 @@ export function createFeature<T extends GeoJSONVTInternalFeature["type"]>(id: nu
     switch (data.type) {
         case 'Point':
         case 'MultiPoint':
-        case 'LineString':
             calcLineBBox(feature, data.geom);
             break;
 
+        case 'LineString':
+            calcLineBBox(feature, data.geom.points);
+            break;
+
         case 'Polygon':
             // the outer ring (ie [0]) contains all inner rings
-            calcLineBBox(feature, data.geom[0]);
+            calcLineBBox(feature, data.geom[0].points);
             break;
 
         case 'MultiLineString':
             for (const line of data.geom) {
-                calcLineBBox(feature, line);
+                calcLineBBox(feature, line.points);
             }
             break;
 
         case 'MultiPolygon':
             for (const polygon of data.geom) {
                 // the outer ring (ie [0]) contains all inner rings
-                calcLineBBox(feature, polygon[0]);
+                calcLineBBox(feature, polygon[0].points);
             }
             break;
     }
@@ -61,7 +64,14 @@ export function createFeature<T extends GeoJSONVTInternalFeature["type"]>(id: nu
     return feature;
 }
 
-function calcLineBBox(feature: GeoJSONVTInternalFeature, geom: number[]) {
+export function optimizeLineMemory(line: SliceArray) {
+    const lineImmutable = line as SliceFixedArray;
+    if (line.points.length > 64) {
+        lineImmutable.points = new Float64Array(line.points);
+    }
+}
+
+function calcLineBBox(feature: GeoJSONVTInternalFeature, geom: number[] | Float64Array) {
     for (let i = 0; i < geom.length; i += 3) {
         feature.minX = Math.min(feature.minX, geom[i]);
         feature.minY = Math.min(feature.minY, geom[i + 1]);

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/index.ts

@@ -1,6 +1,6 @@
 
 import type {GeoJSONVTFeatureDiff, GeoJSONVTSourceDiff} from './difference';
-import type {GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTOptions, GeoJSONToTileOptions, PartialGeoJSONVTFeature, StartEndSizeArray, 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} from './definitions';
 import type {KDBushWithData} from './cluster-tile-index';
 import {GeoJSONVT} from './geojsonvt';
 import {ClusterTileIndex} from './cluster-tile-index';
@@ -22,7 +22,8 @@ export type {
     GeoJSONVTInternalTile, 
     GeoJSONVTInternalTileFeature, 
     PartialGeoJSONVTFeature,
-    StartEndSizeArray,
+    SliceArray,
+    SliceFixedArray,
     GeoJSONVTTile,
     GeoJSONVTFeature,
     GeoJSONVTSourceDiff,

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--;
             }

package/src/tile.ts

@@ -1,4 +1,4 @@
-import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, GeoJSONVTOptions, SliceFixedArray } from "./definitions";
 
 export const GEOJSONVT_CLIP_START = 'geojsonvt_clip_start';
 export const GEOJSONVT_CLIP_END = 'geojsonvt_clip_end';
@@ -140,20 +140,20 @@ function addMultiPolygonTileFeature(tile: GeoJSONVTInternalTile, feature: GeoJSO
     tile.features.push(tileFeature);
 }
 
-function addLine(result: number[][], geom: StartEndSizeArray, tile: GeoJSONVTInternalTile, tolerance: number, isPolygon: boolean, isOuter: boolean) {
+function addLine(result: number[][], geom: SliceFixedArray, tile: GeoJSONVTInternalTile, tolerance: number, isPolygon: boolean, isOuter: boolean) {
     const sqTolerance = tolerance * tolerance;
 
     if (tolerance > 0 && (geom.size < (isPolygon ? sqTolerance : tolerance))) {
-        tile.numPoints += geom.length / 3;
+        tile.numPoints += geom.points.length / 3;
         return;
     }
 
     const ring = [];
 
-    for (let i = 0; i < geom.length; i += 3) {
-        if (tolerance === 0 || geom[i + 2] > sqTolerance) {
+    for (let i = 0; i < geom.points.length; i += 3) {
+        if (tolerance === 0 || geom.points[i + 2] > sqTolerance) {
             tile.numSimplified++;
-            ring.push(geom[i], geom[i + 1]);
+            ring.push(geom.points[i], geom.points[i + 1]);
         }
         tile.numPoints++;
     }

package/src/wrap.ts

@@ -1,7 +1,7 @@
 
 import {AxisType, clip} from './clip';
-import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
-import {createFeature} from './feature';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, SliceArray, SliceFixedArray } from './definitions';
+import {createFeature, optimizeLineMemory} from './feature';
 
 export function wrap(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
     const buffer = options.buffer / options.extent;
@@ -26,9 +26,15 @@ function shiftFeatureCoords(features: GeoJSONVTInternalFeature[], offset: number
     for (const feature of features) {
         switch (feature.type) {
             case 'Point':
-            case 'MultiPoint':
+            case 'MultiPoint': {
+                const newGeometry = shiftPointCoords(feature.geometry, offset);
+
+                newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+                continue;
+            }
+
             case 'LineString': {
-                const newGeometry = shiftCoords(feature.geometry, offset);
+                const newGeometry = shiftLineCoords(feature.geometry, offset);
 
                 newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
                 continue;
@@ -36,9 +42,9 @@ function shiftFeatureCoords(features: GeoJSONVTInternalFeature[], offset: number
 
             case 'MultiLineString':
             case 'Polygon': {
-                const newGeometry = [];
+                const newGeometry: SliceFixedArray[] = [];
                 for (const line of feature.geometry) {
-                    newGeometry.push(shiftCoords(line, offset));
+                    newGeometry.push(shiftLineCoords(line, offset));
                 }
 
                 newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
@@ -46,11 +52,11 @@ function shiftFeatureCoords(features: GeoJSONVTInternalFeature[], offset: number
             }
 
             case 'MultiPolygon': {
-                const newGeometry = [];
+                const newGeometry: SliceFixedArray[][] = [];
                 for (const polygon of feature.geometry) {
-                    const newPolygon = [];
+                    const newPolygon: SliceFixedArray[] = [];
                     for (const line of polygon) {
-                        newPolygon.push(shiftCoords(line, offset));
+                        newPolygon.push(shiftLineCoords(line, offset));
                     }
                     newGeometry.push(newPolygon);
                 }
@@ -64,18 +70,32 @@ function shiftFeatureCoords(features: GeoJSONVTInternalFeature[], offset: number
     return newFeatures;
 }
 
-function shiftCoords(points: StartEndSizeArray, offset: number): number[] | StartEndSizeArray {
-    const newPoints: StartEndSizeArray = [];
-    newPoints.size = points.size;
+function shiftPointCoords(coords: number[], offset: number): number[] {
+    const newCoords: number[] = [];
 
-    if (points.start !== undefined) {
-        newPoints.start = points.start;
-        newPoints.end = points.end;
+    for (let i = 0; i < coords.length; i += 3) {
+        newCoords.push(coords[i] + offset, coords[i + 1], coords[i + 2]);
     }
 
-    for (let i = 0; i < points.length; i += 3) {
-        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
+    return newCoords;
+}
+
+function shiftLineCoords(line: SliceArray | SliceFixedArray, offset: number): SliceFixedArray {
+    const newLine: SliceArray = {
+        points: [],
+        size: line.size
+    };
+
+    if (line.start !== undefined) {
+        newLine.start = line.start;
+        newLine.end = line.end;
     }
 
-    return newPoints;
+    for (let i = 0; i < line.points.length; i += 3) {
+        newLine.points.push(line.points[i] + offset, line.points[i + 1], line.points[i + 2]);
+    }
+
+    optimizeLineMemory(newLine);
+
+    return newLine;
 }