@maplibre/geojson-vt 5.0.2 → 5.0.4

package/dist/wrap.d.ts

@@ -0,0 +1,3 @@
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions } from './definitions';
+export declare function wrap(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): GeoJSONVTInternalFeature[];
+//# sourceMappingURL=wrap.d.ts.map

package/dist/wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../src/wrap.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAqB,MAAM,eAAe,CAAC;AAGnG,wBAAgB,IAAI,CAAC,QAAQ,EAAE,wBAAwB,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,wBAAwB,EAAE,CAehH"}

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@maplibre/geojson-vt",
-  "version": "5.0.2",
+  "version": "5.0.4",
   "description": "Slice GeoJSON data into vector tiles efficiently",
   "type": "module",
-  "exports": "./src/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/geojson-vt.mjs",
+      "default": "./dist/geojson-vt.js"
+    }
+  },
   "sideEffects": false,
   "keywords": [
     "spatial",
@@ -13,7 +19,7 @@
   ],
   "author": "Vladimir Agafonkin",
   "module": "dist/geojson-vt.mjs",
-  "main": "dist/geojson-vt-dev.js",
+  "main": "dist/geojson-vt.js",
   "typings": "dist/index.d.ts",
   "jsdelivr": "dist/geojson-vt.js",
   "unpkg": "dist/geojson-vt.js",

package/src/clip.ts

@@ -1,6 +1,6 @@
 
 import {createFeature} from './feature';
-import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 
 /* clip features between two vertical or horizontal axis-parallel lines:
  *     |        |
@@ -12,7 +12,7 @@ import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './de
  * axis: 0 for x, 1 for y
  * minAll and maxAll: minimum and maximum coordinate value for all features
  */
-export function clip(features: GeoJSONVTFeature[], scale: number, k1: number, k2: number, axis: number, minAll: number, maxAll: number, options: GeoJSONVTOptions): GeoJSONVTFeature[] | null {
+export function clip(features: GeoJSONVTInternalFeature[], scale: number, k1: number, k2: number, axis: number, minAll: number, maxAll: number, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] | null {
     k1 /= scale;
     k2 /= scale;
 
@@ -24,7 +24,7 @@ export function clip(features: GeoJSONVTFeature[], scale: number, k1: number, k2
         return null;
     }
 
-    const clipped: GeoJSONVTFeature[] = [];
+    const clipped: GeoJSONVTInternalFeature[] = [];
 
     for (const feature of features) {
         const min = axis === 0 ? feature.minX : feature.minY;

package/src/convert.ts

@@ -1,7 +1,7 @@
 
 import {simplify} from './simplify';
 import {createFeature} from './feature';
-import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 
 /**
  * converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
@@ -9,8 +9,8 @@ import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './de
  * @param options
  * @returns
  */
-export function convert(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJSONVTFeature[] {
-    const features: GeoJSONVTFeature[] = [];
+export function convert(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
+    const features: GeoJSONVTInternalFeature[] = [];
 
     switch (data.type) {
         case 'FeatureCollection':
@@ -28,7 +28,7 @@ export function convert(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJS
     return features;
 }
 
-function convertFeature(features: GeoJSONVTFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number) {
+function convertFeature(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number) {
     if (!geojson.geometry) return;
 
     if (geojson.geometry.type === 'GeometryCollection') {

package/src/definitions.ts

@@ -78,7 +78,7 @@ export type GeometryTypeMap = {
 
 export type GeometryType = "Point" | "MultiPoint" | "LineString" | "MultiLineString" | "Polygon" | "MultiPolygon";
 
-export type GeoJSONVTFeature = {
+export type GeoJSONVTInternalFeature = {
     [K in GeometryType]: PartialGeoJSONVTFeature & {
         type: K;
         geometry: GeometryTypeMap[K];

package/src/difference.ts

@@ -1,6 +1,6 @@
 import {convert} from './convert';
 import {wrap} from './wrap';
-import type { GeoJSONVTFeature, GeoJSONVTOptions } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions } from './definitions';
 
 export type GeoJSONVTSourceDiff = {
     /**
@@ -61,13 +61,13 @@ type HashedGeoJSONVTSourceDiff = {
  * @param options 
  * @returns 
  */
-export function applySourceDiff(source: GeoJSONVTFeature[], dataDiff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions) {
+export function applySourceDiff(source: GeoJSONVTInternalFeature[], dataDiff: GeoJSONVTSourceDiff, options: GeoJSONVTOptions) {
 
     // convert diff to sets/maps for o(1) lookups
     const diff = diffToHashed(dataDiff);
 
     // collection for features that will be affected by this update
-    let affected: GeoJSONVTFeature[] = [];
+    let affected: GeoJSONVTInternalFeature[] = [];
 
     // full removal - clear everything before applying diff
     if (diff.removeAll) {
@@ -136,7 +136,7 @@ export function applySourceDiff(source: GeoJSONVTFeature[], dataDiff: GeoJSONVTS
 }
 
 // return an updated geojsonvt simplified feature
-function getUpdatedFeature(vtFeature: GeoJSONVTFeature, update: GeoJSONVTFeatureDiff, options: GeoJSONVTOptions): GeoJSONVTFeature | null {
+function getUpdatedFeature(vtFeature: GeoJSONVTInternalFeature, update: GeoJSONVTFeatureDiff, options: GeoJSONVTOptions): GeoJSONVTInternalFeature | null {
     const changeGeometry = !!update.newGeometry;
 
     const changeProps =

package/src/feature.ts

@@ -1,4 +1,4 @@
-import type { GeoJSONVTFeature, GeometryType, GeometryTypeMap } from "./definitions";
+import type { GeoJSONVTInternalFeature, GeometryType, GeometryTypeMap } from "./definitions";
 
 export type SupportedGeometries = GeoJSON.Point | GeoJSON.MultiPoint | GeoJSON.LineString | GeoJSON.MultiLineString | GeoJSON.Polygon | GeoJSON.MultiPolygon;
 
@@ -10,7 +10,7 @@ export type SupportedGeometries = GeoJSON.Point | GeoJSON.MultiPoint | GeoJSON.L
  * @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 {
+export function createFeature<T extends GeometryType>(id: number | string | undefined, type: T, geom: GeometryTypeMap[T], tags: GeoJSON.GeoJsonProperties): GeoJSONVTInternalFeature {
     // This is mostly for TypeScript type narrowing
     const data = { type, geom } as { [K in GeometryType]: { type: K, geom: GeometryTypeMap[K] } }[GeometryType];
 
@@ -23,7 +23,7 @@ export function createFeature<T extends GeometryType>(id: number | string | unde
         minY: Infinity,
         maxX: -Infinity,
         maxY: -Infinity
-    } as GeoJSONVTFeature;
+    } as GeoJSONVTInternalFeature;
 
     switch (data.type) {
         case 'Point':
@@ -54,7 +54,7 @@ export function createFeature<T extends GeometryType>(id: number | string | unde
     return feature;
 }
 
-function calcLineBBox(feature: GeoJSONVTFeature, geom: number[]) {
+function calcLineBBox(feature: GeoJSONVTInternalFeature, 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]);

package/src/index.ts

@@ -2,10 +2,10 @@
 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 {transformTile, type GeoJSONVTFeature, type GeoJSONVTFeatureNonPoint, type GeoJSONVTFeaturePoint, type GeoJSONVTTile} from './transform';
+import {createTile, type GeoJSONVTInternalTile, type GeoJSONVTInternalTileFeature, type GeoJSONVTInternalTileFeaturePoint, type GeoJSONVTInternalTileFeaturNonPoint} from './tile';
 import {applySourceDiff, type GeoJSONVTFeatureDiff, type GeoJSONVTSourceDiff} from './difference';
-import type { GeoJSONVTFeature, GeoJSONVTOptions, GeometryType, GeometryTypeMap, PartialGeoJSONVTFeature, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, GeometryType, GeometryTypeMap, PartialGeoJSONVTFeature, StartEndSizeArray } from './definitions';
 
 const defaultOptions: GeoJSONVTOptions = {
     maxZoom: 14,
@@ -27,13 +27,13 @@ const defaultOptions: GeoJSONVTOptions = {
 class GeoJSONVT {
     private options: GeoJSONVTOptions;
     /** @internal */
-    public tiles: {[key: string]: GeoJSONVTTile};
+    public tiles: {[key: string]: GeoJSONVTInternalTile};
     private tileCoords: {z: number, x: number, y: number, id: number}[];
     /** @internal */
     public stats: {[key: string]: number} = {};
     /** @internal */
     public total: number = 0;
-    private source?: GeoJSONVTFeature[];
+    private source?: GeoJSONVTInternalFeature[];
 
     constructor(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions) {
         options = this.options = Object.assign({}, defaultOptions, options);
@@ -96,7 +96,7 @@ class GeoJSONVT {
      * @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) {
+    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;
@@ -107,7 +107,7 @@ class GeoJSONVT {
             y = stack.pop() as number;
             x = stack.pop() as number;
             z = stack.pop() as number;
-            features = stack.pop() as GeoJSONVTFeature[];
+            features = stack.pop() as GeoJSONVTInternalFeature[];
 
             const z2 = 1 << z;
             const id = toID(z, x, y);
@@ -195,7 +195,7 @@ class GeoJSONVT {
      * @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 {
+    getTile(z: number | string, x: number | string, y: number | string): GeoJSONVTTile | null {
         z = +z;
         x = +x;
         y = +y;
@@ -247,7 +247,7 @@ class GeoJSONVT {
      * @internal
      * @param features 
      */
-    invalidateTiles(features: GeoJSONVTFeature[]) {
+    invalidateTiles(features: GeoJSONVTInternalFeature[]) {
         const options = this.options;
         const {debug} = options;
 
@@ -374,16 +374,21 @@ export default function geojsonvt(data: GeoJSON.GeoJSON, options?: GeoJSONVTOpti
 }
 
 export type { 
-    GeoJSONVTFeature, 
+    GeoJSONVTInternalFeature, 
     GeoJSONVTOptions, 
-    GeoJSONVTTile, 
-    GeoJSONVTTileFeature, 
+    GeoJSONVTInternalTile, 
+    GeoJSONVTInternalTileFeature, 
     GeometryType,
     PartialGeoJSONVTFeature,
     GeoJSONVT,
     GeometryTypeMap,
     StartEndSizeArray,
-    GeoJSONVTTransformedTile,
+    GeoJSONVTTile,
+    GeoJSONVTFeature,
     GeoJSONVTSourceDiff,
-    GeoJSONVTFeatureDiff
+    GeoJSONVTFeatureDiff,
+    GeoJSONVTFeaturePoint,
+    GeoJSONVTFeatureNonPoint,
+    GeoJSONVTInternalTileFeaturePoint,
+    GeoJSONVTInternalTileFeaturNonPoint
 };

package/src/tile.ts

@@ -1,14 +1,22 @@
-import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from "./definitions";
 
-export type GeoJSONVTTileFeature = {
+export type GeoJSONVTInternalTileFeaturePoint = {
     id? : number | string | undefined;
-    type: 1 | 2 | 3;
+    type: 1;
     tags: GeoJSON.GeoJsonProperties | null;
-    geometry: number[] | number[][];
+    geometry: number[];
 }
 
-export type GeoJSONVTTile = {
-    features: GeoJSONVTTileFeature[];
+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;
@@ -20,7 +28,7 @@ export type GeoJSONVTTile = {
     minY: number;
     maxX: number;
     maxY: number;
-    source: GeoJSONVTFeature[] | null;
+    source: GeoJSONVTInternalFeature[] | null;
 }
 
 /**
@@ -32,15 +40,15 @@ export type GeoJSONVTTile = {
  * @param options - the options object
  * @returns the created tile
  */
-export function createTile(features: GeoJSONVTFeature[], z: number, tx: number, ty: number, options: GeoJSONVTOptions): GeoJSONVTTile {
+export function createTile(features: GeoJSONVTInternalFeature[], z: number, tx: number, ty: number, options: GeoJSONVTOptions): GeoJSONVTInternalTile {
     const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
 
     const tile = {
-        features: [] as GeoJSONVTTileFeature[],
+        features: [] as GeoJSONVTInternalTileFeature[],
         numPoints: 0,
         numSimplified: 0,
         numFeatures: features.length,
-        source: null as GeoJSONVTFeature[] | null,
+        source: null as GeoJSONVTInternalFeature[] | null,
         x: tx,
         y: ty,
         z,
@@ -58,62 +66,82 @@ export function createTile(features: GeoJSONVTFeature[], z: number, tx: number,
     return tile;
 }
 
-function addFeature(tile: GeoJSONVTTile, feature: GeoJSONVTFeature, tolerance: number, options: GeoJSONVTOptions) {
-    const simplified: number[] | number[][] = [];
-
+function addFeature(tile: GeoJSONVTInternalTile, feature: GeoJSONVTInternalFeature, tolerance: number, options: GeoJSONVTOptions) {
     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 tags = feature.tags || null;
+
+    let tileFeature: GeoJSONVTInternalTileFeature;
+
     switch (feature.type) {
         case 'Point':
-        case 'MultiPoint':
+        case 'MultiPoint': {
+            const geometry: number[] = [];
             for (let i = 0; i < feature.geometry.length; i += 3) {
-                (simplified as number[]).push(feature.geometry[i] , feature.geometry[i + 1]);
+                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':
-            addLine(simplified as number[][], feature.geometry, tile, tolerance, false, false);
+        }
+        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 'MultiLineString':
-        case 'Polygon':
+        case 'Polygon': {
+            const geometry: number[][] = [];
             for (let i = 0; i < feature.geometry.length; i++) {
-                addLine(simplified as number[][], feature.geometry[i], tile, tolerance, feature.type === 'Polygon', i === 0);
+                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':
+        }
+        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(simplified as number[][], polygon[i], tile, tolerance, true, i === 0);
+                    addLine(geometry, polygon[i], tile, tolerance, true, i === 0);
                 }
             }
+            if (!geometry.length) return;
+            tileFeature = {
+                type: 3,
+                tags: tags,
+                geometry: geometry
+            }
             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;
@@ -122,7 +150,7 @@ function addFeature(tile: GeoJSONVTTile, feature: GeoJSONVTFeature, tolerance: n
     tile.features.push(tileFeature);
 }
 
-function addLine(result: number[][], geom: StartEndSizeArray, tile: GeoJSONVTTile, tolerance: number, isPolygon: boolean, isOuter: boolean) {
+function addLine(result: number[][], geom: StartEndSizeArray, tile: GeoJSONVTInternalTile, tolerance: number, isPolygon: boolean, isOuter: boolean) {
     const sqTolerance = tolerance * tolerance;
 
     if (tolerance > 0 && (geom.size < (isPolygon ? sqTolerance : tolerance))) {

package/src/transform.ts

@@ -1,8 +1,24 @@
-import type { GeoJSONVTTile } from "./tile";
+import type { GeoJSONVTInternalTile } from "./tile";
 
-export type GeoJSONVTTransformedTile = GeoJSONVTTile & {
+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;
-    geometry: [number, number][] | [number, number][][];
+    features: GeoJSONVTFeature[]
 }
 
 /**
@@ -12,9 +28,9 @@ export type GeoJSONVTTransformedTile = GeoJSONVTTile & {
  * @param extent - the tile extent (usually 4096)
  * @returns the transformed tile
  */
-export function transformTile(tile: GeoJSONVTTile, extent: number): GeoJSONVTTransformedTile {
+export function transformTile(tile: GeoJSONVTInternalTile, extent: number): GeoJSONVTTile {
     if (tile.transformed) {
-        return tile as GeoJSONVTTransformedTile;
+        return tile as GeoJSONVTTile;
     }
 
     const z2 = 1 << tile.z;
@@ -22,29 +38,28 @@ export function transformTile(tile: GeoJSONVTTile, extent: number): GeoJSONVTTra
     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));
+        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;
         }
 
-        for (const singleGeom of geom as number[][]) {
+        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));
             }
-            (feature.geometry as unknown as [number, number][][]).push(ring);
+            geometry.push(ring);
         }
+        (feature as unknown as GeoJSONVTFeatureNonPoint).geometry = geometry;
     }
     tile.transformed = true;
 
-    return tile as GeoJSONVTTransformedTile;
+    return tile as GeoJSONVTTile;
 }
 
 function transformPoint(x: number, y: number, extent: number, z2: number, tx: number, ty: number): [number, number] {

package/src/wrap.ts

@@ -1,9 +1,9 @@
 
 import {clip} from './clip';
-import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 import {createFeature} from './feature';
 
-export function wrap(features: GeoJSONVTFeature[], options: GeoJSONVTOptions): GeoJSONVTFeature[] {
+export function wrap(features: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
     const buffer = options.buffer / options.extent;
     let merged = features;
 
@@ -20,7 +20,7 @@ export function wrap(features: GeoJSONVTFeature[], options: GeoJSONVTOptions): G
     return merged;
 }
 
-function shiftFeatureCoords(features: GeoJSONVTFeature[], offset: number): GeoJSONVTFeature[] {
+function shiftFeatureCoords(features: GeoJSONVTInternalFeature[], offset: number): GeoJSONVTInternalFeature[] {
     const newFeatures = [];
 
     for (const feature of features) {