@mapbox/mapbox-gl-style-spec 13.12.0 → 13.13.0

package/expression/definitions/within.js

@@ -0,0 +1,297 @@
+// @flow
+
+import {isValue} from '../values';
+import type {Type} from '../types';
+import {BooleanType} from '../types';
+import type {Expression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {GeoJSON, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
+import MercatorCoordinate from '../../../geo/mercator_coordinate';
+import EXTENT from '../../../data/extent';
+import Point from '@mapbox/point-geometry';
+import type {CanonicalTileID} from '../../../source/tile_id';
+
+type GeoJSONPolygons =| GeoJSONPolygon | GeoJSONMultiPolygon;
+
+// minX, minY, maxX, maxY
+type BBox = [number, number, number, number];
+function updateBBox(bbox: BBox, coord: Point) {
+    bbox[0] = Math.min(bbox[0], coord[0]);
+    bbox[1] = Math.min(bbox[1], coord[1]);
+    bbox[2] = Math.max(bbox[2], coord[0]);
+    bbox[3] = Math.max(bbox[3], coord[1]);
+}
+
+function boxWithinBox(bbox1: BBox, bbox2: BBox) {
+    if (bbox1[0] <= bbox2[0]) return false;
+    if (bbox1[2] >= bbox2[2]) return false;
+    if (bbox1[1] <= bbox2[1]) return false;
+    if (bbox1[3] >= bbox2[3]) return false;
+    return true;
+}
+
+function getTileCoordinates(p, canonical: CanonicalTileID) {
+    const coord = MercatorCoordinate.fromLngLat({lng: p[0], lat: p[1]}, 0);
+    const tilesAtZoom = Math.pow(2, canonical.z);
+    return [Math.round(coord.x * tilesAtZoom * EXTENT), Math.round(coord.y * tilesAtZoom * EXTENT)];
+}
+
+function onBoundary(p, p1, p2) {
+    const x1 = p[0] - p1[0];
+    const y1 = p[1] - p1[1];
+    const x2 = p[0] - p2[0];
+    const y2 = p[1] - p2[1];
+    return (x1 * y2 - x2 * y1 === 0) && (x1 * x2 <= 0) && (y1 * y2 <= 0);
+}
+
+function rayIntersect(p, p1, p2) {
+    return ((p1[1] > p[1]) !== (p2[1] > p[1])) && (p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0]);
+}
+
+// ray casting algorithm for detecting if point is in polygon
+function pointWithinPolygon(point, rings) {
+    let inside = false;
+    for (let i = 0, len = rings.length; i < len; i++) {
+        const ring = rings[i];
+        for (let j = 0, len2 = ring.length; j < len2 - 1; j++) {
+            if (onBoundary(point, ring[j], ring[j + 1])) return false;
+            if (rayIntersect(point, ring[j], ring[j + 1])) inside = !inside;
+        }
+    }
+    return inside;
+}
+
+function pointWithinPolygons(point, polygons) {
+    for (let i = 0; i < polygons.length; i++) {
+        if (pointWithinPolygon(point, polygons[i])) return true;
+    }
+    return false;
+}
+
+function perp(v1, v2) {
+    return (v1[0] * v2[1] - v1[1] * v2[0]);
+}
+
+// check if p1 and p2 are in different sides of line segment q1->q2
+function  twoSided(p1, p2, q1, q2) {
+    // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
+    const x1 = p1[0] - q1[0];
+    const y1 = p1[1] - q1[1];
+    const x2 = p2[0] - q1[0];
+    const y2 = p2[1] - q1[1];
+    const x3 = q2[0] - q1[0];
+    const y3 = q2[1] - q1[1];
+    if ((x1 * y3 - x3 * y1) * (x2 * y3 - x3 * y2) < 0) return true;
+    return false;
+}
+// a, b are end points for line segment1, c and d are end points for line segment2
+function lineIntersectLine(a, b, c, d) {
+    // check if two segments are parallel or not
+    // precondition is end point a, b is inside polygon, if line a->b is
+    // parallel to polygon edge c->d, then a->b won't intersect with c->d
+    const vectorP = [b[0] - a[0], b[1] - a[1]];
+    const vectorQ = [d[0] - c[0], d[1] - c[1]];
+    if (perp(vectorQ, vectorP) === 0) return false;
+
+    // If lines are intersecting with each other, the relative location should be:
+    // a and b lie in different sides of segment c->d
+    // c and d lie in different sides of segment a->b
+    if (twoSided(a, b, c, d) && twoSided(c, d, a, b)) return true;
+    return false;
+}
+
+function lineIntersectPolygon(p1, p2, polygon) {
+    for (const ring of polygon) {
+        // loop through every edge of the ring
+        for (let j = 0; j < ring.length - 1; ++j) {
+            if (lineIntersectLine(p1, p2, ring[j], ring[j + 1])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+function lineStringWithinPolygon(line, polygon) {
+    // First, check if geometry points of line segments are all inside polygon
+    for (let i = 0; i < line.length; ++i) {
+        if (!pointWithinPolygon(line[i], polygon)) {
+            return false;
+        }
+    }
+
+    // Second, check if there is line segment intersecting polygon edge
+    for (let i = 0; i < line.length - 1; ++i) {
+        if (lineIntersectPolygon(line[i], line[i + 1], polygon)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function lineStringWithinPolygons(line, polygons) {
+    for (let i = 0; i < polygons.length; i++) {
+        if (lineStringWithinPolygon(line, polygons[i])) return true;
+    }
+    return false;
+}
+
+function getTilePolygon(coordinates, bbox, canonical) {
+    const polygon = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        const ring = [];
+        for (let j = 0; j < coordinates[i].length; j++) {
+            const coord = getTileCoordinates(coordinates[i][j], canonical);
+            updateBBox(bbox, coord);
+            ring.push(coord);
+        }
+        polygon.push(ring);
+    }
+    return polygon;
+}
+
+function getTilePolygons(coordinates, bbox, canonical) {
+    const polygons = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        const polygon = getTilePolygon(coordinates[i], bbox, canonical);
+        polygons.push(polygon);
+    }
+    return polygons;
+}
+
+function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
+    const pointBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const canonical = ctx.canonicalID();
+    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const tilePoints = [];
+
+    for (const points of ctx.geometry()) {
+        for (const point of points) {
+            const p = [point.x + shifts[0], point.y + shifts[1]];
+            updateBBox(pointBBox, p);
+            tilePoints.push(p);
+        }
+    }
+
+    if (polygonGeometry.type === 'Polygon') {
+        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+        if (!boxWithinBox(pointBBox, polyBBox)) return false;
+
+        for (const point of tilePoints) {
+            if (!pointWithinPolygon(point, tilePolygon)) return false;
+        }
+    }
+
+    if (polygonGeometry.type === 'MultiPolygon') {
+        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+        if (!boxWithinBox(pointBBox, polyBBox)) return false;
+
+        for (const point of tilePoints) {
+            if (!pointWithinPolygons(point, tilePolygons)) return false;
+        }
+    }
+
+    return true;
+}
+
+function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
+    const lineBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+
+    const canonical = ctx.canonicalID();
+    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const tileLines = [];
+
+    for (const line of ctx.geometry()) {
+        const tileLine = [];
+        for (const point of line) {
+            const p = [point.x + shifts[0], point.y + shifts[1]];
+            updateBBox(lineBBox, p);
+            tileLine.push(p);
+        }
+        tileLines.push(tileLine);
+    }
+
+    if (polygonGeometry.type === 'Polygon') {
+        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+        if (!boxWithinBox(lineBBox, polyBBox)) return false;
+
+        for (const line of tileLines) {
+            if (!lineStringWithinPolygon(line, tilePolygon)) return false;
+        }
+    }
+
+    if (polygonGeometry.type === 'MultiPolygon') {
+        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+
+        if (!boxWithinBox(lineBBox, polyBBox)) return false;
+
+        for (const line of tileLines) {
+            if (!lineStringWithinPolygons(line, tilePolygons)) return false;
+        }
+    }
+    return true;
+
+}
+
+class Within implements Expression {
+    type: Type;
+    geojson: GeoJSON
+    geometries: GeoJSONPolygons;
+
+    constructor(geojson: GeoJSON, geometries: GeoJSONPolygons) {
+        this.type = BooleanType;
+        this.geojson = geojson;
+        this.geometries = geometries;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+        if (args.length !== 2)
+            return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
+        if (isValue(args[1])) {
+            const geojson = (args[1]: Object);
+            if (geojson.type === 'FeatureCollection') {
+                for (let i = 0; i < geojson.features.length; ++i) {
+                    const type = geojson.features[i].geometry.type;
+                    if (type === 'Polygon' || type === 'MultiPolygon') {
+                        return new Within(geojson, geojson.features[i].geometry);
+                    }
+                }
+            } else if (geojson.type === 'Feature') {
+                const type = geojson.geometry.type;
+                if (type === 'Polygon' || type === 'MultiPolygon') {
+                    return new Within(geojson, geojson.geometry);
+                }
+            } else if (geojson.type  === 'Polygon' || geojson.type === 'MultiPolygon') {
+                return new Within(geojson, geojson);
+            }
+        }
+        return context.error(`'within' expression requires valid geojson object that contains polygon geometry type.`);
+    }
+
+    evaluate(ctx: EvaluationContext) {
+        if (ctx.geometry() != null && ctx.canonicalID() != null) {
+            if (ctx.geometryType() === 'Point') {
+                return pointsWithinPolygons(ctx, this.geometries);
+            } else if (ctx.geometryType() === 'LineString') {
+                return linesWithinPolygons(ctx, this.geometries);
+            }
+        }
+        return false;
+    }
+
+    eachChild() {}
+
+    outputDefined(): boolean {
+        return true;
+    }
+
+    serialize(): Array<mixed> {
+        return ["within", this.geojson];
+    }
+
+}
+
+export default Within;

package/expression/evaluation_context.js

@@ -3,6 +3,7 @@
 import {Color} from './values';
 import type {FormattedSection} from './types/formatted';
 import type {GlobalProperties, Feature, FeatureState} from './index';
+import type {CanonicalTileID} from '../../source/tile_id';
 
 const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
 
@@ -12,8 +13,9 @@ class EvaluationContext {
     featureState: ?FeatureState;
     formattedSection: ?FormattedSection;
     availableImages: ?Array<string>;
+    canonical: ?CanonicalTileID;
 
-    _parseColorCache: {[string]: ?Color};
+    _parseColorCache: {[_: string]: ?Color};
 
     constructor() {
         this.globals = (null: any);
@@ -22,6 +24,7 @@ class EvaluationContext {
         this.formattedSection = null;
         this._parseColorCache = {};
         this.availableImages = null;
+        this.canonical = null;
     }
 
     id() {
@@ -32,6 +35,14 @@ class EvaluationContext {
         return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
     }
 
+    geometry() {
+        return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
+    }
+
+    canonicalID() {
+        return this.canonical;
+    }
+
     properties() {
         return this.feature && this.feature.properties || {};
     }

package/expression/expression.js

@@ -1,7 +1,6 @@
 // @flow
 
 import type {Type} from './types';
-import type {Value} from './values';
 import type ParsingContext from './parsing_context';
 import type EvaluationContext from './evaluation_context';
 
@@ -16,14 +15,13 @@ export interface Expression {
 
     /**
      * Statically analyze the expression, attempting to enumerate possible outputs. Returns
-     * an array of values plus the sentinel value `undefined`, used to indicate that the
-     * complete set of outputs is statically undecidable.
+     * false if the complete set of outputs is statically undecidable, otherwise true.
      */
-    possibleOutputs(): Array<Value | void>;
+    outputDefined(): boolean;
 
     serialize(): SerializedExpression;
 }
 
 export type ExpressionParser = (args: $ReadOnlyArray<mixed>, context: ParsingContext) => ?Expression;
 export type ExpressionRegistration = Class<Expression> & { +parse: ExpressionParser };
-export type ExpressionRegistry = {[string]: ExpressionRegistration};
+export type ExpressionRegistry = {[_: string]: ExpressionRegistration};

package/expression/index.js

@@ -25,21 +25,24 @@ import type {Result} from '../util/result';
 import type {InterpolationType} from './definitions/interpolate';
 import type {PropertyValueSpecification} from '../types';
 import type {FormattedSection} from './types/formatted';
+import type Point from '@mapbox/point-geometry';
+import type {CanonicalTileID} from '../../source/tile_id';
 
 export type Feature = {
     +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon',
     +id?: any,
-    +properties: {[string]: any},
-    +patterns?: {[string]: {"min": string, "mid": string, "max": string}}
+    +properties: {[_: string]: any},
+    +patterns?: {[_: string]: {"min": string, "mid": string, "max": string}},
+    +geometry?: Array<Array<Point>>
 };
 
-export type FeatureState = {[string]: any};
+export type FeatureState = {[_: string]: any};
 
 export type GlobalProperties = $ReadOnly<{
     zoom: number,
     heatmapDensity?: number,
     lineProgress?: number,
-    isSupportedScript?: (string) => boolean,
+    isSupportedScript?: (_: string) => boolean,
     accumulated?: Value
 }>;
 
@@ -49,7 +52,7 @@ export class StyleExpression {
     _evaluator: EvaluationContext;
     _defaultValue: Value;
     _warningHistory: {[key: string]: boolean};
-    _enumValues: ?{[string]: any};
+    _enumValues: ?{[_: string]: any};
 
     constructor(expression: Expression, propertySpec: ?StylePropertySpecification) {
         this.expression = expression;
@@ -59,20 +62,22 @@ export class StyleExpression {
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
         this._evaluator.featureState = featureState;
+        this._evaluator.canonical = canonical;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection;
 
         return this.expression.evaluate(this._evaluator);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
         this._evaluator.featureState = featureState || null;
+        this._evaluator.canonical = canonical;
         this._evaluator.availableImages = availableImages || null;
         this._evaluator.formattedSection = formattedSection || null;
 
@@ -138,12 +143,12 @@ export class ZoomConstantExpression<Kind: EvaluationKind> {
         this.isStateDependent = kind !== ('constant': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
-        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection);
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
-        return this._styleExpression.evaluate(globals, feature, featureState, availableImages, formattedSection);
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 }
 
@@ -163,12 +168,12 @@ export class ZoomDependentExpression<Kind: EvaluationKind> {
         this.interpolationType = interpolationType;
     }
 
-    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
-        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection);
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
-    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
-        return this._styleExpression.evaluate(globals, feature, featureState, availableImages, formattedSection);
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
     interpolationFactor(input: number, lower: number, upper: number): number {
@@ -182,18 +187,18 @@ export class ZoomDependentExpression<Kind: EvaluationKind> {
 
 export type ConstantExpression = {
     kind: 'constant',
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>) => any,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
 }
 
 export type SourceExpression = {
     kind: 'source',
     isStateDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
 };
 
 export type CameraExpression = {
     kind: 'camera',
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>) => any,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
     +interpolationFactor: (input: number, lower: number, upper: number) => number,
     zoomStops: Array<number>,
     interpolationType: ?InterpolationType
@@ -202,7 +207,7 @@ export type CameraExpression = {
 export type CompositeExpression = {
     kind: 'composite',
     isStateDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
     +interpolationFactor: (input: number, lower: number, upper: number) => number,
     zoomStops: Array<number>,
     interpolationType: ?InterpolationType

package/expression/is_constant.js

@@ -1,7 +1,7 @@
 // @flow
 
 import CompoundExpression from './compound_expression';
-
+import Within from './definitions/within';
 import type {Expression} from './expression.js';
 
 function isFeatureConstant(e: Expression) {
@@ -23,6 +23,10 @@ function isFeatureConstant(e: Expression) {
         }
     }
 
+    if (e instanceof Within) {
+        return false;
+    }
+
     let result = true;
     e.eachChild(arg => {
         if (result && !isFeatureConstant(arg)) { result = false; }

package/expression/parsing_context.js

@@ -9,6 +9,7 @@ import Coercion from './definitions/coercion';
 import EvaluationContext from './evaluation_context';
 import CompoundExpression from './compound_expression';
 import CollatorExpression from './definitions/collator';
+import Within from './definitions/within';
 import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant';
 import Var from './definitions/var';
 
@@ -201,6 +202,8 @@ function isConstant(expression: Expression) {
         // generally shouldn't change between executions, we can't serialize them
         // as constant expressions because results change based on environment.
         return false;
+    } else if (expression instanceof Within) {
+        return false;
     }
 
     const isTypeAnnotation = expression instanceof Coercion ||

package/expression/scope.js

@@ -8,7 +8,7 @@ import type {Expression} from './expression';
  */
 class Scope {
     parent: ?Scope;
-    bindings: {[string]: Expression};
+    bindings: {[_: string]: Expression};
     constructor(parent?: Scope, bindings: Array<[string, Expression]> = []) {
         this.parent = parent;
         this.bindings = {};

package/expression/types/resolved_image.js

@@ -18,7 +18,8 @@ export default class ResolvedImage {
         return this.name;
     }
 
-    static fromString(name: string): ResolvedImage {
+    static fromString(name: string): ResolvedImage | null {
+        if (!name) return null; // treat empty values as no image
         return new ResolvedImage({name, available: false});
     }
 

package/feature_filter/convert.js

@@ -4,7 +4,7 @@ import {isExpressionFilter} from './index';
 
 import type {FilterSpecification} from '../types';
 
-type ExpectedTypes = {[string]: 'string' | 'number' | 'boolean'};
+type ExpectedTypes = {[_: string]: 'string' | 'number' | 'boolean'};
 
 /**
  * Convert the given legacy filter to (the JSON representation of) an

package/feature_filter/index.js

@@ -1,9 +1,11 @@
 // @flow
 
 import {createExpression} from '../expression';
+import type {GlobalProperties, Feature} from '../expression';
+import type {CanonicalTileID} from '../../source/tile_id';
 
-import type {GlobalProperties} from '../expression';
-export type FeatureFilter = (globalProperties: GlobalProperties, feature: VectorTileFeature) => boolean;
+type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => boolean;
+export type FeatureFilter ={filter: FilterExpression, needGeometry: boolean};
 
 export default createFilter;
 export {isExpressionFilter};
@@ -21,7 +23,8 @@ function isExpressionFilter(filter: any) {
         return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
 
     case 'in':
-        return filter.length >= 3 && Array.isArray(filter[2]);
+        return filter.length >= 3 && (typeof filter[1] !== 'string' || Array.isArray(filter[2]));
+
     case '!in':
     case '!has':
     case 'none':
@@ -71,7 +74,7 @@ const filterSpec = {
  */
 function createFilter(filter: any): FeatureFilter {
     if (filter === null || filter === undefined) {
-        return () => true;
+        return {filter: () => true, needGeometry: false};
     }
 
     if (!isExpressionFilter(filter)) {
@@ -82,7 +85,9 @@ function createFilter(filter: any): FeatureFilter {
     if (compiled.result === 'error') {
         throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
     } else {
-        return (globalProperties: GlobalProperties, feature: VectorTileFeature) => compiled.value.evaluate(globalProperties, feature);
+        const needGeometry = Array.isArray(filter) && filter.length !== 0 && filter[0] === 'within';
+        return {filter: (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiled.value.evaluate(globalProperties, feature, {}, canonical),
+            needGeometry};
     }
 }
 

package/flow-typed/vector-tile.js

@@ -3,7 +3,7 @@ import type Point from '@mapbox/point-geometry';
 import type { GeoJSONFeature } from '@mapbox/geojson-types';
 
 declare interface VectorTile {
-    layers: {[string]: VectorTileLayer};
+    layers: {[_: string]: VectorTileLayer};
 }
 
 declare interface VectorTileLayer {
@@ -18,7 +18,7 @@ declare interface VectorTileFeature {
     extent: number;
     type: 1 | 2 | 3;
     id: number;
-    properties: {[string]: string | number | boolean};
+    properties: {[_: string]: string | number | boolean};
 
     loadGeometry(): Array<Array<Point>>;
     toGeoJSON(x: number, y: number, z: number): GeoJSONFeature;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
   "description": "a specification for mapbox gl styles",
-  "version": "13.12.0",
+  "version": "13.13.0",
   "author": "Mapbox",
   "keywords": [
     "mapbox",
@@ -30,6 +30,7 @@
   "dependencies": {
     "@mapbox/jsonlint-lines-primitives": "~2.0.2",
     "@mapbox/unitbezier": "^0.0.0",
+    "@mapbox/point-geometry": "^0.1.0",
     "csscolorparser": "~1.0.2",
     "json-stringify-pretty-compact": "^2.0.0",
     "minimist": "0.0.8",

package/reference/v8.json

@@ -1025,7 +1025,7 @@
     },
     "symbol-sort-key": {
       "type": "number",
-      "doc": "Sorts features in ascending order based on this value. Features with a higher sort key will appear above features with a lower sort key when they overlap. Features with a lower sort key will have priority over other features when doing placement.",
+      "doc": "Sorts features in ascending order based on this value. Features with lower sort keys are drawn and placed first.  When `icon-allow-overlap` or `text-allow-overlap` is `false`, features with a lower sort key will have priority during placement. When `icon-allow-overlap` or `text-allow-overlap` is set to `true`, features with a higher sort key will overlap over features with a lower sort key.",
       "sdk-support": {
         "basic functionality": {
           "js": "0.53.0",
@@ -3454,6 +3454,15 @@
           }
         }
       },
+      "within": {
+        "doc": "Returns `true` if the feature being evaluated is inside the pre-defined geometry boundary, `false` otherwise. The expression has one argument which must be a valid GeoJSON Polygon/Multi-Polygon object. The expression only evaluates on `Point` or `LineString` feature. For `Point` feature, The expression will return false if any point of the feature is on the boundary or outside the boundary. For `LineString` feature, the expression will return false if the line is fully outside the boundary, or the line is partially intersecting the boundary, which means either part of the line is outside of the boundary, or end point of the line lies on the boundary.",
+        "group": "Decision",
+        "sdk-support": {
+          "basic functionality": {
+            "js": "1.9.0"
+          }
+        }
+      },
       "is-supported-script": {
         "doc": "Returns `true` if the input string is expected to render legibly. Returns `false` if the input string contains sections that cannot be rendered without potential loss of meaning (e.g. Indic scripts that require complex text shaping, or right-to-left scripts if the the `mapbox-gl-rtl-text` plugin is not in use in Mapbox GL JS).",
         "group": "String",