@maplibre/geojson-vt 5.0.3 → 6.0.0

package/dist/geojsonvt.d.ts

@@ -0,0 +1,76 @@
+import { type GeoJSONVTSourceDiff } from './difference';
+import type { ClusterOrPointFeature, GeoJSONVTOptions, GeoJSONVTTile, SuperclusterOptions } from './definitions';
+export declare const defaultOptions: GeoJSONVTOptions;
+/**
+ * Main class for creating and managing a vector tile index from GeoJSON data.
+ */
+export declare class GeoJSONVT {
+    /**
+     * @internal
+     * This is for the tests
+     */
+    get tiles(): any;
+    /**
+     * @internal
+     * This is for the tests
+     */
+    get stats(): any;
+    /**
+    * @internal
+    * This is for the tests
+    */
+    get total(): any;
+    private options;
+    private source?;
+    private tileIndex;
+    constructor(data: GeoJSON.GeoJSON, options?: GeoJSONVTOptions);
+    private initializeIndex;
+    /**
+     * 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): GeoJSONVTTile | null;
+    /**
+     * Updates the source data feature set using a {@link GeoJSONVTSourceDiff}
+     * @param diff - the source diff object
+     */
+    updateData(diff: GeoJSONVTSourceDiff, filter?: (feature: GeoJSON.Feature) => boolean): void;
+    /**
+     * Filter an update using a predicate function. Returns the affected and updated source features.
+     */
+    private filterUpdate;
+    /**
+     * Returns source data as GeoJSON - only available when `updateable` option is set to true.
+     */
+    getData(): GeoJSON.GeoJSON;
+    /**
+     * Update supercluster options and regenerate the index.
+     * @param cluster - whether to enable clustering
+     * @param clusterOptions - {@link SuperclusterOptions}
+     */
+    updateClusterOptions(cluster: boolean, clusterOptions: SuperclusterOptions): void;
+    /**
+     * Returns the zoom level at which a cluster expands into multiple children.
+     * @param clusterId - The target cluster id.
+     * @returns the expansion zoom or null in case of non-clustered source
+     */
+    getClusterExpansionZoom(clusterId: number): number | null;
+    /**
+     * Returns the immediate children (clusters or points) of a cluster as GeoJSON.
+     * @param clusterId - The target cluster id.
+     * @returns the immediate children or null in case of non-clustered source
+     */
+    getClusterChildren(clusterId: number): ClusterOrPointFeature[] | null;
+    /**
+     * Returns leaf point features under a cluster, paginated by `limit` and `offset`.
+     * @param clusterId - The target cluster id.
+     * @param limit - Maximum number of points to return (defaults to `10`).
+     * @param offset - Number of points to skip before collecting results (defaults to `0`).
+     * @returns leaf point features under a cluster or null in case of non-clustered source
+     */
+    getClusterLeaves(clusterId: number, limit: number, offset: number): GeoJSON.Feature<GeoJSON.Point>[] | null;
+}
+//# sourceMappingURL=geojsonvt.d.ts.map

package/dist/geojsonvt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojsonvt.d.ts","sourceRoot":"","sources":["../src/geojsonvt.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,KAAK,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAC,qBAAqB,EAAgD,gBAAgB,EAAE,aAAa,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAE7J,eAAO,MAAM,cAAc,EAAE,gBAc5B,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAElB;;;OAGG;IACH,IAAW,KAAK,QAGf;IACD;;;OAGG;IACH,IAAW,KAAK,QAGf;IACA;;;MAGE;IACH,IAAW,KAAK,QAGf;IAED,OAAO,CAAC,OAAO,CAAmB;IAElC,OAAO,CAAC,MAAM,CAAC,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAqB;gBAE1B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB;IA8B7D,OAAO,CAAC,eAAe;IAMvB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,IAAI;IAUzF;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO;IAqBpF;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,OAAO;IAK1B;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,mBAAmB;IAa1E;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIzD;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAIrE;;;;;;OAMG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;CAG9G"}

package/dist/geojsonvt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geojsonvt.test.d.ts.map

package/dist/geojsonvt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojsonvt.test.d.ts","sourceRoot":"","sources":["../src/geojsonvt.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+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 { KDBushWithData } from './cluster-tile-index';
+import { GeoJSONVT } from './geojsonvt';
+import { ClusterTileIndex } from './cluster-tile-index';
+import { geoJSONToTile } from './geojson-to-tile';
+export { GeoJSONVT, ClusterTileIndex as Supercluster, geoJSONToTile };
+export type { GeoJSONVTInternalFeature, GeoJSONVTOptions, GeoJSONToTileOptions, GeoJSONVTInternalTile, GeoJSONVTInternalTileFeature, PartialGeoJSONVTFeature, StartEndSizeArray, GeoJSONVTTile, GeoJSONVTFeature, GeoJSONVTSourceDiff, GeoJSONVTFeatureDiff, GeoJSONVTFeaturePoint, GeoJSONVTFeatureNonPoint, GeoJSONVTInternalTileFeaturePoint, GeoJSONVTInternalTileFeatureNonPoint, GeoJSONVTInternalPointFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTInternalMultiPolygonFeature, SuperclusterOptions, ClusterProperties, ClusterFeature, ClusterOrPointFeature, KDBushWithData, GeoJSONVTTileIndex };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAC5E,OAAO,KAAK,EAAC,wBAAwB,EAAE,kCAAkC,EAAE,uCAAuC,EAAE,kCAAkC,EAAE,oCAAoC,EAAE,6BAA6B,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,qBAAqB,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,iCAAiC,EAAE,oCAAoC,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAC1pB,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EACH,SAAS,EACT,gBAAgB,IAAI,YAAY,EAChC,aAAa,EAChB,CAAA;AAED,YAAY,EACR,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,iCAAiC,EACjC,oCAAoC,EACpC,6BAA6B,EAC7B,kCAAkC,EAClC,kCAAkC,EAClC,uCAAuC,EACvC,+BAA+B,EAC/B,oCAAoC,EACpC,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EACrB,CAAC"}

package/dist/simplify.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 declare function simplify(coords: number[], first: number, last: number, sqTolerance: number): void;
+//# sourceMappingURL=simplify.d.ts.map

package/dist/simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../src/simplify.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAqC1F"}

package/dist/simplify.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=simplify.test.d.ts.map

package/dist/simplify.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.test.d.ts","sourceRoot":"","sources":["../src/simplify.test.ts"],"names":[],"mappings":""}

package/dist/tile-index.d.ts

@@ -0,0 +1,51 @@
+import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, ClusterOrPointFeature, GeoJSONVTTileIndex, GeoJSONVTInternalTile, GeoJSONVTTile } from "./definitions";
+export declare class TileIndex implements GeoJSONVTTileIndex {
+    private options;
+    private tileCoords;
+    /** @internal */
+    tiles: {
+        [key: string]: GeoJSONVTInternalTile;
+    };
+    /** @internal */
+    stats: {
+        [key: string]: number;
+    };
+    /** @internal */
+    total: number;
+    constructor(options: GeoJSONVTOptions);
+    initialize(features: GeoJSONVTInternalFeature[]): void;
+    /** {@inheritdoc} */
+    updateIndex(source: GeoJSONVTInternalFeature[], affected: GeoJSONVTInternalFeature[], options: GeoJSONVTOptions): void;
+    /** {@inheritdoc} */
+    getClusterExpansionZoom(_clusterId: number): number | null;
+    /** {@inheritdoc} */
+    getChildren(_clusterId: number): ClusterOrPointFeature[] | null;
+    /** {@inheritdoc} */
+    getLeaves(_clusterId: number, _limit?: number, _offset?: number): GeoJSON.Feature<GeoJSON.Point>[] | null;
+    /** {@inheritdoc} */
+    getTile(z: number, x: number, y: number): GeoJSONVTTile | null;
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * z, x, and y are the coordinates of the parent tile
+     * cz, cx, and cy are the coordinates of the target tile
+     *
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the options.
+     * @internal
+     * @param features - features to split
+     * @param z - tile zoom level
+     * @param x - tile x coordinate
+     * @param y - tile y coordinate
+     * @param cz - target tile zoom level
+     * @param cx - target tile x coordinate
+     * @param cy - target tile y coordinate
+     */
+    private splitTile;
+    /**
+     * Invalidates (removes) tiles affected by the provided features
+     * @internal
+     * @param features
+     */
+    private invalidateTiles;
+}
+//# sourceMappingURL=tile-index.d.ts.map

package/dist/tile-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-index.d.ts","sourceRoot":"","sources":["../src/tile-index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjK,qBAAa,SAAU,YAAW,kBAAkB;IAWpC,OAAO,CAAC,OAAO;IAT3B,OAAO,CAAC,UAAU,CAAkD;IAEpE,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;KAAC,CAAC;IACrD,gBAAgB;IACT,KAAK,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAM;IAC3C,gBAAgB;IACT,KAAK,EAAE,MAAM,CAAK;gBAEL,OAAO,EAAE,gBAAgB;IAO7C,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,GAAG,IAAI;IAWtD,oBAAoB;IACpB,WAAW,CAAC,MAAM,EAAE,wBAAwB,EAAE,EAAE,QAAQ,EAAE,wBAAwB,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IA2BtH,oBAAoB;IAEpB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI1D,oBAAoB;IAEpB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,qBAAqB,EAAE,GAAG,IAAI;IAI/D,oBAAoB;IAEpB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI;IAIzG,oBAAoB;IACpB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAwC9D;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS;IA4FjB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAuE1B"}

package/dist/tile.d.ts

@@ -0,0 +1,12 @@
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalTile, GeoJSONVTOptions } from "./definitions";
+/**
+ * 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 declare function createTile(features: GeoJSONVTInternalFeature[], z: number, tx: number, ty: number, options: GeoJSONVTOptions): GeoJSONVTInternalTile;
+//# sourceMappingURL=tile.d.ts.map

package/dist/tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.d.ts","sourceRoot":"","sources":["../src/tile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAyN,qBAAqB,EAAgC,gBAAgB,EAAqB,MAAM,eAAe,CAAC;AAI/W;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,qBAAqB,CAwBpJ"}

package/dist/transform.d.ts

@@ -0,0 +1,10 @@
+import type { GeoJSONVTInternalTile, GeoJSONVTTile } from "./definitions";
+/**
+ * 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 declare function transformTile(tile: GeoJSONVTInternalTile, extent: number): GeoJSONVTTile;
+//# sourceMappingURL=transform.d.ts.map

package/dist/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmD,qBAAqB,EAA2E,aAAa,EAAE,MAAM,eAAe,CAAC;AAEpM;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAmBxF"}

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.3",
+  "version": "6.0.0",
   "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,33 +19,38 @@
   ],
   "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",
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
+    "@types/benchmark": "^2.1.5",
     "@types/geojson": "^7946.0.16",
-    "@types/node": "^25.0.9",
-    "@vitest/coverage-v8": "^4.0.17",
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.18",
     "benchmark": "^2.1.4",
-    "eslint": "^9.39.2",
-    "rollup": "^4.55.2",
+    "eslint": "^10.0.2",
+    "rollup": "^4.59.0",
     "tslib": "^2.8.1",
-    "typedoc": "^0.28.16",
+    "tsx": "^4.21.0",
+    "typedoc": "^0.28.17",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.1",
+    "typescript-eslint": "^8.56.1",
     "vitest": "^4.0.17"
   },
   "license": "ISC",
   "scripts": {
-    "lint": "eslint **/*.ts",
+    "lint": "eslint",
     "test": "vitest",
+    "coverage": "vitest run --coverage",
     "build": "rollup -c && tsc -p tsconfig.declaration.json",
     "watch": "rollup -cw",
-    "bench": "node bench/benchmark.js",
+    "start": "npm run watch",
+    "bench": "tsx bench/benchmark.ts",
     "docs": "typedoc && mkdir -p docs/debug && cp -r debug/* docs/debug && find docs/debug -name '*.html' -exec sed -i 's|../dist/geojson-vt-dev.js|https://unpkg.com/@maplibre/geojson-vt@latest/dist/geojson-vt.js|g' {} +",
     "prepublishOnly": "npm run test && npm run build"
   },
@@ -50,5 +61,8 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/maplibre/geojson-vt"
+  },
+  "dependencies": {
+    "kdbush": "^4.0.2"
   }
 }

package/src/clip.ts

@@ -1,110 +1,78 @@
 
 import {createFeature} from './feature';
-import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 
-/* clip features between two vertical or horizontal axis-parallel lines:
+export const enum AxisType {
+    X = 0,
+    Y = 1
+}
+
+/** 
+ * clip features between two vertical or horizontal axis-parallel lines:
  *     |        |
  *  ___|___     |     /
  * /   |   \____|____/
  *     |        |
  *
- * k1 and k2 are the line coordinates
- * axis: 0 for x, 1 for y
- * minAll and maxAll: minimum and maximum coordinate value for all features
+ * @param features - the features to clip
+ * @param scale - the scale to divide start and end inputs
+ * @param start - the start of the clip range
+ * @param end - the end of the clip range
+ * @param axis - which axis to clip against
+ * @param minAll - the minimum for all features in the relevant axis
+ * @param maxAll - the maximum for all features in the relevant axis
  */
-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;
+export function clip(features: GeoJSONVTInternalFeature[], scale: number, start: number, end: number, axis: AxisType, minAll: number, maxAll: number, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] | null {
+    start /= scale;
+    end /= scale;
 
-    if (minAll >= k1 && maxAll < k2) { // trivial accept
+    if (minAll >= start && maxAll < end) { // trivial accept
         return features;
     }
 
-    if (maxAll < k1 || minAll >= k2) { // trivial reject
+    if (maxAll < start || minAll >= end) { // trivial reject
         return null;
     }
 
     const clipped: GeoJSONVTInternalFeature[] = [];
 
     for (const feature of features) {
-        const min = axis === 0 ? feature.minX : feature.minY;
-        const max = axis === 0 ? feature.maxX : feature.maxY;
+        const min = axis === AxisType.X ? feature.minX : feature.minY;
+        const max = axis === AxisType.X ? feature.maxX : feature.maxY;
 
-        if (min >= k1 && max < k2) { // trivial accept
+        if (min >= start && max < end) { // trivial accept
             clipped.push(feature);
             continue;
         }
 
-        if (max < k1 || min >= k2) { // trivial reject
+        if (max < start || min >= end) { // trivial reject
             continue;
         }
 
         switch (feature.type) {
             case 'Point':
             case 'MultiPoint': {
-                const pointGeometry: number[] = [];
-                clipPoints(feature.geometry, pointGeometry, k1, k2, axis);
-                if (!pointGeometry.length) continue;
-
-                const type = pointGeometry.length === 3 ? 'Point' : 'MultiPoint';
-                clipped.push(createFeature(feature.id, type, pointGeometry, feature.tags));
+                clipPointFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'LineString': {
-                const lineGeometry: StartEndSizeArray[] = [];
-                clipLine(feature.geometry, lineGeometry, k1, k2, axis, false, options.lineMetrics);
-                if (!lineGeometry.length) continue;
-
-                if (options.lineMetrics) {
-                    for (const line of lineGeometry) {
-                        clipped.push(createFeature(feature.id, feature.type, line, feature.tags));
-                    }
-                    continue;
-                }
-
-                if (lineGeometry.length > 1) {
-                    clipped.push(createFeature(feature.id, "MultiLineString", lineGeometry, feature.tags));
-                    continue;
-                }
-
-                clipped.push(createFeature(feature.id, feature.type, lineGeometry[0], feature.tags));
+                clipLineStringFeature(feature, clipped, start, end, axis, options);
                 continue;
             }
 
             case 'MultiLineString': {
-                const multiLineGeometry: StartEndSizeArray[] = [];
-                clipLines(feature.geometry, multiLineGeometry, k1, k2, axis, false);
-                if (!multiLineGeometry.length) continue;
-
-                if (multiLineGeometry.length === 1) {
-                    clipped.push(createFeature(feature.id, "LineString", multiLineGeometry[0], feature.tags));
-                    continue;
-                }
-
-                clipped.push(createFeature(feature.id, feature.type, multiLineGeometry, feature.tags));
+                clipMultiLineStringFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'Polygon': {
-                const polygonGeometry: StartEndSizeArray[] = [];
-                clipLines(feature.geometry, polygonGeometry, k1, k2, axis, true);
-                if (!polygonGeometry.length) continue;
-
-                clipped.push(createFeature(feature.id, feature.type, polygonGeometry, feature.tags));
+                clipPolygonFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'MultiPolygon': {
-                const multiPolygonGeometry: StartEndSizeArray[][] = [];
-                for (const polygon of feature.geometry) {
-                    const newPolygon: StartEndSizeArray[] = [];
-                    clipLines(polygon, newPolygon, k1, k2, axis, true);
-                    if (newPolygon.length) multiPolygonGeometry.push(newPolygon);
-                }
-                if (!multiPolygonGeometry.length) continue;
-
-                clipped.push(createFeature(feature.id, feature.type, multiPolygonGeometry, feature.tags));
+                clipMultiPolygonFeature(feature, clipped, start, end, axis);
                 continue;
             }
         }
@@ -115,20 +83,90 @@ export function clip(features: GeoJSONVTInternalFeature[], scale: number, k1: nu
     return clipped;
 }
 
-function clipPoints(geom: number[], newGeom: number[], k1: number, k2: number, axis: number) {
+function clipPointFeature(feature: GeoJSONVTInternalPointFeature | GeoJSONVTInternalMultiPointFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: number[] = [];
+
+    clipPoints(feature.geometry, geom, start, end, axis);
+    if (!geom.length) return;
+
+    const type = geom.length === 3 ? 'Point' : 'MultiPoint';
+    clipped.push(createFeature(feature.id, type, geom, feature.tags));
+}
+
+function clipLineStringFeature(feature: GeoJSONVTInternalLineStringFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType, options: GeoJSONVTOptions) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLine(feature.geometry, geom, start, end, axis, false, options.lineMetrics);
+    if (!geom.length) return;
+
+    if (options.lineMetrics) {
+        for (const line of geom) {
+            clipped.push(createFeature(feature.id, 'LineString', line, feature.tags));
+        }
+        return;
+    }
+
+    if (geom.length > 1) {
+        clipped.push(createFeature(feature.id, 'MultiLineString', geom, feature.tags));
+        return;
+    }
+
+    clipped.push(createFeature(feature.id, 'LineString', geom[0], feature.tags));
+}
+
+function clipMultiLineStringFeature(feature: GeoJSONVTInternalMultiLineStringFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLines(feature.geometry, geom, start, end, axis, false);
+    if (!geom.length) return;
+
+    if (geom.length === 1) {
+        clipped.push(createFeature(feature.id, 'LineString', geom[0], feature.tags));
+        return;
+    }
+
+    clipped.push(createFeature(feature.id,'MultiLineString', geom, feature.tags));
+}
+
+function clipPolygonFeature(feature: GeoJSONVTInternalPolygonFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLines(feature.geometry, geom, start, end, axis, true);
+    if (!geom.length) return;
+
+    clipped.push(createFeature(feature.id, 'Polygon', geom, feature.tags));
+}
+
+function clipMultiPolygonFeature(feature: GeoJSONVTInternalMultiPolygonFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[][] = [];
+
+    for (const polygon of feature.geometry) {
+        const newPolygon: StartEndSizeArray[] = [];
+
+        clipLines(polygon, newPolygon, start, end, axis, true);
+        if (!newPolygon.length) continue;
+
+        geom.push(newPolygon);
+    }
+    if (!geom.length) return;
+
+    clipped.push(createFeature(feature.id, 'MultiPolygon', geom, feature.tags));
+}
+
+function clipPoints(geom: number[], newGeom: number[], start: number, end: number, axis: AxisType) {
     for (let i = 0; i < geom.length; i += 3) {
         const a = geom[i + axis];
 
-        if (a >= k1 && a <= k2) {
+        if (a >= start && a <= end) {
             addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
         }
     }
 }
 
-function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: number, k2: number, axis: number, isPolygon: boolean, trackMetrics: boolean) {
+function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], start: number, end: number, axis: AxisType, isPolygon: boolean, trackMetrics: boolean) {
 
     let slice = newSlice(geom);
-    const intersect = axis === 0 ? intersectX : intersectY;
+    const intersect = axis === AxisType.X ? intersectX : intersectY;
     let len = geom.start;
     let segLen, t;
 
@@ -138,37 +176,37 @@ function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: num
         const az = geom[i + 2];
         const bx = geom[i + 3];
         const by = geom[i + 4];
-        const a = axis === 0 ? ax : ay;
-        const b = axis === 0 ? bx : by;
+        const a = axis === AxisType.X ? ax : ay;
+        const b = axis === AxisType.X ? bx : by;
         let exited = false;
 
         if (trackMetrics) segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
 
-        if (a < k1) {
+        if (a < start) {
             // ---|-->  | (line enters the clip region from the left)
-            if (b > k1) {
-                t = intersect(slice, ax, ay, bx, by, k1);
+            if (b > start) {
+                t = intersect(slice, ax, ay, bx, by, start);
                 if (trackMetrics) slice.start = len + segLen * t;
             }
-        } else if (a > k2) {
+        } else if (a > end) {
             // |  <--|--- (line enters the clip region from the right)
-            if (b < k2) {
-                t = intersect(slice, ax, ay, bx, by, k2);
+            if (b < end) {
+                t = intersect(slice, ax, ay, bx, by, end);
                 if (trackMetrics) slice.start = len + segLen * t;
             }
         } else {
             addPoint(slice, ax, ay, az);
         }
 
-        if (b < k1 && a >= k1) {
+        if (b < start && a >= start) {
             // <--|---  | or <--|-----|--- (line exits the clip region on the left)
-            t = intersect(slice, ax, ay, bx, by, k1);
+            t = intersect(slice, ax, ay, bx, by, start);
             exited = true;
         }
 
-        if (b > k2 && a <= k2) {
+        if (b > end && a <= end) {
             // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
-            t = intersect(slice, ax, ay, bx, by, k2);
+            t = intersect(slice, ax, ay, bx, by, end);
             exited = true;
         }
 
@@ -186,8 +224,8 @@ function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: num
     const ax = geom[last];
     const ay = geom[last + 1];
     const az = geom[last + 2];
-    const a = axis === 0 ? ax : ay;
-    if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
+    const a = axis === AxisType.X ? ax : ay;
+    if (a >= start && a <= end) addPoint(slice, ax, ay, az);
 
     // close the polygon if its endpoints are not the same after clipping
     last = slice.length - 3;
@@ -209,9 +247,9 @@ function newSlice(line: StartEndSizeArray): StartEndSizeArray {
     return slice;
 }
 
-function clipLines(geom: StartEndSizeArray[], newGeom: StartEndSizeArray[], k1: number, k2: number, axis: number, isPolygon: boolean) {
+function clipLines(geom: StartEndSizeArray[], newGeom: StartEndSizeArray[], start: number, end: number, axis: AxisType, isPolygon: boolean) {
     for (const line of geom) {
-        clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+        clipLine(line, newGeom, start, end, axis, isPolygon, false);
     }
 }