@maplibre/geojson-vt 5.0.1 → 5.0.2

package/src/feature.ts

@@ -0,0 +1,64 @@
+import type { GeoJSONVTFeature, GeometryType, GeometryTypeMap } from "./definitions";
+
+export type SupportedGeometries = GeoJSON.Point | GeoJSON.MultiPoint | GeoJSON.LineString | GeoJSON.MultiLineString | GeoJSON.Polygon | GeoJSON.MultiPolygon;
+
+/**
+ * 
+ * @param id - the feature's ID
+ * @param type - the feature's type
+ * @param geom - the feature's geometry
+ * @param tags - the feature's properties
+ * @returns the created feature
+ */
+export function createFeature<T extends GeometryType>(id: number | string | undefined, type: T, geom: GeometryTypeMap[T], tags: GeoJSON.GeoJsonProperties): GeoJSONVTFeature {
+    // This is mostly for TypeScript type narrowing
+    const data = { type, geom } as { [K in GeometryType]: { type: K, geom: GeometryTypeMap[K] } }[GeometryType];
+
+    const feature = {
+        id: id == null ? null : id,
+        type: data.type,
+        geometry: data.geom,
+        tags,
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    } as GeoJSONVTFeature;
+
+    switch (data.type) {
+        case 'Point':
+        case 'MultiPoint':
+        case 'LineString':
+            calcLineBBox(feature, data.geom);
+            break;
+
+        case 'Polygon':
+            // the outer ring (ie [0]) contains all inner rings
+            calcLineBBox(feature, data.geom[0]);
+            break;
+
+        case 'MultiLineString':
+            for (const line of data.geom) {
+                calcLineBBox(feature, line);
+            }
+            break;
+
+        case 'MultiPolygon':
+            for (const polygon of data.geom) {
+                // the outer ring (ie [0]) contains all inner rings
+                calcLineBBox(feature, polygon[0]);
+            }
+            break;
+    }
+
+    return feature;
+}
+
+function calcLineBBox(feature: GeoJSONVTFeature, geom: number[]) {
+    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]);
+        feature.maxX = Math.max(feature.maxX, geom[i]);
+        feature.maxY = Math.max(feature.maxY, geom[i + 1]);
+    }
+}

package/src/{index.js → index.ts}

@@ -1,28 +1,42 @@
 
-import convert from './convert.js';              // GeoJSON conversion and preprocessing
-import clip from './clip.js';                    // stripe clipping algorithm
-import wrap from './wrap.js';                    // date line processing
-import transform from './transform.js';          // coordinate transformation
-import createTile from './tile.js';              // final simplified tile generation
-import {applySourceDiff} from './difference.js'; // diff utilities
-
-const defaultOptions = {
-    maxZoom: 14,            // max zoom to preserve detail on
-    indexMaxZoom: 5,        // max zoom in the tile index
-    indexMaxPoints: 100000, // max number of points per tile in the tile index
-    tolerance: 3,           // simplification tolerance (higher means simpler)
-    extent: 4096,           // tile extent
-    buffer: 64,             // tile buffer on each side
-    lineMetrics: false,     // whether to calculate line metrics
-    promoteId: null,        // name of a feature property to be promoted to feature.id
-    generateId: false,      // whether to generate feature ids. Cannot be used with promoteId
-    updateable: false,      // whether geojson can be updated (with caveat of a stored simplified copy)
-    debug: 0                // logging level (0, 1 or 2)
+import {convert} from './convert';
+import {clip} from './clip';
+import {wrap} from './wrap';
+import {transformTile, type GeoJSONVTTransformedTile} from './transform';
+import {createTile, type GeoJSONVTTile, type GeoJSONVTTileFeature} from './tile';
+import {applySourceDiff, type GeoJSONVTFeatureDiff, type GeoJSONVTSourceDiff} from './difference';
+import type { GeoJSONVTFeature, GeoJSONVTOptions, GeometryType, GeometryTypeMap, PartialGeoJSONVTFeature, StartEndSizeArray } from './definitions';
+
+const defaultOptions: GeoJSONVTOptions = {
+    maxZoom: 14,
+    indexMaxZoom: 5,
+    indexMaxPoints: 100000,
+    tolerance: 3,
+    extent: 4096,
+    buffer: 64,
+    lineMetrics: false,
+    promoteId: null,
+    generateId: false,
+    updateable: false,
+    debug: 0
 };
 
+/**
+ * Main class for creating and managing a vector tile index from GeoJSON data.
+ */
 class GeoJSONVT {
-    constructor(data, options) {
-        options = this.options = extend(Object.create(defaultOptions), options);
+    private options: GeoJSONVTOptions;
+    /** @internal */
+    public tiles: {[key: string]: GeoJSONVTTile};
+    private tileCoords: {z: number, x: number, y: number, id: number}[];
+    /** @internal */
+    public stats: {[key: string]: number} = {};
+    /** @internal */
+    public total: number = 0;
+    private source?: GeoJSONVTFeature[];
+
+    constructor(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions) {
+        options = this.options = Object.assign({}, defaultOptions, options);
 
         const debug = options.debug;
 
@@ -50,7 +64,9 @@ class GeoJSONVT {
         features = wrap(features, options);
 
         // start slicing from the top tile down
-        if (features.length) this.splitTile(features, 0, 0, 0);
+        if (features.length) {
+            this.splitTile(features, 0, 0, 0);
+        }
 
         // for updateable indexes, store a copy of the original simplified features
         if (options.updateable) {
@@ -64,13 +80,23 @@ class GeoJSONVT {
         }
     }
 
-    // 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.
-    splitTile(features, z, x, y, cz, cx, cy) {
+    /**
+     * 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
+     */
+    splitTile(features: GeoJSONVTFeature[], z: number, x: number, y: number, cz?: number, cx?: number, cy?: number) {
 
         const stack = [features, z, x, y];
         const options = this.options;
@@ -78,10 +104,10 @@ class GeoJSONVT {
 
         // avoid recursion by using a processing queue
         while (stack.length) {
-            y = stack.pop();
-            x = stack.pop();
-            z = stack.pop();
-            features = stack.pop();
+            y = stack.pop() as number;
+            x = stack.pop() as number;
+            z = stack.pop() as number;
+            features = stack.pop() as GeoJSONVTFeature[];
 
             const z2 = 1 << z;
             const id = toID(z, x, y);
@@ -125,7 +151,7 @@ class GeoJSONVT {
             // if we slice further down, no need to keep source geometry
             tile.source = null;
 
-            if (features.length === 0) continue;
+            if (!features.length) continue;
 
             if (debug > 1) console.time('clipping');
 
@@ -162,7 +188,14 @@ class GeoJSONVT {
         }
     }
 
-    getTile(z, x, y) {
+    /**
+     * Given z, x, and y tile coordinates, returns the corresponding tile with geometries in tile coordinates, much like MVT data is stored.
+     * @param z - tile zoom level
+     * @param x - tile x coordinate
+     * @param y - tile y coordinate
+     * @returns the transformed tile or null if not found
+     */
+    getTile(z: number | string, x: number | string, y: number | string): GeoJSONVTTransformedTile | null {
         z = +z;
         x = +x;
         y = +y;
@@ -176,7 +209,9 @@ class GeoJSONVT {
         x = (x + z2) & (z2 - 1); // wrap tile x coordinate
 
         const id = toID(z, x, y);
-        if (this.tiles[id]) return transform(this.tiles[id], extent);
+        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);
 
@@ -192,7 +227,7 @@ class GeoJSONVT {
             parent = this.tiles[toID(z0, x0, y0)];
         }
 
-        if (!parent || !parent.source) return null;
+        if (!parent?.source) return null;
 
         // if we found a parent tile containing the original geometry, we can drill down from it
         if (debug > 1) {
@@ -202,11 +237,17 @@ class GeoJSONVT {
         this.splitTile(parent.source, z0, x0, y0, z, x, y);
         if (debug > 1) console.timeEnd('drilling down');
 
-        return this.tiles[id] ? transform(this.tiles[id], extent) : null;
+        if (!this.tiles[id]) return null;
+
+        return transformTile(this.tiles[id], extent);
     }
 
-    // invalidates (removes) tiles affected by the provided features
-    invalidateTiles(features) {
+    /**
+     * Invalidates (removes) tiles affected by the provided features
+     * @internal
+     * @param features 
+     */
+    invalidateTiles(features: GeoJSONVTFeature[]) {
         const options = this.options;
         const {debug} = options;
 
@@ -272,13 +313,17 @@ class GeoJSONVT {
         }
 
         // remove tile coords that are no longer in the index
-        if (removedLookup.size) this.tileCoords = this.tileCoords.filter(c => !removedLookup.has(c.id));
+        if (removedLookup.size) {
+            this.tileCoords = this.tileCoords.filter(c => !removedLookup.has(c.id));
+        }
     }
 
-    // updates the tile index by adding and/or removing geojson features
-    // invalidates tiles that are affected by the update for regeneration on next getTile call
-    // diff is an object with properties specified in difference.js
-    updateData(diff) {
+    /**
+     * Updates the tile index by adding and/or removing geojson features
+     * invalidates tiles that are affected by the update for regeneration on next getTile call.
+     * @param diff - the source diff object
+     */
+    updateData(diff: GeoJSONVTSourceDiff) {
         const options = this.options;
         const debug = options.debug;
 
@@ -320,15 +365,25 @@ class GeoJSONVT {
     }
 }
 
-function toID(z, x, y) {
+function toID(z: number, x: number, y: number): number {
     return (((1 << z) * y + x) * 32) + z;
 }
 
-function extend(dest, src) {
-    for (const i in src) dest[i] = src[i];
-    return dest;
-}
-
-export default function geojsonvt(data, options) {
+export default function geojsonvt(data: GeoJSON.GeoJSON, options?: GeoJSONVTOptions) {
     return new GeoJSONVT(data, options);
 }
+
+export type { 
+    GeoJSONVTFeature, 
+    GeoJSONVTOptions, 
+    GeoJSONVTTile, 
+    GeoJSONVTTileFeature, 
+    GeometryType,
+    PartialGeoJSONVTFeature,
+    GeoJSONVT,
+    GeometryTypeMap,
+    StartEndSizeArray,
+    GeoJSONVTTransformedTile,
+    GeoJSONVTSourceDiff,
+    GeoJSONVTFeatureDiff
+};

package/src/simplify.test.ts

@@ -0,0 +1,73 @@
+
+import {test, expect} from 'vitest';
+import {simplify} from './simplify';
+
+const points = [
+    [0.22455,0.25015],[0.22691,0.24419],[0.23331,0.24145],[0.23498,0.23606],
+    [0.24421,0.23276],[0.26259,0.21531],[0.26776,0.21381],[0.27357,0.20184],
+    [0.27312,0.19216],[0.27762,0.18903],[0.28036,0.18141],[0.28651,0.17774],
+    [0.29241,0.15937],[0.29691,0.15564],[0.31495,0.15137],[0.31975,0.14516],
+    [0.33033,0.13757],[0.34148,0.13996],[0.36998,0.13789],[0.38739,0.14251],
+    [0.39128,0.13939],[0.40952,0.14114],[0.41482,0.13975],[0.42772,0.12730],
+    [0.43960,0.11974],[0.47493,0.10787],[0.48651,0.10675],[0.48920,0.10945],
+    [0.49379,0.10863],[0.50474,0.11966],[0.51296,0.12235],[0.51863,0.12089],
+    [0.52409,0.12688],[0.52957,0.12786],[0.53421,0.14093],[0.53927,0.14724],
+    [0.56769,0.14891],[0.57525,0.15726],[0.58062,0.15815],[0.60153,0.15685],
+    [0.61774,0.15986],[0.62200,0.16704],[0.62955,0.19460],[0.63890,0.19561],
+    [0.64126,0.20081],[0.65177,0.20456],[0.67155,0.22255],[0.68368,0.21745],
+    [0.69525,0.21915],[0.70064,0.21798],[0.70312,0.21436],[0.71226,0.21587],
+    [0.72149,0.21281],[0.72781,0.21336],[0.72998,0.20873],[0.73532,0.20820],
+    [0.73994,0.20477],[0.76998,0.20842],[0.77960,0.21687],[0.78420,0.21816],
+    [0.80024,0.21462],[0.81053,0.21973],[0.81719,0.22682],[0.82077,0.23617],
+    [0.82723,0.23616],[0.82989,0.23989],[0.85100,0.24894],[0.85988,0.25549],
+    [0.86521,0.26853],[0.85795,0.28030],[0.86548,0.29145],[0.86681,0.29866],
+    [0.86468,0.30271],[0.86779,0.30617],[0.85987,0.31137],[0.86008,0.31435],
+    [0.85829,0.31494],[0.85810,0.32760],[0.85454,0.33540],[0.86092,0.34300],
+    [0.85643,0.35015],[0.85142,0.35296],[0.84984,0.35959],[0.85456,0.36553],
+    [0.84974,0.37038],[0.84409,0.37189],[0.84475,0.38044],[0.84152,0.38367],
+    [0.83957,0.39040],[0.84559,0.39905],[0.84840,0.40755],[0.84371,0.41130],
+    [0.84409,0.41988],[0.83951,0.43276],[0.84133,0.44104],[0.84762,0.44922],
+    [0.84716,0.45844],[0.85138,0.46279],[0.85397,0.47115],[0.86636,0.48077]
+];
+
+const simplified = [
+    [0.22455,0.25015],[0.26776,0.21381],[0.29691,0.15564],[0.33033,0.13757],
+    [0.40952,0.14114],[0.4396,0.11974],[0.48651,0.10675],[0.52957,0.12786],
+    [0.53927,0.14724],[0.56769,0.14891],[0.61774,0.15986],[0.62955,0.1946],
+    [0.67155,0.22255],[0.72781,0.21336],[0.73994,0.20477],[0.76998,0.20842],
+    [0.7842,0.21816],[0.80024,0.21462],[0.82077,0.23617],[0.85988,0.25549],
+    [0.86521,0.26853],[0.85795,0.2803],[0.86779,0.30617],[0.85829,0.31494],
+    [0.85454,0.3354],[0.86092,0.343],[0.84984,0.35959],[0.85456,0.36553],
+    [0.84409,0.37189],[0.83957,0.3904],[0.8484,0.40755],[0.83951,0.43276],
+    [0.85397,0.47115],[0.86636,0.48077]
+];
+
+test('simplifies points correctly with the given tolerance', () => {
+    const coords = [];
+    for (let i = 0; i < points.length; i++) {
+        coords.push(points[i][0], points[i][1], 0);
+    }
+
+    coords[2] = 1;
+    coords[coords.length - 1] = 1;
+    simplify(coords, 0, coords.length - 3, 0.001 * 0.001);
+
+    const result = [];
+    for (let i = 0; i < coords.length; i += 3) {
+        if (coords[i + 2] > 0.005 * 0.005) {
+            result.push([coords[i], coords[i + 1]]);
+        }
+    }
+    expect(result).toEqual(simplified);
+});
+
+test('does not throw max call stack error on bad long input', () => {
+    const coords: number[] = [];
+    for (let i = 0; i < 1400; i++) {
+        coords.push(0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0);
+    }
+
+    expect(() => {
+        simplify(coords, 0, coords.length, 2e-15);
+    }).not.toThrow();
+});

package/src/{simplify.js → simplify.ts}

@@ -1,7 +1,11 @@
-
-// calculate simplification data using optimized Douglas-Peucker algorithm
-
-export default function simplify(coords, first, last, sqTolerance) {
+/**
+ * calculate simplification data using optimized Douglas-Peucker algorithm
+ * @param coords - flat array of coordinates
+ * @param first - index of the first coordinate in the segment
+ * @param last - index of the last coordinate in the segment
+ * @param sqTolerance - square tolerance value
+ */
+export function simplify(coords: number[], first: number, last: number, sqTolerance: number) {
     let maxSqDist = sqTolerance;
     const mid = first + ((last - first) >> 1);
     let minPosToMid = last - first;
@@ -18,8 +22,10 @@ export default function simplify(coords, first, last, sqTolerance) {
         if (d > maxSqDist) {
             index = i;
             maxSqDist = d;
+            continue;
+        }
 
-        } else if (d === maxSqDist) {
+        if (d === maxSqDist) {
             // a workaround to ensure we choose a pivot close to the middle of the list,
             // reducing recursion depth, for certain degenerate inputs
             // https://github.com/mapbox/geojson-vt/issues/104
@@ -38,14 +44,21 @@ export default function simplify(coords, first, last, sqTolerance) {
     }
 }
 
-// square distance from a point to a segment
-function getSqSegDist(px, py, x, y, bx, by) {
-
+/**
+ * Claculates the square distance from a point to a segment
+ * @param px - x coordinate of the point
+ * @param py - y coordinate of the point
+ * @param x - x coordinate of the first segment endpoint
+ * @param y - y coordinate of the first segment endpoint
+ * @param bx - x coordinate of the second segment endpoint
+ * @param by - y coordinate of the second segment endpoint
+ * @returns square distance from a point to a segment
+ */
+function getSqSegDist(px: number, py: number, x: number, y: number, bx: number, by: number): number {
     let dx = bx - x;
     let dy = by - y;
 
     if (dx !== 0 || dy !== 0) {
-
         const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
 
         if (t > 1) {

package/src/tile.ts

@@ -0,0 +1,166 @@
+import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
+
+export type GeoJSONVTTileFeature = {
+    id? : number | string | undefined;
+    type: 1 | 2 | 3;
+    tags: GeoJSON.GeoJsonProperties | null;
+    geometry: number[] | number[][];
+}
+
+export type GeoJSONVTTile = {
+    features: GeoJSONVTTileFeature[];
+    numPoints: number;
+    numSimplified: number;
+    numFeatures: number;
+    x: number;
+    y: number;
+    z: number;
+    transformed: boolean;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    source: GeoJSONVTFeature[] | null;
+}
+
+/**
+ * Creates a tile object from the given features
+ * @param features - the features to include in the tile
+ * @param z
+ * @param tx
+ * @param ty
+ * @param options - the options object
+ * @returns the created tile
+ */
+export function createTile(features: GeoJSONVTFeature[], z: number, tx: number, ty: number, options: GeoJSONVTOptions): GeoJSONVTTile {
+    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+
+    const tile = {
+        features: [] as GeoJSONVTTileFeature[],
+        numPoints: 0,
+        numSimplified: 0,
+        numFeatures: features.length,
+        source: null as GeoJSONVTFeature[] | null,
+        x: tx,
+        y: ty,
+        z,
+        transformed: false,
+        minX: 2,
+        minY: 1,
+        maxX: -1,
+        maxY: 0
+    };
+
+    for (const feature of features) {
+        addFeature(tile, feature, tolerance, options);
+    }
+
+    return tile;
+}
+
+function addFeature(tile: GeoJSONVTTile, feature: GeoJSONVTFeature, tolerance: number, options: GeoJSONVTOptions) {
+    const simplified: number[] | number[][] = [];
+
+    tile.minX = Math.min(tile.minX, feature.minX);
+    tile.minY = Math.min(tile.minY, feature.minY);
+    tile.maxX = Math.max(tile.maxX, feature.maxX);
+    tile.maxY = Math.max(tile.maxY, feature.maxY);
+
+    switch (feature.type) {
+        case 'Point':
+        case 'MultiPoint':
+            for (let i = 0; i < feature.geometry.length; i += 3) {
+                (simplified as number[]).push(feature.geometry[i] , feature.geometry[i + 1]);
+                tile.numPoints++;
+                tile.numSimplified++;
+            }
+            break;
+
+        case 'LineString':
+            addLine(simplified as number[][], feature.geometry, tile, tolerance, false, false);
+            break;
+
+        case 'MultiLineString':
+        case 'Polygon':
+            for (let i = 0; i < feature.geometry.length; i++) {
+                addLine(simplified as number[][], feature.geometry[i], tile, tolerance, feature.type === 'Polygon', i === 0);
+            }
+            break;
+
+        case 'MultiPolygon':
+            for (let k = 0; k < feature.geometry.length; k++) {
+                const polygon = feature.geometry[k];
+                for (let i = 0; i < polygon.length; i++) {
+                    addLine(simplified as number[][], polygon[i], tile, tolerance, true, i === 0);
+                }
+            }
+            break;
+    }
+    if (!simplified.length) return;
+
+    let tags = feature.tags || null;
+
+    if (feature.type === 'LineString' && 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;
+    }
+
+    const tileFeature: GeoJSONVTTileFeature = {
+        geometry: simplified,
+        type: feature.type === 'Polygon' || feature.type === 'MultiPolygon' ? 3 :
+        (feature.type === 'LineString' || feature.type === 'MultiLineString' ? 2 : 1),
+        tags
+    };
+
+    if (feature.id !== null) {
+        tileFeature.id = feature.id;
+    }
+
+    tile.features.push(tileFeature);
+}
+
+function addLine(result: number[][], geom: StartEndSizeArray, tile: GeoJSONVTTile, tolerance: number, isPolygon: boolean, isOuter: boolean) {
+    const sqTolerance = tolerance * tolerance;
+
+    if (tolerance > 0 && (geom.size < (isPolygon ? sqTolerance : tolerance))) {
+        tile.numPoints += geom.length / 3;
+        return;
+    }
+
+    const ring = [];
+
+    for (let i = 0; i < geom.length; i += 3) {
+        if (tolerance === 0 || geom[i + 2] > sqTolerance) {
+            tile.numSimplified++;
+            ring.push(geom[i], geom[i + 1]);
+        }
+        tile.numPoints++;
+    }
+
+    if (isPolygon) rewind(ring, isOuter);
+
+    result.push(ring);
+}
+
+function rewind(ring: number[], clockwise: boolean) {
+    let area = 0;
+
+    for (let i = 0, len = ring.length, j = len - 2; i < len; j = i, i += 2) {
+        area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+    }
+
+    if (area > 0 !== clockwise) return;
+
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+        const x = ring[i];
+        const y = ring[i + 1];
+
+        ring[i] = ring[len - 2 - i];
+        ring[i + 1] = ring[len - 1 - i];
+        ring[len - 2 - i] = x;
+        ring[len - 1 - i] = y;
+    }
+}

package/src/transform.ts

@@ -0,0 +1,55 @@
+import type { GeoJSONVTTile } from "./tile";
+
+export type GeoJSONVTTransformedTile = GeoJSONVTTile & {
+    transformed: true;
+    geometry: [number, number][] | [number, number][][];
+}
+
+/**
+ * Transforms the coordinates of each feature in the given tile from
+ * mercator-projected space into (extent x extent) tile space.
+ * @param tile - the tile to transform, this gets modified in place
+ * @param extent - the tile extent (usually 4096)
+ * @returns the transformed tile
+ */
+export function transformTile(tile: GeoJSONVTTile, extent: number): GeoJSONVTTransformedTile {
+    if (tile.transformed) {
+        return tile as GeoJSONVTTransformedTile;
+    }
+
+    const z2 = 1 << tile.z;
+    const tx = tile.x;
+    const ty = tile.y;
+
+    for (const feature of tile.features) {
+        const geom = feature.geometry;
+        const type = feature.type;
+
+        feature.geometry = [];
+
+        if (type === 1) {
+            for (let j = 0; j < geom.length; j += 2) {
+                (feature.geometry as [number, number][]).push(transformPoint(geom[j] as number, geom[j + 1] as number, extent, z2, tx, ty));
+            }
+            continue;
+        }
+
+        for (const singleGeom of geom as number[][]) {
+            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));
+            }
+            (feature.geometry as unknown as [number, number][][]).push(ring);
+        }
+    }
+    tile.transformed = true;
+
+    return tile as GeoJSONVTTransformedTile;
+}
+
+function transformPoint(x: number, y: number, extent: number, z2: number, tx: number, ty: number): [number, number] {
+    return [
+        Math.round(extent * (x * z2 - tx)),
+        Math.round(extent * (y * z2 - ty))
+    ];
+}