@loaders.gl/mvt 3.3.0-alpha.6 → 3.3.0-alpha.8

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

@@ -0,0 +1,125 @@
+"use strict";
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTile = void 0;
+/**
+ * Create a tile from features and tile index
+ */
+function createTile(features, z, tx, ty, options) {
+    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+    const tile = {
+        features: [],
+        numPoints: 0,
+        numSimplified: 0,
+        numFeatures: features.length,
+        source: 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;
+}
+exports.createTile = createTile;
+// eslint-disable-next-line complexity, max-statements
+function addFeature(tile, feature, tolerance, options) {
+    const geom = feature.geometry;
+    const type = feature.type;
+    const simplified = [];
+    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);
+    if (type === 'Point' || type === 'MultiPoint') {
+        for (let i = 0; i < geom.length; i += 3) {
+            simplified.push(geom[i], geom[i + 1]);
+            tile.numPoints++;
+            tile.numSimplified++;
+        }
+    }
+    else if (type === 'LineString') {
+        addLine(simplified, geom, tile, tolerance, false, false);
+    }
+    else if (type === 'MultiLineString' || type === 'Polygon') {
+        for (let i = 0; i < geom.length; i++) {
+            addLine(simplified, geom[i], tile, tolerance, type === 'Polygon', i === 0);
+        }
+    }
+    else if (type === 'MultiPolygon') {
+        for (let k = 0; k < geom.length; k++) {
+            const polygon = geom[k];
+            for (let i = 0; i < polygon.length; i++) {
+                addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
+            }
+        }
+    }
+    if (simplified.length) {
+        let tags = feature.tags || null;
+        if (type === 'LineString' && options.lineMetrics) {
+            tags = {};
+            for (const key in feature.tags)
+                tags[key] = feature.tags[key];
+            // eslint-disable-next-line camelcase
+            tags.mapbox_clip_start = geom.start / geom.size;
+            // eslint-disable-next-line camelcase
+            tags.mapbox_clip_end = geom.end / geom.size;
+        }
+        // @ts-expect-error TODO - create sub type?
+        const tileFeature = {
+            geometry: simplified,
+            type: type === 'Polygon' || type === 'MultiPolygon'
+                ? 3
+                : type === 'LineString' || type === 'MultiLineString'
+                    ? 2
+                    : 1,
+            tags
+        };
+        if (feature.id !== null) {
+            tileFeature.id = feature.id;
+        }
+        tile.features.push(tileFeature);
+    }
+}
+// eslint-disable-next-line max-params, max-statements
+function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
+    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, 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/geojson-tiler/transform.d.ts

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

package/dist/lib/geojson-tiler/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/lib/geojson-tiler/transform.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,QAAQ,CAAC;AAExC;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAiC5E"}

package/dist/lib/geojson-tiler/transform.js

@@ -0,0 +1,43 @@
+"use strict";
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTile = void 0;
+/**
+ * Transforms the coordinates of each feature in the given tile from
+ * mercator-projected space into (extent x extent) tile space.
+ */
+function transformTile(tile, extent) {
+    if (tile.transformed) {
+        return tile;
+    }
+    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.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
+            }
+        }
+        else {
+            for (let j = 0; j < geom.length; j++) {
+                const ring = [];
+                for (let k = 0; k < geom[j].length; k += 2) {
+                    ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
+                }
+                feature.geometry.push(ring);
+            }
+        }
+    }
+    tile.transformed = true;
+    return tile;
+}
+exports.transformTile = transformTile;
+// eslint-disable-next-line max-params
+function transformPoint(x, y, extent, z2, tx, ty) {
+    return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
+}

package/dist/lib/geojson-tiler/wrap.d.ts

@@ -0,0 +1,17 @@
+import type { GeoJSONTileFeature } from './tile';
+/**
+ * Options for wrap()
+ */
+export type WrapOptions = {
+    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 options buffer and extent
+ * @returns
+ */
+export declare function wrap(features: GeoJSONTileFeature[], options: WrapOptions): GeoJSONTileFeature[];
+//# sourceMappingURL=wrap.d.ts.map

package/dist/lib/geojson-tiler/wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../../../src/lib/geojson-tiler/wrap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,QAAQ,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC,8CAA8C,CAAC;IAC9D,MAAM,EAAE,MAAM,CAAC,0BAA0B,CAAC;IAC1C,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,kBAAkB,EAAE,EAAE,OAAO,EAAE,WAAW,wBAkBxE"}

package/dist/lib/geojson-tiler/wrap.js

@@ -0,0 +1,86 @@
+"use strict";
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = void 0;
+const clip_1 = require("./clip");
+const feature_1 = require("./feature");
+/**
+ * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
+ * @param features list of features to be wrapped
+ * @param options buffer and extent
+ * @returns
+ */
+function wrap(features, options) {
+    const buffer = options.buffer / options.extent;
+    let merged = features;
+    const left = (0, clip_1.clip)(features, 1, -1 - buffer, buffer, 0, -1, 2, options); // left world copy
+    const right = (0, clip_1.clip)(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
+    if (left || right) {
+        merged = (0, clip_1.clip)(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
+        if (left) {
+            merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
+        }
+        if (right) {
+            merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center
+        }
+    }
+    return merged;
+}
+exports.wrap = wrap;
+/**
+ * Shift the x coordinates of a list of features
+ * @param features list of features to shift x coordinates for
+ * @param offset
+ * @returns
+ */
+function shiftFeatureCoords(features, offset) {
+    const newFeatures = [];
+    for (let i = 0; i < features.length; i++) {
+        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));
+                }
+                newGeometry.push(newPolygon);
+            }
+        }
+        newFeatures.push((0, feature_1.createFeature)(feature.id, type, newGeometry, feature.tags));
+    }
+    return newFeatures;
+}
+class Points extends Array {
+}
+/**
+ * Shift the x coordinate of every point
+ * @param points
+ * @param offset
+ * @returns
+ */
+function shiftCoords(points, offset) {
+    const newPoints = [];
+    newPoints.size = points.size;
+    if (points.start !== undefined) {
+        newPoints.start = points.start;
+        newPoints.end = points.end;
+    }
+    for (let i = 0; i < points.length; i += 3) {
+        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
+    }
+    return newPoints;
+}

package/dist/lib/mapbox-vector-tile/vector-tile-feature.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const mapbox_util_functions_1 = require("../../helpers/mapbox-util-functions");
 class VectorTileFeature {
+    static get types() {
+        return ['Unknown', 'Point', 'LineString', 'Polygon'];
+    }
     constructor(pbf, end, extent, keys, values) {
         // Public
         this.properties = {};
@@ -15,9 +18,6 @@ class VectorTileFeature {
         this._values = values;
         pbf.readFields(mapbox_util_functions_1.readFeature, this, end);
     }
-    static get types() {
-        return ['Unknown', 'Point', 'LineString', 'Polygon'];
-    }
     // eslint-disable-next-line complexity, max-statements
     loadGeometry() {
         const pbf = this._pbf;

package/dist/lib/types.d.ts

@@ -1,6 +1,6 @@
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
 /** For local coordinates, the tileIndex is not required */
-declare type MVTLocalCoordinatesOptions = {
+type MVTLocalCoordinatesOptions = {
     /**
      * When set to `local`, the parser will return a flat array of GeoJSON objects with local coordinates decoded from tile origin.
      */
@@ -8,7 +8,7 @@ declare type MVTLocalCoordinatesOptions = {
     tileIndex: null;
 };
 /** In WGS84 coordinates, the tileIndex is required */
-declare type MVTWgs84CoordinatesOptions = {
+type MVTWgs84CoordinatesOptions = {
     /**
      * When set to `wgs84`, the parser will return a flat array of GeoJSON objects with coordinates in longitude, latitude decoded from the provided tile index.
      */
@@ -23,7 +23,7 @@ declare type MVTWgs84CoordinatesOptions = {
         z: number;
     };
 };
-export declare type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
+export type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
     /**
      * When non-`null`, the layer name of each feature is added to
      * `feature.properties[layerProperty]`. (A `feature.properties` object is created if the feature
@@ -37,13 +37,13 @@ export declare type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84Coordinat
     layers?: string[];
     shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
 };
-export declare type MVTMapboxGeometry = {
+export type MVTMapboxGeometry = {
     type?: string;
     id?: number;
     length: number;
     coordinates?: any[];
 };
-export declare type MVTMapboxCoordinates = {
+export type MVTMapboxCoordinates = {
     type: string;
     geometry: {
         type: string;
@@ -54,7 +54,7 @@ export declare type MVTMapboxCoordinates = {
     };
     id?: number;
 };
-export declare type MVTLoaderOptions = LoaderOptions & {
+export type MVTLoaderOptions = LoaderOptions & {
     mvt?: MVTOptions;
     gis?: {
         /**

package/dist/lib/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,2DAA2D;AAC3D,aAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,sDAAsD;AACtD,aAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;CAC9C,CAAC;AAEF,oBAAY,UAAU,GAAG,CAAC,0BAA0B,GAAG,0BAA0B,CAAC,GAAG;IACnF;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;CAC3F,CAAC;AAEF,oBAAY,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,oBAAY,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,iBAAiB,CAAC;KAChC,CAAC;IACF,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,oBAAY,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE;QACJ;;WAEG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,yCAAyC;QACzC,MAAM,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;KAC5F,CAAC;CACH,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,2DAA2D;AAC3D,KAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,sDAAsD;AACtD,KAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,0BAA0B,GAAG,0BAA0B,CAAC,GAAG;IACnF;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;CAC3F,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,iBAAiB,CAAC;KAChC,CAAC;IACF,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE;QACJ;;WAEG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,yCAAyC;QACzC,MAAM,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;KAC5F,CAAC;CACH,CAAC"}

package/dist/mvt-worker.js

@@ -2145,7 +2145,7 @@
   }
 
   // src/mvt-loader.ts
-  var VERSION = true ? "3.3.0-alpha.6" : "latest";
+  var VERSION = true ? "3.3.0-alpha.8" : "latest";
   var DEFAULT_MVT_LOADER_OPTIONS = {
     mvt: {
       shape: "geojson",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "3.3.0-alpha.6",
+  "version": "3.3.0-alpha.8",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -32,14 +32,14 @@
     "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "3.3.0-alpha.6",
-    "@loaders.gl/loader-utils": "3.3.0-alpha.6",
-    "@loaders.gl/schema": "3.3.0-alpha.6",
+    "@loaders.gl/gis": "3.3.0-alpha.8",
+    "@loaders.gl/loader-utils": "3.3.0-alpha.8",
+    "@loaders.gl/schema": "3.3.0-alpha.8",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@types/pbf": "^3.0.2"
   },
-  "gitHead": "718a2998a26883247461ff05f01dcbef8d8c2417"
+  "gitHead": "69cfde0340328dd800c7c90151b56b406f47e9ae"
 }

package/src/index.ts

@@ -1 +1,8 @@
+// loaders.gl, MIT license
+
 export {MVTLoader, MVTWorkerLoader} from './mvt-loader';
+
+// GeoJSONTiler
+
+export type {GeoJSONTilerOptions} from './lib/geojson-tiler/geojson-tiler';
+export {GeoJSONTiler} from './lib/geojson-tiler/geojson-tiler';

package/src/lib/geojson-tiler/LICENSE

@@ -0,0 +1,19 @@
+This directory is forked from Mapbox's https://github.com/mapbox/geojson-vt under ISC License.
+
+```
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+```

package/src/lib/geojson-tiler/clip.ts

@@ -0,0 +1,248 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {GeoJSONTileFeature} from './tile';
+import {createFeature} from './feature';
+
+/* eslint-disable no-continue */
+
+/**
+ * Clip features between two vertical or horizontal axis-parallel lines:
+ *     |        |
+ *  ___|___     |     /
+ * /   |   \____|____/
+ *     |        |
+ *
+ * @param k1 and k2 are the line coordinates
+ * @param axis: 0 for x, 1 for y
+ * @param minAll and maxAll: minimum and maximum coordinate value for all features
+ */
+// eslint-disable-next-line max-params, complexity, max-statements
+export function clip(
+  features: GeoJSONTileFeature[],
+  scale: number,
+  k1: number,
+  k2: number,
+  axis,
+  minAll: number,
+  maxAll: number,
+  options: {lineMetrics: boolean}
+): GeoJSONTileFeature[] | null {
+  k1 /= scale;
+  k2 /= scale;
+
+  if (minAll >= k1 && maxAll < k2) {
+    return features;
+  }
+  // trivial accept
+  else if (maxAll < k1 || minAll >= k2) {
+    return null; // trivial reject
+  }
+
+  const clipped: GeoJSONTileFeature[] = [];
+
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    let type = feature.type;
+
+    const min = axis === 0 ? feature.minX : feature.minY;
+    const max = axis === 0 ? feature.maxX : feature.maxY;
+
+    if (min >= k1 && max < k2) {
+      // trivial accept
+      clipped.push(feature);
+      continue;
+    } else if (max < k1 || min >= k2) {
+      // trivial reject
+      continue;
+    }
+
+    let newGeometry: number[][][] | number[][] = [];
+
+    if (type === 'Point' || type === 'MultiPoint') {
+      clipPoints(geometry, newGeometry, k1, k2, axis);
+    } else if (type === 'LineString') {
+      clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
+    } else if (type === 'MultiLineString') {
+      clipLines(geometry, newGeometry, k1, k2, axis, false);
+    } else if (type === 'Polygon') {
+      clipLines(geometry, newGeometry, k1, k2, axis, true);
+    } else if (type === 'MultiPolygon') {
+      for (const polygon of geometry) {
+        const newPolygon = [];
+        clipLines(polygon, newPolygon, k1, k2, axis, true);
+        if (newPolygon.length) {
+          newGeometry.push(newPolygon);
+        }
+      }
+    }
+
+    if (newGeometry.length) {
+      if (options.lineMetrics && type === 'LineString') {
+        for (const line of newGeometry) {
+          clipped.push(createFeature(feature.id, type, line, feature.tags));
+        }
+        continue;
+      }
+
+      if (type === 'LineString' || type === 'MultiLineString') {
+        if (newGeometry.length === 1) {
+          type = 'LineString';
+          // @ts-expect-error TODO - use proper GeoJSON geometry types
+          newGeometry = newGeometry[0];
+        } else {
+          type = 'MultiLineString';
+        }
+      }
+      if (type === 'Point' || type === 'MultiPoint') {
+        type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
+      }
+
+      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    }
+  }
+
+  return clipped.length ? clipped : null;
+}
+
+function clipPoints(geom, newGeom, k1: number, k2: number, axis): void {
+  for (let i = 0; i < geom.length; i += 3) {
+    const a = geom[i + axis];
+
+    if (a >= k1 && a <= k2) {
+      addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
+    }
+  }
+}
+
+// eslint-disable-next-line max-params, complexity, max-statements
+function clipLine(
+  geom,
+  newGeom,
+  k1: number,
+  k2: number,
+  axis,
+  isPolygon: boolean,
+  trackMetrics: boolean
+): void {
+  let slice = newSlice(geom);
+  const intersect = axis === 0 ? intersectX : intersectY;
+  let len = geom.start;
+  let segLen;
+  let t;
+
+  for (let i = 0; i < geom.length - 3; i += 3) {
+    const ax = geom[i];
+    const ay = geom[i + 1];
+    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;
+    let exited = false;
+
+    if (trackMetrics) {
+      segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
+    }
+
+    if (a < k1) {
+      // ---|-->  | (line enters the clip region from the left)
+      if (b > k1) {
+        t = intersect(slice, ax, ay, bx, by, k1);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else if (a > k2) {
+      // |  <--|--- (line enters the clip region from the right)
+      if (b < k2) {
+        t = intersect(slice, ax, ay, bx, by, k2);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else {
+      addPoint(slice, ax, ay, az);
+    }
+    if (b < k1 && a >= k1) {
+      // <--|---  | or <--|-----|--- (line exits the clip region on the left)
+      t = intersect(slice, ax, ay, bx, by, k1);
+      exited = true;
+    }
+    if (b > k2 && a <= k2) {
+      // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
+      t = intersect(slice, ax, ay, bx, by, k2);
+      exited = true;
+    }
+
+    if (!isPolygon && exited) {
+      if (trackMetrics) {
+        slice.end = len + segLen * t;
+      }
+      newGeom.push(slice);
+      slice = newSlice(geom);
+    }
+
+    if (trackMetrics) {
+      len += segLen;
+    }
+  }
+
+  // add the last point
+  let last = geom.length - 3;
+  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);
+
+  // close the polygon if its endpoints are not the same after clipping
+  last = slice.length - 3;
+  if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
+    addPoint(slice, slice[0], slice[1], slice[2]);
+  }
+
+  // add the final slice
+  if (slice.length) {
+    newGeom.push(slice);
+  }
+}
+
+class Slice extends Array<number> {
+  size?: number;
+  start?: number;
+  end?: number;
+}
+
+function newSlice(line: {size: number; start: number; end: number}): Slice {
+  const slice: Slice = [];
+  slice.size = line.size;
+  slice.start = line.start;
+  slice.end = line.end;
+  return slice;
+}
+
+// eslint-disable-next-line max-params
+function clipLines(geom, newGeom, k1: number, k2: number, axis, isPolygon: boolean): void {
+  for (const line of geom) {
+    clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+  }
+}
+
+function addPoint(out: number[], x: number, y: number, z: number): void {
+  out.push(x, y, z);
+}
+
+// eslint-disable-next-line max-params
+function intersectX(out, ax: number, ay: number, bx: number, by: number, x: number): number {
+  const t = (x - ax) / (bx - ax);
+  addPoint(out, x, ay + (by - ay) * t, 1);
+  return t;
+}
+
+// eslint-disable-next-line max-params
+function intersectY(out, ax: number, ay: number, bx: number, by: number, y): number {
+  const t = (y - ay) / (by - ay);
+  addPoint(out, ax + (bx - ax) * t, y, 1);
+  return t;
+}