@mapbox/mapbox-gl-style-spec 13.28.0 → 14.0.0-beta.1

package/expression/definitions/index.js

@@ -14,7 +14,7 @@ import {
     toString as typeToString
 } from '../types.js';
 
-import {typeOf, Color, validateRGBA, toString as valueToString} from '../values.js';
+import {typeOf, Color, validateRGBA, validateHSLA, toString as valueToString} from '../values.js';
 import CompoundExpression from '../compound_expression.js';
 import RuntimeError from '../runtime_error.js';
 import Let from './let.js';
@@ -45,9 +45,12 @@ import FormatExpression from './format.js';
 import ImageExpression from './image.js';
 import Length from './length.js';
 import Within from './within.js';
+import Distance from './distance.js';
 
+import type EvaluationContext from '../evaluation_context.js';
 import type {Varargs} from '../compound_expression.js';
-import type {ExpressionRegistry} from '../expression.js';
+import type {Expression, ExpressionRegistry} from '../expression.js';
+import {mulberry32} from '../../util/random.js';
 
 const expressions: ExpressionRegistry = {
     // special forms
@@ -57,38 +60,60 @@ const expressions: ExpressionRegistry = {
     '<': LessThan,
     '>=': GreaterThanOrEqual,
     '<=': LessThanOrEqual,
+    // $FlowFixMe[method-unbinding]
     'array': Assertion,
+    // $FlowFixMe[method-unbinding]
     'at': At,
     'boolean': Assertion,
+    // $FlowFixMe[method-unbinding]
     'case': Case,
+    // $FlowFixMe[method-unbinding]
     'coalesce': Coalesce,
+    // $FlowFixMe[method-unbinding]
     'collator': CollatorExpression,
+    // $FlowFixMe[method-unbinding]
     'format': FormatExpression,
+    // $FlowFixMe[method-unbinding]
     'image': ImageExpression,
+    // $FlowFixMe[method-unbinding]
     'in': In,
+    // $FlowFixMe[method-unbinding]
     'index-of': IndexOf,
+    // $FlowFixMe[method-unbinding]
     'interpolate': Interpolate,
     'interpolate-hcl': Interpolate,
     'interpolate-lab': Interpolate,
+    // $FlowFixMe[method-unbinding]
     'length': Length,
+    // $FlowFixMe[method-unbinding]
     'let': Let,
+    // $FlowFixMe[method-unbinding]
     'literal': Literal,
+    // $FlowFixMe[method-unbinding]
     'match': Match,
     'number': Assertion,
+    // $FlowFixMe[method-unbinding]
     'number-format': NumberFormat,
     'object': Assertion,
+    // $FlowFixMe[method-unbinding]
     'slice': Slice,
+    // $FlowFixMe[method-unbinding]
     'step': Step,
     'string': Assertion,
+    // $FlowFixMe[method-unbinding]
     'to-boolean': Coercion,
     'to-color': Coercion,
     'to-number': Coercion,
     'to-string': Coercion,
+    // $FlowFixMe[method-unbinding]
     'var': Var,
-    'within': Within
+    // $FlowFixMe[method-unbinding]
+    'within': Within,
+    // $FlowFixMe[method-unbinding]
+    'distance': Distance
 };
 
-function rgba(ctx, [r, g, b, a]) {
+function rgba(ctx: EvaluationContext, [r, g, b, a]: Array<Expression>) {
     r = r.evaluate(ctx);
     g = g.evaluate(ctx);
     b = b.evaluate(ctx);
@@ -98,16 +123,37 @@ function rgba(ctx, [r, g, b, a]) {
     return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
 }
 
-function has(key, obj) {
+function hsla(ctx: EvaluationContext, [h, s, l, a]: Array<Expression>) {
+    h = h.evaluate(ctx);
+    s = s.evaluate(ctx);
+    l = l.evaluate(ctx);
+    const alpha = a ? a.evaluate(ctx) : 1;
+    const error = validateHSLA(h, s, l, alpha);
+    if (error) throw new RuntimeError(error);
+    const colorFunction = `hsla(${h}, ${s}%, ${l}%, ${alpha})`;
+    const color = Color.parse(colorFunction);
+    if (!color) throw new RuntimeError(`Failed to parse HSLA color: ${colorFunction}`);
+    return color;
+}
+
+function has(key: string, obj: {[string]: any}): boolean {
     return key in obj;
 }
 
-function get(key, obj) {
+function get(key: string, obj: {[string]: any}) {
     const v = obj[key];
     return typeof v === 'undefined' ? null : v;
 }
 
-function binarySearch(v, a, i, j) {
+function getConfig(ctx: EvaluationContext, key: string, scope: string) {
+    if (scope.length) {
+        key += `\u{1f}${scope}`;
+    }
+    const v = ctx.getConfig(key);
+    return v ? v.evaluate(ctx) : null;
+}
+
+function binarySearch(v: any, a: {[number]: any}, i: number, j: number) {
     while (i <= j) {
         const m = (i + j) >> 1;
         if (a[m] === v)
@@ -124,6 +170,19 @@ function varargs(type: Type): Varargs {
     return {type};
 }
 
+function hashString(str: string) {
+    let hash = 0;
+    if (str.length === 0) {
+        return hash;
+    }
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash;
+}
+
 CompoundExpression.register(expressions, {
     'error': [
         ErrorType,
@@ -152,6 +211,16 @@ CompoundExpression.register(expressions, {
         [NumberType, NumberType, NumberType, NumberType],
         rgba
     ],
+    'hsl': [
+        ColorType,
+        [NumberType, NumberType, NumberType],
+        hsla
+    ],
+    'hsla': [
+        ColorType,
+        [NumberType, NumberType, NumberType, NumberType],
+        hsla
+    ],
     'has': {
         type: BooleanType,
         overloads: [
@@ -176,6 +245,18 @@ CompoundExpression.register(expressions, {
             ]
         ]
     },
+    'config': {
+        type: ValueType,
+        overloads: [
+            [
+                [StringType],
+                (ctx, [key]) => getConfig(ctx, key.evaluate(ctx), '')
+            ], [
+                [StringType, StringType],
+                (ctx, [key, scope]) => getConfig(ctx, key.evaluate(ctx), scope.evaluate(ctx))
+            ]
+        ]
+    },
     'feature-state': [
         ValueType,
         [StringType],
@@ -211,6 +292,11 @@ CompoundExpression.register(expressions, {
         [],
         (ctx) => ctx.distanceFromCenter()
     ],
+    'measure-light': [
+        NumberType,
+        [StringType],
+        (ctx, [s]) => ctx.measureLight(s.evaluate(ctx))
+    ],
     'heatmap-density': [
         NumberType,
         [],
@@ -221,6 +307,11 @@ CompoundExpression.register(expressions, {
         [],
         (ctx) => ctx.globals.lineProgress || 0
     ],
+    'raster-value': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.rasterValue || 0
+    ],
     'sky-radial-progress': [
         NumberType,
         [],
@@ -574,7 +665,30 @@ CompoundExpression.register(expressions, {
         StringType,
         [CollatorType],
         (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
-    ]
+    ],
+    'random': [
+        NumberType,
+        [NumberType, NumberType, ValueType],
+        (ctx, args) => {
+            const [min, max, seed] = args.map(arg => arg.evaluate(ctx));
+            if (min > max) {
+                return min;
+            }
+            if (min === max) {
+                return min;
+            }
+            let seedVal;
+            if (typeof seed === 'string') {
+                seedVal = hashString(seed);
+            } else if (typeof seed === 'number') {
+                seedVal = seed;
+            } else {
+                throw new RuntimeError(`Invalid seed input: ${seed}`);
+            }
+            const random = mulberry32(seedVal)();
+            return min + random * (max - min);
+        }
+    ],
 });
 
 export default expressions;

package/expression/definitions/interpolate.js

@@ -252,7 +252,7 @@ class Interpolate implements Expression {
  *
  * @private
 */
-function exponentialInterpolation(input, base, lowerValue, upperValue) {
+function exponentialInterpolation(input: number, base: number, lowerValue: number, upperValue: number) {
     const difference = upperValue - lowerValue;
     const progress = input - lowerValue;
 

package/expression/definitions/match.js

@@ -37,7 +37,7 @@ class Match implements Expression {
             return context.error(`Expected an even number of arguments.`);
 
         let inputType;
-        let outputType;
+        let outputType: ?Type;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
@@ -138,7 +138,7 @@ class Match implements Expression {
             }
         }
 
-        const coerceLabel = (label) => this.inputType.kind === 'number' ? Number(label) : label;
+        const coerceLabel = (label: number | string) => this.inputType.kind === 'number' ? Number(label) : label;
 
         for (const [outputIndex, labels] of groupedByOutput) {
             if (labels.length === 1) {

package/expression/definitions/within.js

@@ -6,22 +6,16 @@ import {BooleanType} from '../types.js';
 import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
-import type {GeoJSON, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
+import type Point from '@mapbox/point-geometry';
+import type {GeoJSON, GeoJSONPosition, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
 import type {CanonicalTileID} from '../../../source/tile_id.js';
+import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util.js';
+import type {BBox} from '../../util/geometry_util.js';
 
 type GeoJSONPolygons =| GeoJSONPolygon | GeoJSONMultiPolygon;
 
-// minX, minY, maxX, maxY
-type BBox = [number, number, number, number];
 const EXTENT = 8192;
 
-function updateBBox(bbox: BBox, coord: [number, number]) {
-    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 mercatorXfromLng(lng: number) {
     return (180 + lng) / 360;
 }
@@ -30,92 +24,27 @@ function mercatorYfromLat(lat: number) {
     return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
 }
 
-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) {
+function getTileCoordinates(p: GeoJSONPosition, canonical: CanonicalTileID) {
     const x = mercatorXfromLng(p[0]);
     const y = mercatorYfromLat(p[1]);
     const tilesAtZoom = Math.pow(2, canonical.z);
     return [Math.round(x * tilesAtZoom * EXTENT), Math.round(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) {
+function pointWithinPolygons(point: GeoJSONPosition, polygons: Array<Array<Array<GeoJSONPosition>>>) {
     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];
-    const det1 = (x1 * y3 - x3 * y1);
-    const det2 =  (x2 * y3 - x3 * y2);
-    if ((det1 > 0 && det2 < 0) || (det1 < 0 && det2 > 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) {
+function lineIntersectPolygon(p1: GeoJSONPosition, p2: GeoJSONPosition, polygon: Array<Array<GeoJSONPosition>>) {
     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])) {
+        for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+            const q1 = ring[k];
+            const q2 = ring[j];
+            if (segmentIntersectSegment(p1, p2, q1, q2)) {
                 return true;
             }
         }
@@ -123,7 +52,7 @@ function lineIntersectPolygon(p1, p2, polygon) {
     return false;
 }
 
-function lineStringWithinPolygon(line, polygon) {
+function lineStringWithinPolygon(line: Array<GeoJSONPosition>, polygon: Array<Array<GeoJSONPosition>>) {
     // 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)) {
@@ -140,14 +69,14 @@ function lineStringWithinPolygon(line, polygon) {
     return true;
 }
 
-function lineStringWithinPolygons(line, polygons) {
+function lineStringWithinPolygons(line: Array<GeoJSONPosition>, polygons: Array<Array<Array<GeoJSONPosition>>>) {
     for (let i = 0; i < polygons.length; i++) {
         if (lineStringWithinPolygon(line, polygons[i])) return true;
     }
     return false;
 }
 
-function getTilePolygon(coordinates, bbox: BBox, canonical: CanonicalTileID) {
+function getTilePolygon(coordinates: Array<Array<GeoJSONPosition>>, bbox: BBox, canonical: CanonicalTileID) {
     const polygon = [];
     for (let i = 0; i < coordinates.length; i++) {
         const ring = [];
@@ -161,7 +90,7 @@ function getTilePolygon(coordinates, bbox: BBox, canonical: CanonicalTileID) {
     return polygon;
 }
 
-function getTilePolygons(coordinates, bbox, canonical: CanonicalTileID) {
+function getTilePolygons(coordinates: Array<Array<Array<GeoJSONPosition>>>, bbox: BBox, canonical: CanonicalTileID) {
     const polygons = [];
     for (let i = 0; i < coordinates.length; i++) {
         const polygon = getTilePolygon(coordinates[i], bbox, canonical);
@@ -170,7 +99,7 @@ function getTilePolygons(coordinates, bbox, canonical: CanonicalTileID) {
     return polygons;
 }
 
-function updatePoint(p, bbox, polyBBox, worldSize) {
+function updatePoint(p: GeoJSONPosition, bbox: BBox, polyBBox: Array<number>, worldSize: number) {
     if (p[0] < polyBBox[0] || p[0] > polyBBox[2]) {
         const halfWorldSize = worldSize * 0.5;
         let shift = (p[0] - polyBBox[0] > halfWorldSize) ? -worldSize : (polyBBox[0] - p[0] > halfWorldSize) ? worldSize : 0;
@@ -182,12 +111,12 @@ function updatePoint(p, bbox, polyBBox, worldSize) {
     updateBBox(bbox, p);
 }
 
-function resetBBox(bbox) {
+function resetBBox(bbox: BBox) {
     bbox[0] = bbox[1] = Infinity;
     bbox[2] = bbox[3] = -Infinity;
 }
 
-function getTilePoints(geometry, pointBBox, polyBBox, canonical: CanonicalTileID) {
+function getTilePoints(geometry: ?Array<Array<Point>>, pointBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints = [];
@@ -202,15 +131,15 @@ function getTilePoints(geometry, pointBBox, polyBBox, canonical: CanonicalTileID
     return tilePoints;
 }
 
-function getTileLines(geometry, lineBBox, polyBBox, canonical: CanonicalTileID) {
+function getTileLines(geometry: ?Array<Array<Point>>, lineBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
-    const tileLines = [];
+    const tileLines: Array<Array<GeoJSONPosition>> = [];
     if (!geometry) return tileLines;
     for (const line of geometry) {
         const tileLine = [];
         for (const point of line) {
-            const p = [point.x + shifts[0], point.y + shifts[1]];
+            const p: GeoJSONPosition = [point.x + shifts[0], point.y + shifts[1]];
             updateBBox(lineBBox, p);
             tileLine.push(p);
         }

package/expression/evaluation_context.js

@@ -1,6 +1,7 @@
 // @flow
 
 import {Color} from './values.js';
+import type {Expression} from './expression.js';
 
 import type Point from '@mapbox/point-geometry';
 import type {FormattedSection} from './types/formatted.js';
@@ -19,10 +20,11 @@ class EvaluationContext {
     canonical: null | CanonicalTileID;
     featureTileCoord: ?Point;
     featureDistanceData: ?FeatureDistanceData;
+    options: ?Map<string, Expression>;
 
     _parseColorCache: {[_: string]: ?Color};
 
-    constructor() {
+    constructor(options?: ?Map<string, Expression>) {
         this.globals = (null: any);
         this.feature = null;
         this.featureState = null;
@@ -32,6 +34,7 @@ class EvaluationContext {
         this.canonical = null;
         this.featureTileCoord = null;
         this.featureDistanceData = null;
+        this.options = options;
     }
 
     id(): number | null {
@@ -54,6 +57,10 @@ class EvaluationContext {
         return (this.feature && this.feature.properties) || {};
     }
 
+    measureLight(_: string): number {
+        return this.globals.brightness || 0;
+    }
+
     distanceFromCenter(): number {
         if (this.featureTileCoord && this.featureDistanceData) {
 
@@ -84,6 +91,10 @@ class EvaluationContext {
         }
         return cached;
     }
+
+    getConfig(id: string): ?Expression {
+        return this.options ? this.options.get(id) : null;
+    }
 }
 
 export default EvaluationContext;