@mapwhit/tilerenderer 1.2.1 → 1.2.2

package/build/min/package.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.2.1",
+  "version": "1.2.2",
   "type": "module"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapwhit/tilerenderer",
   "description": "A WebGL interactive maps library",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "type": "module",
   "exports": {
     ".": "./src/index.js",
@@ -14,15 +14,15 @@
   },
   "dependencies": {
     "@mapbox/gl-matrix": "^0.0.1",
-    "@mapbox/point-geometry": "~1",
     "@mapbox/unitbezier": "^0.0.1",
     "@mapbox/whoots-js": "^3.0.0",
     "@mapwhit/events": "^1.0.0",
     "@mapwhit/geojson-rewind": "^2.0.0",
-    "@mapwhit/geometry": "^1.0.0",
+    "@mapwhit/geometry": "^1.1.0",
     "@mapwhit/pbf": "^1.0.0",
+    "@mapwhit/point-geometry": "^1.0.2",
     "@mapwhit/style-expressions": "^1.2.0",
-    "@mapwhit/vector-tile": "^2.0.1",
+    "@mapwhit/vector-tile": "4.0.0",
     "@pirxpilot/nanoassert": "~1",
     "csscolorparser": "^1.0.3",
     "dynload": "^1.0.2",

package/src/data/bucket/fill_extrusion_bucket.js

@@ -1,4 +1,4 @@
-import { VectorTileFeature } from '@mapwhit/vector-tile';
+import { clone, dist, perp, sub, unit } from '@mapwhit/point-geometry';
 import assert from 'assert';
 import earcut from 'earcut';
 import classifyRings from '../../util/classify_rings.js';
@@ -15,7 +15,6 @@ import EvaluationParameters from '../../style/evaluation_parameters.js';
 import loadGeometry from '../load_geometry.js';
 import { addPatternDependencies, hasPattern } from './pattern_bucket_features.js';
 
-const { types: vectorTileFeatureTypes } = VectorTileFeature;
 const layoutAttributes = layout.members;
 
 const FACTOR = 2 ** 13;
@@ -34,7 +33,7 @@ function addVertex(vertexArray, x, y, nx, ny, nz, t, e) {
   );
 }
 
-class FillExtrusionBucket {
+export default class FillExtrusionBucket {
   constructor(options) {
     this.zoom = options.zoom;
     this.overscaling = options.overscaling;
@@ -145,46 +144,44 @@ class FillExtrusionBucket {
         }
 
         let edgeDistance = 0;
+        let from = ring[0];
+        for (let i = 1; i < ring.length; i++) {
+          const to = ring[i];
 
-        for (let p = 0; p < ring.length; p++) {
-          const p1 = ring[p];
-
-          if (p >= 1) {
-            const p2 = ring[p - 1];
-
-            if (!isBoundaryEdge(p1, p2)) {
-              if (segment.vertexLength + 4 > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
-                segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
-              }
+          if (!isBoundaryEdge(to, from)) {
+            if (segment.vertexLength + 4 > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
+              segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
+            }
 
-              const perp = p1.sub(p2)._perp()._unit();
-              const dist = p2.dist(p1);
-              if (edgeDistance + dist > 32768) {
-                edgeDistance = 0;
-              }
+            const { x, y } = unit(perp(sub(clone(to), from)));
+            const distance = dist(from, to);
+            if (edgeDistance + distance > 32768) {
+              edgeDistance = 0;
+            }
 
-              addVertex(this.layoutVertexArray, p1.x, p1.y, perp.x, perp.y, 0, 0, edgeDistance);
-              addVertex(this.layoutVertexArray, p1.x, p1.y, perp.x, perp.y, 0, 1, edgeDistance);
+            addVertex(this.layoutVertexArray, to.x, to.y, x, y, 0, 0, edgeDistance);
+            addVertex(this.layoutVertexArray, to.x, to.y, x, y, 0, 1, edgeDistance);
 
-              edgeDistance += dist;
+            edgeDistance += distance;
 
-              addVertex(this.layoutVertexArray, p2.x, p2.y, perp.x, perp.y, 0, 0, edgeDistance);
-              addVertex(this.layoutVertexArray, p2.x, p2.y, perp.x, perp.y, 0, 1, edgeDistance);
+            addVertex(this.layoutVertexArray, from.x, from.y, x, y, 0, 0, edgeDistance);
+            addVertex(this.layoutVertexArray, from.x, from.y, x, y, 0, 1, edgeDistance);
 
-              const bottomRight = segment.vertexLength;
+            const bottomRight = segment.vertexLength;
 
-              // ┌──────┐
-              // │ 0  1 │ Counter-clockwise winding order.
-              // │      │ Triangle 1: 0 => 2 => 1
-              // │ 2  3 │ Triangle 2: 1 => 2 => 3
-              // └──────┘
-              this.indexArray.emplaceBack(bottomRight, bottomRight + 2, bottomRight + 1);
-              this.indexArray.emplaceBack(bottomRight + 1, bottomRight + 2, bottomRight + 3);
+            // ┌──────┐
+            // │ 0  1 │ Counter-clockwise winding order.
+            // │      │ Triangle 1: 0 => 2 => 1
+            // │ 2  3 │ Triangle 2: 1 => 2 => 3
+            // └──────┘
+            this.indexArray.emplaceBack(bottomRight, bottomRight + 2, bottomRight + 1);
+            this.indexArray.emplaceBack(bottomRight + 1, bottomRight + 2, bottomRight + 3);
 
-              segment.vertexLength += 4;
-              segment.primitiveLength += 2;
-            }
+            segment.vertexLength += 4;
+            segment.primitiveLength += 2;
           }
+
+          from = to;
         }
       }
 
@@ -194,7 +191,7 @@ class FillExtrusionBucket {
 
       //Only triangulate and draw the area of the feature if it is a polygon
       //Other feature types (e.g. LineString) do not have area, so triangulation is pointless / undefined
-      if (vectorTileFeatureTypes[feature.type] !== 'Polygon') {
+      if (feature.type !== 3) {
         continue;
       }
 
@@ -241,13 +238,11 @@ class FillExtrusionBucket {
   }
 }
 
-export default FillExtrusionBucket;
-
-function isBoundaryEdge(p1, p2) {
+export function isBoundaryEdge(p1, p2) {
   return (p1.x === p2.x && (p1.x < 0 || p1.x > EXTENT)) || (p1.y === p2.y && (p1.y < 0 || p1.y > EXTENT));
 }
 
-function isEntirelyOutside(ring) {
+export function isEntirelyOutside(ring) {
   let left = true;
   let right = true;
   let top = true;

package/src/data/bucket/line_bucket.js

@@ -1,4 +1,4 @@
-import { VectorTileFeature } from '@mapwhit/vector-tile';
+import { dist, equals, Point } from '@mapwhit/point-geometry';
 import EvaluationParameters from '../../style/evaluation_parameters.js';
 import { LineLayoutArray } from '../array_types.js';
 import EXTENT from '../extent.js';
@@ -10,7 +10,6 @@ import layout from './line_attributes.js';
 import { addPatternDependencies, hasPattern } from './pattern_bucket_features.js';
 
 const layoutAttributes = layout.members;
-const vectorTileFeatureTypes = VectorTileFeature.types;
 
 // NOTE ON EXTRUDE SCALE:
 // scale the extrusion vector so that the normal length is this value.
@@ -66,21 +65,18 @@ function addLineVertex(layoutVertexBuffer, point, extrude, round, up, dir, lines
   );
 }
 
-/**
- * @private
- */
-class LineBucket {
-  constructor(options) {
-    this.zoom = options.zoom;
-    this.overscaling = options.overscaling;
-    this.layers = options.layers;
-    this.index = options.index;
+export default class LineBucket {
+  constructor({ zoom, overscaling, layers, index }) {
+    this.zoom = zoom;
+    this.overscaling = overscaling;
+    this.layers = layers;
+    this.index = index;
     this.features = [];
     this.hasPattern = false;
 
     this.layoutVertexArray = new LineLayoutArray();
     this.indexArray = new TriangleIndexArray();
-    this.programConfigurations = new ProgramConfigurationSet(layoutAttributes, options.layers, options.zoom);
+    this.programConfigurations = new ProgramConfigurationSet(layoutAttributes, layers, zoom);
     this.segments = new SegmentVector();
   }
 
@@ -174,24 +170,11 @@ class LineBucket {
   }
 
   addLine(vertices, feature, join, cap, miterLimit, roundLimit, index, imagePositions) {
-    let lineDistances = null;
-    if (
-      !!feature.properties &&
-      feature.properties.hasOwnProperty('mapbox_clip_start') &&
-      feature.properties.hasOwnProperty('mapbox_clip_end')
-    ) {
-      lineDistances = {
-        start: feature.properties.mapbox_clip_start,
-        end: feature.properties.mapbox_clip_end,
-        tileTotal: undefined
-      };
-    }
-
-    const isPolygon = vectorTileFeatureTypes[feature.type] === 'Polygon';
+    const isPolygon = feature.type === 3;
 
     // If the line has duplicate vertices at the ends, adjust start/length to remove them.
-    const firstVertex = vertices[0];
-    const lastVertex = vertices[vertices.length - 1];
+    const firstVertex = Point.clone(vertices[0]);
+    const lastVertex = Point.clone(vertices[vertices.length - 1]);
     let len = vertices.length;
     while (len >= 2 && lastVertex.equals(vertices[len - 2])) {
       len--;
@@ -206,8 +189,16 @@ class LineBucket {
       return;
     }
 
-    if (lineDistances) {
-      lineDistances.tileTotal = calculateFullDistance(vertices, first, len);
+    let lineDistances = null;
+    if (
+      feature.properties?.hasOwnProperty('mapbox_clip_start') &&
+      feature.properties?.hasOwnProperty('mapbox_clip_end')
+    ) {
+      lineDistances = {
+        start: feature.properties.mapbox_clip_start,
+        end: feature.properties.mapbox_clip_end,
+        tileTotal: calculateFullDistance(vertices, first, len)
+      };
     }
 
     if (join === 'bevel') {
@@ -238,16 +229,19 @@ class LineBucket {
     }
 
     for (let i = first; i < len; i++) {
-      const nextVertex =
+      let nextVertex =
         isPolygon && i === len - 1
           ? vertices[first + 1]
           : // if the line is closed, we treat the last vertex like the first
             vertices[i + 1]; // just the next vertex
 
       // if two consecutive vertices exist, skip the current one
-      if (nextVertex && vertices[i].equals(nextVertex)) {
+      if (nextVertex && equals(vertices[i], nextVertex)) {
         continue;
       }
+      if (nextVertex) {
+        nextVertex = Point.clone(nextVertex);
+      }
 
       if (nextNormal) {
         prevNormal = nextNormal;
@@ -296,15 +290,15 @@ class LineBucket {
       const isSharpCorner = cosHalfAngle < COS_HALF_SHARP_CORNER && prevVertex && nextVertex;
 
       if (isSharpCorner && i > first) {
-        const prevSegmentLength = currentVertex.dist(prevVertex);
+        const prevSegmentLength = dist(currentVertex, prevVertex);
         if (prevSegmentLength > 2 * sharpCornerOffset) {
-          const newPrevVertex = currentVertex.sub(
-            currentVertex
-              .sub(prevVertex)
+          const newPrevVertex = Point.clone(currentVertex)._sub(
+            Point.clone(currentVertex)
+              ._sub(prevVertex)
               ._mult(sharpCornerOffset / prevSegmentLength)
               ._round()
           );
-          this.distance += newPrevVertex.dist(prevVertex);
+          this.distance += dist(newPrevVertex, prevVertex);
           this.addCurrentVertex(newPrevVertex, this.distance, prevNormal.mult(1), 0, 0, false, segment, lineDistances);
           prevVertex = newPrevVertex;
         }
@@ -342,7 +336,7 @@ class LineBucket {
 
       // Calculate how far along the line the currentVertex is
       if (prevVertex) {
-        this.distance += currentVertex.dist(prevVertex);
+        this.distance += dist(currentVertex, prevVertex);
       }
 
       switch (currentJoin) {
@@ -356,7 +350,7 @@ class LineBucket {
 
           if (miterLength > 100) {
             // Almost parallel lines
-            joinNormal = nextNormal.clone().mult(-1);
+            joinNormal = nextNormal.mult(-1);
           } else {
             const direction = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0 ? -1 : 1;
             const bevelLength = (miterLength * prevNormal.add(nextNormal).mag()) / prevNormal.sub(nextNormal).mag();
@@ -505,15 +499,15 @@ class LineBucket {
       }
 
       if (isSharpCorner && i < len - 1) {
-        const nextSegmentLength = currentVertex.dist(nextVertex);
+        const nextSegmentLength = dist(currentVertex, nextVertex);
         if (nextSegmentLength > 2 * sharpCornerOffset) {
-          const newCurrentVertex = currentVertex.add(
-            nextVertex
-              .sub(currentVertex)
+          const newCurrentVertex = Point.clone(currentVertex)._add(
+            Point.clone(nextVertex)
+              ._sub(currentVertex)
               ._mult(sharpCornerOffset / nextSegmentLength)
               ._round()
           );
-          this.distance += newCurrentVertex.dist(currentVertex);
+          this.distance += dist(newCurrentVertex, currentVertex);
           this.addCurrentVertex(
             newCurrentVertex,
             this.distance,
@@ -556,7 +550,7 @@ class LineBucket {
       distance = scaleDistance(distance, distancesForScaling);
     }
 
-    extrude = normal.clone();
+    extrude = Point.clone(normal);
     if (endLeft) {
       extrude._sub(normal.perp()._mult(endLeft));
     }
@@ -658,10 +652,8 @@ function calculateFullDistance(vertices, first, len) {
   let prev = vertices[first];
   for (let i = first + 1; i < len; i++) {
     const next = vertices[i];
-    total += prev.dist(next);
+    total += dist(prev, next);
     prev = next;
   }
   return total;
 }
-
-export default LineBucket;

package/src/data/bucket/symbol_bucket.js

@@ -1,3 +1,4 @@
+import { dist } from '@mapwhit/point-geometry';
 import { Formatted } from '@mapwhit/style-expressions';
 import { VectorTileFeature } from '@mapwhit/vector-tile';
 import EvaluationParameters from '../../style/evaluation_parameters.js';
@@ -20,8 +21,6 @@ import { collisionBoxLayout, collisionCircleLayout, symbolLayoutAttributes } fro
 import SymbolBuffers from './symbol_buffers.js';
 import CollisionBuffers from './symbol_collision_buffers.js';
 
-const vectorTileFeatureTypes = VectorTileFeature.types;
-
 function addVertex(array, anchorX, anchorY, ox, oy, tx, ty, sizeVertex) {
   array.emplaceBack(
     // a_pos_offset
@@ -186,7 +185,7 @@ export default class SymbolBucket {
         sourceLayerIndex,
         geometry: loadGeometry(feature),
         properties: feature.properties,
-        type: vectorTileFeatureTypes[feature.type]
+        type: VectorTileFeature.types[feature.type]
       };
       if (typeof feature.id !== 'undefined') {
         symbolFeature.id = feature.id;
@@ -263,13 +262,13 @@ export default class SymbolBucket {
       for (let i = anchor.segment + 1; i < line.length; i++) {
         vertices[i] = { x: line[i].x, y: line[i].y, tileUnitDistanceFromAnchor: sumForwardLength };
         if (i < line.length - 1) {
-          sumForwardLength += line[i + 1].dist(line[i]);
+          sumForwardLength += dist(line[i + 1], line[i]);
         }
       }
       for (let i = anchor.segment || 0; i >= 0; i--) {
         vertices[i] = { x: line[i].x, y: line[i].y, tileUnitDistanceFromAnchor: sumBackwardLength };
         if (i > 0) {
-          sumBackwardLength += line[i - 1].dist(line[i]);
+          sumBackwardLength += dist(line[i - 1], line[i]);
         }
       }
       for (let i = 0; i < line.length; i++) {

package/src/data/feature_index.js

@@ -45,7 +45,7 @@ class FeatureIndex {
 
     const params = args.params || {};
     const pixelsToTileUnits = EXTENT / args.tileSize / args.scale;
-    const filter = featureFilter(params.filter);
+    const filter = featureFilter(params.filter, params.globalState);
 
     const queryGeometry = args.queryGeometry;
     const queryPadding = args.queryPadding * pixelsToTileUnits;
@@ -175,11 +175,18 @@ class FeatureIndex {
 
   // Given a set of symbol indexes that have already been looked up,
   // return a matching set of GeoJSONFeatures
-  lookupSymbolFeatures(symbolFeatureIndexes, bucketIndex, sourceLayerIndex, filterSpec, filterLayerIDs, styleLayers) {
+  lookupSymbolFeatures(
+    symbolFeatureIndexes,
+    bucketIndex,
+    sourceLayerIndex,
+    { filterSpec, globalState },
+    filterLayerIDs,
+    styleLayers
+  ) {
     const result = {};
     this.loadVTLayers();
 
-    const filter = featureFilter(filterSpec);
+    const filter = featureFilter(filterSpec, globalState);
 
     for (const symbolFeatureIndex of symbolFeatureIndexes) {
       this.loadMatchingFeature(

package/src/geo/transform.js

@@ -1,5 +1,5 @@
 import glMatrix from '@mapbox/gl-matrix';
-import Point from '@mapbox/point-geometry';
+import { Point } from '@mapwhit/point-geometry';
 import EXTENT from '../data/extent.js';
 import { UnwrappedTileID } from '../source/tile_id.js';
 import interpolate from '../util/interpolate.js';
@@ -194,10 +194,10 @@ class Transform {
   getVisibleUnwrappedCoordinates(tileID) {
     const result = [new UnwrappedTileID(0, tileID)];
     if (this._renderWorldCopies) {
-      const utl = this.pointCoordinate(new Point(0, 0), 0);
-      const utr = this.pointCoordinate(new Point(this.width, 0), 0);
-      const ubl = this.pointCoordinate(new Point(this.width, this.height), 0);
-      const ubr = this.pointCoordinate(new Point(0, this.height), 0);
+      const utl = this.pointCoordinate({ x: 0, y: 0 }, 0);
+      const utr = this.pointCoordinate({ x: this.width, y: 0 }, 0);
+      const ubl = this.pointCoordinate({ x: this.width, y: this.height }, 0);
+      const ubr = this.pointCoordinate({ x: 0, y: this.height }, 0);
       const w0 = Math.floor(Math.min(utl.column, utr.column, ubl.column, ubr.column));
       const w1 = Math.floor(Math.max(utl.column, utr.column, ubl.column, ubr.column));
 
@@ -242,10 +242,10 @@ class Transform {
     const centerCoord = this.pointCoordinate(this.centerPoint, z);
     const centerPoint = new Point(centerCoord.column - 0.5, centerCoord.row - 0.5);
     const cornerCoords = [
-      this.pointCoordinate(new Point(0, 0), z),
-      this.pointCoordinate(new Point(this.width, 0), z),
-      this.pointCoordinate(new Point(this.width, this.height), z),
-      this.pointCoordinate(new Point(0, this.height), z)
+      this.pointCoordinate({ x: 0, y: 0 }, z),
+      this.pointCoordinate({ x: this.width, y: 0 }, z),
+      this.pointCoordinate({ x: this.width, y: this.height }, z),
+      this.pointCoordinate({ x: 0, y: this.height }, z)
     ];
     return tileCover(z, cornerCoords, options.reparseOverscaled ? actualZ : z, this._renderWorldCopies).sort(
       (a, b) => centerPoint.dist(a.canonical) - centerPoint.dist(b.canonical)
@@ -472,7 +472,7 @@ class Transform {
     const s = Math.max(sx || 0, sy || 0);
 
     if (s) {
-      this.center = this.unproject(new Point(sx ? (maxX + minX) / 2 : this.x, sy ? (maxY + minY) / 2 : this.y));
+      this.center = this.unproject({ x: sx ? (maxX + minX) / 2 : this.x, y: sy ? (maxY + minY) / 2 : this.y });
       this.zoom += this.scaleZoom(s);
       this._unmodified = unmodified;
       this._constraining = false;
@@ -505,7 +505,7 @@ class Transform {
 
     // pan the map if the screen goes off the range
     if (x2 !== undefined || y2 !== undefined) {
-      this.center = this.unproject(new Point(x2 !== undefined ? x2 : this.x, y2 !== undefined ? y2 : this.y));
+      this.center = this.unproject({ x: x2 ?? this.x, y: y2 ?? this.y });
     }
 
     this._unmodified = unmodified;
@@ -592,7 +592,7 @@ class Transform {
       return 1;
     }
 
-    const coord = this.pointCoordinate(new Point(0, 0)).zoomTo(this.zoom);
+    const coord = this.pointCoordinate({ x: 0, y: 0 }).zoomTo(this.zoom);
     const p = [coord.column * this.tileSize, coord.row * this.tileSize, 0, 1];
     const topPoint = vec4.transformMat4(p, p, this.pixelMatrix);
     return topPoint[3] / this.cameraToCenterDistance;
@@ -612,7 +612,7 @@ class Transform {
   getCameraPoint() {
     const pitch = this._pitch;
     const yOffset = Math.tan(pitch) * (this.cameraToCenterDistance || 1);
-    return this.centerPoint.add(new Point(0, yOffset));
+    return this.centerPoint.add({ x: 0, y: yOffset });
   }
 
   /*

package/src/index.js

@@ -1,7 +1,7 @@
 import './util/polyfill.js';
 
-import { default as Point } from '@mapbox/point-geometry';
 import { Evented } from '@mapwhit/events';
+import { Point } from '@mapwhit/point-geometry';
 import packageJSON from '../package.json' with { type: 'json' };
 import { default as LngLat } from './geo/lng_lat.js';
 import { default as LngLatBounds } from './geo/lng_lat_bounds.js';

package/src/source/geojson_wrapper.js

@@ -1,9 +1,5 @@
-import Point from '@mapbox/point-geometry';
-import { VectorTileFeature } from '@mapwhit/vector-tile';
 import EXTENT from '../data/extent.js';
 
-const { toGeoJSON } = VectorTileFeature.prototype;
-
 // The feature type used by geojson-vt and supercluster. Should be extracted to
 // global type and used in module definitions for those two modules.
 
@@ -47,10 +43,6 @@ class FeatureWrapper {
       ? this._feature.geometry.map(p => [makePoint(p)])
       : this._feature.geometry.map(ring => ring.map(makePoint));
   }
-
-  toGeoJSON(x, y, z) {
-    return toGeoJSON.call(this, x, y, z);
-  }
 }
 
 class GeoJSONWrapper {
@@ -79,5 +71,5 @@ class GeoJSONWrapper {
 export default GeoJSONWrapper;
 
 function makePoint(arr) {
-  return new Point(arr[0], arr[1]);
+  return { x: arr[0], y: arr[1] };
 }

package/src/source/query_features.js

@@ -94,7 +94,10 @@ export function queryRenderedSymbols(
       renderedSymbols[queryData.bucketInstanceId],
       queryData.bucketIndex,
       queryData.sourceLayerIndex,
-      params.filter,
+      {
+        filterSpec: params.filter,
+        globalState: params.globalState
+      },
       params.layers,
       styleLayers
     );

package/src/source/rtl_text_plugin.js

@@ -67,7 +67,9 @@ function registerRTLTextPlugin(loadedPlugin) {
   plugin['processBidirectionalText'] = loadedPlugin.processBidirectionalText;
   plugin['processStyledBidirectionalText'] = loadedPlugin.processStyledBidirectionalText;
 
-  _completionCallback();
+  if (_completionCallback) {
+    _completionCallback();
+  }
   _loadedCallbacks.forEach(callback => callback());
   _loadedCallbacks.length = 0;
 }

package/src/source/source_cache.js

@@ -1,5 +1,5 @@
-import Point from '@mapbox/point-geometry';
 import { ErrorEvent, Event, Evented } from '@mapwhit/events';
+import { Point } from '@mapwhit/point-geometry';
 import EXTENT from '../data/extent.js';
 import Coordinate from '../geo/coordinate.js';
 import browser from '../util/browser.js';
@@ -162,8 +162,8 @@ class SourceCache extends Evented {
       if (zDiff !== 0) {
         return zDiff;
       }
-      const rotatedA = new Point(a.canonical.x, a.canonical.y).rotate(angle);
-      const rotatedB = new Point(b.canonical.x, b.canonical.y).rotate(angle);
+      const rotatedA = Point.clone(a.canonical)._rotate(angle);
+      const rotatedB = Point.clone(b.canonical)._rotate(angle);
       return rotatedB.y - rotatedA.y || rotatedB.x - rotatedA.x;
     }
   }

package/src/source/tile.js

@@ -204,7 +204,7 @@ class Tile {
       return;
     }
 
-    const filter = featureFilter(params?.filter);
+    const filter = featureFilter(params?.filter, params?.globalState);
     const { z, x, y } = this.tileID.canonical;
     const coord = { z, x, y };
 

package/src/style/evaluation_parameters.js

@@ -6,6 +6,7 @@ export default class EvaluationParameters {
   // "options" may also be another EvaluationParameters to copy, see CrossFadedProperty.possiblyEvaluate
   constructor(zoom, options) {
     this.zoom = zoom;
+    this.isSupportedScript = isSupportedScript;
 
     if (options) {
       this.now = options.now || 0;
@@ -20,10 +21,6 @@ export default class EvaluationParameters {
     }
   }
 
-  isSupportedScript(str) {
-    return isStringInSupportedScript(str, rtlTextPlugin.isLoaded());
-  }
-
   crossFadingFactor() {
     if (this.fadeDuration === 0) {
       return 1;
@@ -41,3 +38,7 @@ export default class EvaluationParameters {
       : { fromScale: 0.5, toScale: 1, t: 1 - (1 - t) * fraction };
   }
 }
+
+function isSupportedScript(str) {
+  return isStringInSupportedScript(str, rtlTextPlugin.isLoaded());
+}