@loaders.gl/mvt 4.3.0-alpha.1 → 4.3.0-alpha.3

package/dist/lib/vector-tiler/features/convert-feature.js

@@ -0,0 +1,140 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+import { createProtoFeature } from "./proto-feature.js";
+import { simplifyPath } from "./simplify-path.js";
+/**
+ * converts a GeoJSON feature into an intermediate projected JSON vector format
+ * with simplification data
+ */
+export function convertFeaturesToProtoFeature(data, options) {
+    const protoFeatures = [];
+    switch (data.type) {
+        case 'FeatureCollection':
+            let i = 0;
+            for (const feature of data.features) {
+                protoFeatures.push(convertFeature(feature, options, i++));
+            }
+            break;
+        case 'Feature':
+            protoFeatures.push(convertFeature(data, options));
+            break;
+        default:
+            // single geometry or a geometry collection
+            protoFeatures.push(convertFeature({ geometry: data }, options));
+    }
+    return protoFeatures;
+}
+/**
+ * converts a GeoJSON feature into an intermediate projected JSON vector format
+ * with simplification data
+ */
+function convertFeature(geojson, options, index) {
+    // GeoJSON geometries can be null, but no vector tile will include them.
+    if (!geojson.geometry) {
+        return;
+    }
+    const coords = geojson.geometry.coordinates;
+    const type = geojson.geometry.type;
+    const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+    let geometry = [];
+    let id = geojson.id;
+    if (options.promoteId) {
+        id = geojson.properties[options.promoteId];
+    }
+    else if (options.generateId) {
+        id = index || 0;
+    }
+    switch (type) {
+        case 'Point':
+            convertPoint(coords, geometry);
+            break;
+        case 'MultiPoint':
+            for (const p of coords) {
+                convertPoint(p, geometry);
+            }
+            break;
+        case 'LineString':
+            convertLine(coords, geometry, tolerance, false);
+            break;
+        case 'MultiLineString':
+            if (options.lineMetrics) {
+                // explode into linestrings to be able to track metrics
+                for (const line of coords) {
+                    geometry = [];
+                    convertLine(line, geometry, tolerance, false);
+                    features.push(createProtoFeature(id, 'LineString', geometry, geojson.properties));
+                }
+                return;
+                convertLines(coords, geometry, tolerance, false);
+            }
+            break;
+        case 'Polygon':
+            convertLines(coords, geometry, tolerance, true);
+            break;
+        case 'MultiPolygon':
+            for (const polygon of coords) {
+                const newPolygon = [];
+                convertLines(polygon, newPolygon, tolerance, true);
+                geometry.push(newPolygon);
+            }
+            break;
+        case 'GeometryCollection':
+            for (const singleGeometry of geojson.geometry.geometries) {
+                convertFeature(features, {
+                    id,
+                    geometry: singleGeometry,
+                    properties: geojson.properties
+                }, options, index);
+            }
+            break;
+        default:
+            throw new Error('Input data is not a valid GeoJSON object.');
+    }
+    return createProtoFeature(id, type, geometry, geojson.properties);
+}
+function convertPoint(coords, out) {
+    out.push(projectX(coords[0]), projectY(coords[1]), 0);
+}
+function convertLine(ring, out, tolerance, isPolygon) {
+    let x0, y0;
+    let size = 0;
+    for (let j = 0; j < ring.length; j++) {
+        const x = projectX(ring[j][0]);
+        const y = projectY(ring[j][1]);
+        out.push(x, y, 0);
+        if (j > 0) {
+            if (isPolygon) {
+                size += (x0 * y - x * y0) / 2; // area
+            }
+            else {
+                size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)); // length
+            }
+        }
+        x0 = x;
+        y0 = y;
+    }
+    const last = out.length - 3;
+    out[2] = 1;
+    simplifyPath(out, 0, last, tolerance);
+    out[last + 2] = 1;
+    out.size = Math.abs(size);
+    out.start = 0;
+    out.end = out.size;
+}
+function convertLines(rings, out, tolerance, isPolygon) {
+    for (let i = 0; i < rings.length; i++) {
+        const geom = [];
+        convertLine(rings[i], geom, tolerance, isPolygon);
+        out.push(geom);
+    }
+}
+function projectX(x) {
+    return x / 360 + 0.5;
+}
+function projectY(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/dist/lib/vector-tiler/features/proto-feature.d.ts

@@ -0,0 +1,30 @@
+export type ProtoFeature = {
+    type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
+    simplifiedType: 1 | 2 | 3;
+    geometry: any[];
+    id?: string;
+    tags?: Record<string, unknown>;
+    /** spatial extents */
+    minX: number;
+    /** spatial extents */
+    maxX: number;
+    /** spatial extents */
+    minY: number;
+    /** spatial extents */
+    maxY: number;
+};
+export type GeoJSONTileGeometry = GeoJSONTilePointGeometry | GeoJSONTileLineGeometry | GeoJSONTilePolygonGeometry;
+export type GeoJSONTilePointGeometry = {
+    simplifiedType: 1;
+    geometry: number[];
+};
+export type GeoJSONTileLineGeometry = {
+    simplifiedType: 1;
+    geometry: number[][];
+};
+export type GeoJSONTilePolygonGeometry = {
+    simplifiedType: 1;
+    geometry: number[][][];
+};
+export declare function createProtoFeature(id: any, type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon', geometry: any[], tags: any): ProtoFeature;
+//# sourceMappingURL=proto-feature.d.ts.map

package/dist/lib/vector-tiler/features/proto-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proto-feature.d.ts","sourceRoot":"","sources":["../../../../src/lib/vector-tiler/features/proto-feature.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,iBAAiB,GAAG,SAAS,GAAG,cAAc,CAAC;IAC7F,cAAc,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,QAAQ,EAAE,GAAG,EAAE,CAAC;IAGhB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE/B,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAC3B,wBAAwB,GACxB,uBAAuB,GACvB,0BAA0B,CAAC;AAE/B,MAAM,MAAM,wBAAwB,GAAG;IACrC,cAAc,EAAE,CAAC,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,cAAc,EAAE,CAAC,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,cAAc,EAAE,CAAC,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;CACxB,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,GAAG,EACP,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,iBAAiB,GAAG,SAAS,GAAG,cAAc,EAC5F,QAAQ,EAAE,GAAG,EAAE,EACf,IAAI,KAAA,GACH,YAAY,CA6Cd"}

package/dist/lib/vector-tiler/features/proto-feature.js

@@ -0,0 +1,52 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+export function createProtoFeature(id, type, geometry, tags) {
+    const feature = {
+        // eslint-disable-next-line
+        id: id == null ? null : id,
+        type,
+        simplifiedType: undefined, // TODO
+        geometry,
+        tags,
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    };
+    // TODO break out into separate function
+    switch (type) {
+        case 'Point':
+        case 'MultiPoint':
+        case 'LineString':
+            calcLineBBox(feature, geometry);
+            break;
+        case 'MultiLineString':
+            for (const line of geometry) {
+                calcLineBBox(feature, line);
+            }
+            break;
+        case 'Polygon':
+            // the outer ring (ie [0]) contains all inner rings
+            calcLineBBox(feature, geometry[0]);
+            break;
+        case 'MultiPolygon':
+            for (const polygon of geometry) {
+                // the outer ring (ie [0]) contains all inner rings
+                calcLineBBox(feature, polygon[0]);
+            }
+            break;
+        default:
+            throw new Error(String(type));
+    }
+    return feature;
+}
+function calcLineBBox(feature, geometry) {
+    for (let i = 0; i < geometry.length; i += 3) {
+        feature.minX = Math.min(feature.minX, geometry[i]);
+        feature.minY = Math.min(feature.minY, geometry[i + 1]);
+        feature.maxX = Math.max(feature.maxX, geometry[i]);
+        feature.maxY = Math.max(feature.maxY, geometry[i + 1]);
+    }
+}

package/dist/lib/{geojsonvt/simplify.d.ts → vector-tiler/features/simplify-path.d.ts}

@@ -6,5 +6,5 @@
  * @param last last coord to simplify
  * @param sqTolerance tolerance (square distance)
  */
-export declare function simplify(coords: number[], first: number, last: number, sqTolerance: number): void;
-//# sourceMappingURL=simplify.d.ts.map
+export declare function simplifyPath(coords: number[], first: number, last: number, sqTolerance: number): void;
+//# sourceMappingURL=simplify-path.d.ts.map

package/dist/lib/vector-tiler/features/simplify-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify-path.d.ts","sourceRoot":"","sources":["../../../../src/lib/vector-tiler/features/simplify-path.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,IAAI,CAkCN"}

package/dist/lib/{geojsonvt/simplify.js → vector-tiler/features/simplify-path.js}

@@ -10,7 +10,7 @@
  * @param last last coord to simplify
  * @param sqTolerance tolerance (square distance)
  */
-export function simplify(coords, first, last, sqTolerance) {
+export function simplifyPath(coords, first, last, sqTolerance) {
     let maxSqDist = sqTolerance;
     const mid = (last - first) >> 1;
     let minPosToMid = last - first;
@@ -38,10 +38,10 @@ export function simplify(coords, first, last, sqTolerance) {
     }
     if (maxSqDist > sqTolerance) {
         if (index - first > 3)
-            simplify(coords, first, index, sqTolerance);
+            simplifyPath(coords, first, index, sqTolerance);
         coords[index + 2] = maxSqDist;
         if (last - index > 3)
-            simplify(coords, index, last, sqTolerance);
+            simplifyPath(coords, index, last, sqTolerance);
     }
 }
 /** square distance from a point to a segment */

package/dist/lib/{geojsonvt/wrap.d.ts → vector-tiler/features/wrap-features.d.ts}

@@ -1,17 +1,17 @@
-import type { GeoJSONTileFeature } from "./tile.js";
+import type { ProtoFeature } from "./proto-feature.js";
 /**
  * Options for wrap()
  */
-export type WrapOptions = {
+export type WrapFeaturesOptions = {
     buffer: number /** number of pixels of buffer for the tile */;
     extent: number /** extent of each tile */;
     lineMetrics: boolean;
 };
 /**
  * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
- * @param features list of features to be wrapped
+ * @param list of features to be wrapped
  * @param options buffer and extent
  * @returns
  */
-export declare function wrap(features: GeoJSONTileFeature[], options: WrapOptions): GeoJSONTileFeature[];
-//# sourceMappingURL=wrap.d.ts.map
+export declare function wrapFeatures(features: ProtoFeature[], options: WrapFeaturesOptions): ProtoFeature[];
+//# sourceMappingURL=wrap-features.d.ts.map

package/dist/lib/vector-tiler/features/wrap-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-features.d.ts","sourceRoot":"","sources":["../../../../src/lib/vector-tiler/features/wrap-features.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,2BAAwB;AAIlD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC,8CAA8C,CAAC;IAC9D,MAAM,EAAE,MAAM,CAAC,0BAA0B,CAAC;IAC1C,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,YAAY,EAAE,EACxB,OAAO,EAAE,mBAAmB,GAC3B,YAAY,EAAE,CAkBhB"}

package/dist/lib/{geojsonvt/wrap.js → vector-tiler/features/wrap-features.js}

@@ -2,21 +2,21 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 // Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
-import { clip } from "./clip.js";
-import { createFeature } from "./feature.js";
+import { createProtoFeature } from "./proto-feature.js";
+import { clipFeatures } from "./clip-features.js";
 /**
  * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
- * @param features list of features to be wrapped
+ * @param list of features to be wrapped
  * @param options buffer and extent
  * @returns
  */
-export function wrap(features, options) {
+export function wrapFeatures(features, options) {
     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 = clipFeatures(features, 1, -1 - buffer, buffer, 0, -1, 2, options); // left world copy
+    const right = clipFeatures(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
     if (left || right) {
-        merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
+        merged = clipFeatures(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
         if (left) {
             merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
         }
@@ -38,27 +38,34 @@ function shiftFeatureCoords(features, offset) {
         const feature = features[i];
         const type = feature.type;
         let newGeometry;
-        if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
-            newGeometry = shiftCoords(feature.geometry, offset);
-        }
-        else if (type === 'MultiLineString' || type === 'Polygon') {
-            newGeometry = [];
-            for (const line of feature.geometry) {
-                newGeometry.push(shiftCoords(line, offset));
-            }
-        }
-        else if (type === 'MultiPolygon') {
-            newGeometry = [];
-            for (const polygon of feature.geometry) {
-                const newPolygon = [];
-                for (const line of polygon) {
-                    // @ts-expect-error TODO
-                    newPolygon.push(shiftCoords(line, offset));
+        switch (type) {
+            case 'Point':
+            case 'MultiPoint':
+            case 'LineString':
+                newGeometry = shiftCoords(feature.geometry, offset);
+                break;
+            case 'MultiLineString':
+            case 'Polygon':
+                newGeometry = [];
+                for (const line of feature.geometry) {
+                    newGeometry.push(shiftCoords(line, offset));
+                }
+                break;
+            case 'MultiPolygon':
+                newGeometry = [];
+                for (const polygon of feature.geometry) {
+                    const newPolygon = [];
+                    for (const line of polygon) {
+                        // @ts-expect-error TODO
+                        newPolygon.push(shiftCoords(line, offset));
+                    }
+                    newGeometry.push(newPolygon);
                 }
-                newGeometry.push(newPolygon);
-            }
+                break;
+            default:
+                throw new Error(String(type));
         }
-        newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
+        newFeatures.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
     }
     return newFeatures;
 }

package/dist/lib/vector-tiler/proto-tile.d.ts

@@ -0,0 +1,40 @@
+import type { ProtoFeature } from "./features/proto-feature.js";
+export type ProtoTile = {
+    /** Processed features */
+    protoFeatures: ProtoFeature[];
+    /** if we slice further down, no need to keep source geometry */
+    sourceFeatures: ProtoFeature[] | null;
+    /** Properties */
+    tags?: Record<string, string>;
+    /** tile x coordinate */
+    x: number;
+    /** tile y coordinate */
+    y: number;
+    /** tile z coordinate */
+    z: number;
+    /** spatial extent */
+    minX: number;
+    /** spatial extent */
+    maxX: number;
+    /** spatial extent */
+    minY: number;
+    /** spatial extent */
+    maxY: number;
+    /** Whether this tile has been transformed */
+    transformed: boolean;
+    numPoints: number;
+    numSimplified: number;
+    /** Number of features in this tile */
+    numFeatures: number;
+};
+export type CreateTileOptions = {
+    maxZoom?: number;
+    tolerance: number;
+    extent: number;
+    lineMetrics: boolean;
+};
+/**
+ * Create a tile from features and tile index
+ */
+export declare function createProtoTile(features: ProtoFeature[], z: any, tx: any, ty: any, options: CreateTileOptions): ProtoTile;
+//# sourceMappingURL=proto-tile.d.ts.map

package/dist/lib/vector-tiler/proto-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proto-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/vector-tiler/proto-tile.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,oCAAiC;AAE3D,MAAM,MAAM,SAAS,GAAG;IACtB,yBAAyB;IACzB,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,gEAAgE;IAChE,cAAc,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IAEtC,iBAAiB;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE9B,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IAEb,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,YAAY,EAAE,EACxB,CAAC,KAAA,EACD,EAAE,KAAA,EACF,EAAE,KAAA,EACF,OAAO,EAAE,iBAAiB,GACzB,SAAS,CAqBX"}

package/dist/lib/vector-tiler/proto-tile.js

@@ -0,0 +1,138 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+/**
+ * Create a tile from features and tile index
+ */
+export function createProtoTile(features, z, tx, ty, options) {
+    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+    const tile = {
+        protoFeatures: [],
+        sourceFeatures: null,
+        numPoints: 0,
+        numSimplified: 0,
+        numFeatures: features.length,
+        x: tx,
+        y: ty,
+        z,
+        transformed: false,
+        minX: 2,
+        minY: 1,
+        maxX: -1,
+        maxY: 0
+    };
+    for (const feature of features) {
+        addProtoFeature(tile, feature, tolerance, options);
+    }
+    return tile;
+}
+// eslint-disable-next-line complexity, max-statements
+function addProtoFeature(tile, feature, tolerance, options) {
+    const geometry = feature.geometry;
+    const type = feature.type;
+    const simplifiedGeometry = [];
+    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);
+    let simplifiedType;
+    switch (type) {
+        case 'Point':
+        case 'MultiPoint':
+            simplifiedType = 1;
+            for (let i = 0; i < geometry.length; i += 3) {
+                simplifiedGeometry.push(geometry[i], geometry[i + 1]);
+                tile.numPoints++;
+                tile.numSimplified++;
+            }
+            break;
+        case 'LineString':
+            simplifiedType = 2;
+            addProtoLine(simplifiedGeometry, geometry, tile, tolerance, false, false);
+            break;
+        case 'MultiLineString':
+            simplifiedType = 2;
+            for (let i = 0; i < geometry.length; i++) {
+                addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, false, i === 0);
+            }
+            break;
+        case 'Polygon':
+            simplifiedType = 3;
+            for (let i = 0; i < geometry.length; i++) {
+                addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, true, i === 0);
+            }
+            break;
+        case 'MultiPolygon':
+            simplifiedType = 3;
+            for (let k = 0; k < geometry.length; k++) {
+                const polygon = geometry[k];
+                for (let i = 0; i < polygon.length; i++) {
+                    addProtoLine(simplifiedGeometry, polygon[i], tile, tolerance, true, i === 0);
+                }
+            }
+            break;
+        default:
+            throw new Error(`Unknown geometry type: ${type}`);
+    }
+    if (simplifiedGeometry.length) {
+        let tags = feature.tags || null;
+        if (type === 'LineString' && options.lineMetrics) {
+            tags = {};
+            for (const key in feature.tags) {
+                tags[key] = feature.tags[key];
+            }
+            // @ts-expect-error adding fields to arrays
+            // eslint-disable-next-line camelcase
+            tags.mapbox_clip_start = geometry.start / geometry.size;
+            // @ts-expect-error adding fields to arrays
+            // eslint-disable-next-line camelcase
+            tags.mapbox_clip_end = geometry.end / geometry.size;
+        }
+        const tileFeature = {
+            geometry: simplifiedGeometry,
+            simplifiedType,
+            // @ts-expect-error
+            tags
+        };
+        if (feature.id !== null) {
+            tileFeature.id = feature.id;
+        }
+        tile.protoFeatures.push(tileFeature);
+    }
+}
+// eslint-disable-next-line max-params, max-statements
+function addProtoLine(result, geometry, tile, tolerance, isPolygon, isOuter) {
+    const sqTolerance = tolerance * tolerance;
+    if (tolerance > 0 && geometry.size < (isPolygon ? sqTolerance : tolerance)) {
+        tile.numPoints += geometry.length / 3;
+        return;
+    }
+    const ring = [];
+    for (let i = 0; i < geometry.length; i += 3) {
+        if (tolerance === 0 || geometry[i + 2] > sqTolerance) {
+            tile.numSimplified++;
+            ring.push(geometry[i], geometry[i + 1]);
+        }
+        tile.numPoints++;
+    }
+    if (isPolygon)
+        rewind(ring, isOuter);
+    result.push(ring);
+}
+function rewind(ring, clockwise) {
+    let area = 0;
+    for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+        area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+    }
+    if (area > 0 === clockwise) {
+        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/dist/lib/vector-tiler/tile-to-geojson.d.ts

@@ -0,0 +1,12 @@
+import { ProtoTile } from "./proto-tile.js";
+import { GeoJSONTable } from '@loaders.gl/schema';
+export declare function convertTileToGeoJSON(protoTile: ProtoTile, props: {
+    coordinates: 'EPSG:4326' | 'wgs84' | 'local';
+    tileIndex: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    extent: number;
+}): GeoJSONTable | null;
+//# sourceMappingURL=tile-to-geojson.d.ts.map

package/dist/lib/vector-tiler/tile-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/vector-tiler/tile-to-geojson.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAU,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAMzD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE;IACL,WAAW,EAAE,WAAW,GAAG,OAAO,GAAG,OAAO,CAAC;IAC7C,SAAS,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;CAChB,GACA,YAAY,GAAG,IAAI,CAqFrB"}

package/dist/lib/vector-tiler/tile-to-geojson.js

@@ -0,0 +1,81 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+import { projectToLngLat } from "../utils/geometry-utils.js";
+import { convertToLocalCoordinates } from "../utils/geometry-utils.js";
+// eslint-disable-next-line max-statements, complexity
+export function convertTileToGeoJSON(protoTile, props) {
+    const features = [];
+    for (const rawFeature of protoTile.protoFeatures) {
+        if (!rawFeature || !rawFeature.geometry) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        let type;
+        let coordinates;
+        // raw geometry
+        switch (rawFeature.simplifiedType) {
+            case 1:
+                if (rawFeature.geometry.length === 1) {
+                    type = 'Point';
+                    coordinates = rawFeature.geometry[0];
+                }
+                else {
+                    type = 'MultiPoint';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            case 2:
+                if (rawFeature.geometry.length === 1) {
+                    type = 'LineString';
+                    coordinates = rawFeature.geometry[0];
+                }
+                else {
+                    type = 'MultiLineString';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            case 3:
+                if (rawFeature.geometry.length > 1) {
+                    type = 'MultiPolygon';
+                    coordinates = [rawFeature.geometry];
+                }
+                else {
+                    type = 'Polygon';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            default:
+                throw new Error(`${rawFeature.simplifiedType}is not a valid simplified type`);
+        }
+        switch (props.coordinates) {
+            case 'EPSG:4326':
+            case 'wgs84':
+                projectToLngLat(coordinates, props.tileIndex, props.extent);
+                break;
+            default:
+                convertToLocalCoordinates(coordinates, props.extent);
+                break;
+        }
+        const feature = {
+            type: 'Feature',
+            geometry: {
+                type,
+                coordinates
+            },
+            properties: rawFeature.tags || {},
+            id: rawFeature.id
+        };
+        features.push(feature);
+    }
+    if (features.length === 0) {
+        return null;
+    }
+    const table = {
+        shape: 'geojson-table',
+        type: 'FeatureCollection',
+        features
+    };
+    return table;
+}

package/dist/lib/vector-tiler/transform-tile.d.ts

@@ -0,0 +1,7 @@
+import type { ProtoTile } from "./proto-tile.js";
+/**
+ * Transforms the coordinates of each protoFeature in the given protoTile from
+ * mercator-projected space into (extent x extent) protoTile space.
+ */
+export declare function transformTile(protoTile: ProtoTile, extent: number): ProtoTile;
+//# sourceMappingURL=transform-tile.d.ts.map

package/dist/lib/vector-tiler/transform-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/vector-tiler/transform-tile.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,SAAS,EAAC,wBAAqB;AAE5C;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAiC7E"}