@mapbox/mapbox-gl-style-spec 14.0.0 → 14.1.0

package/expression/compound_expression.js

@@ -21,17 +21,23 @@ class CompoundExpression implements Expression {
     type: Type;
     _evaluate: Evaluate;
     args: Array<Expression>;
+    _overloadIndex: number;
 
     static definitions: {[_: string]: Definition };
 
-    constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>) {
+    constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>, overloadIndex: number) {
         this.name = name;
         this.type = type;
         this._evaluate = evaluate;
         this.args = args;
+        this._overloadIndex = overloadIndex;
     }
 
     evaluate(ctx: EvaluationContext): Value {
+        if (!this._evaluate) { // restore evaluate function after transfer between threads
+            const definition = CompoundExpression.definitions[this.name];
+            this._evaluate = Array.isArray(definition) ? definition[2] : definition.overloads[this._overloadIndex][1];
+        }
         return this._evaluate(ctx, this.args);
     }
 
@@ -62,14 +68,18 @@ class CompoundExpression implements Expression {
             [[definition[1], definition[2]]] :
             definition.overloads;
 
-        const overloads = availableOverloads.filter(([signature]) => (
-            !Array.isArray(signature) || // varags
-            signature.length === args.length - 1 // correct param count
-        ));
+        const overloadParams = [];
 
         let signatureContext: ParsingContext = (null: any);
 
-        for (const [params, evaluate] of overloads) {
+        let overloadIndex = -1;
+
+        for (const [params, evaluate] of availableOverloads) {
+            if (Array.isArray(params) && params.length !== args.length - 1) continue; // param count doesn't match
+
+            overloadParams.push(params);
+            overloadIndex++;
+
             // Use a fresh context for each attempted signature so that, if
             // we eventually succeed, we haven't polluted `context.errors`.
             signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, undefined, context.options);
@@ -111,19 +121,17 @@ class CompoundExpression implements Expression {
             }
 
             if (signatureContext.errors.length === 0) {
-                return new CompoundExpression(op, type, evaluate, parsedArgs);
+                return new CompoundExpression(op, type, evaluate, parsedArgs, overloadIndex);
             }
         }
 
         assert(!signatureContext || signatureContext.errors.length > 0);
 
-        if (overloads.length === 1) {
+        if (overloadParams.length === 1) {
             context.errors.push(...signatureContext.errors);
         } else {
-            const expected = overloads.length ? overloads : availableOverloads;
-            const signatures = expected
-                .map(([params]) => stringifySignature(params))
-                .join(' | ');
+            const expected = overloadParams.length ? overloadParams : availableOverloads.map(([params]) => params);
+            const signatures = expected.map(stringifySignature).join(' | ');
 
             const actualTypes = [];
             // For error message, re-parse arguments without trying to

package/expression/definitions/index.js

@@ -145,12 +145,57 @@ function get(key: string, obj: {[string]: any}) {
     return typeof v === 'undefined' ? null : v;
 }
 
+function coerceValue(type: 'string' | 'number' | 'boolean' | 'color', value: any): any {
+    switch (type) {
+    case 'string': return String(value);
+    case 'number': return +value;
+    case 'boolean': return !!value;
+    case 'color': return Color.parse(value);
+    }
+    return value;
+}
+
+function clampToAllowedNumber(value: number, min: number | void, max: number | void, step: number | void): number {
+    if (step !== undefined) {
+        value = step * Math.round(value / step);
+    }
+    if (min !== undefined && value < min) {
+        value = min;
+    }
+    if (max !== undefined && value > max) {
+        value = max;
+    }
+    return value;
+}
+
 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;
+    const config = ctx.getConfig(key);
+    if (!config) return null;
+
+    const {type, value, values, minValue, maxValue, stepValue} = config;
+
+    const defaultValue = config.default.evaluate(ctx);
+    let result = value ? value.evaluate(ctx) : defaultValue;
+
+    if (type) result = coerceValue(type, result);
+
+    if (value !== undefined && result !== undefined && values && !values.includes(result)) {
+        result = defaultValue;
+        if (type) result = coerceValue(type, result);
+    }
+
+    if (result !== undefined && (minValue !== undefined || maxValue !== undefined || stepValue !== undefined)) {
+        if (typeof result === 'number') {
+            result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
+        } else if (Array.isArray(result)) {
+            result = result.map((item) => typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
+        }
+    }
+
+    return result;
 }
 
 function binarySearch(v: any, a: {[number]: any}, i: number, j: number) {

package/expression/evaluation_context.js

@@ -1,13 +1,13 @@
 // @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';
 import type {GlobalProperties, Feature, FeatureState} from './index.js';
 import type {CanonicalTileID} from '../../source/tile_id.js';
 import type {FeatureDistanceData} from '../feature_filter/index.js';
+import type {ConfigOptions, ConfigOptionValue} from '../../style/properties.js';
 
 const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
 
@@ -20,11 +20,11 @@ class EvaluationContext {
     canonical: null | CanonicalTileID;
     featureTileCoord: ?Point;
     featureDistanceData: ?FeatureDistanceData;
-    options: ?Map<string, Expression>;
+    options: ?ConfigOptions;
 
     _parseColorCache: {[_: string]: ?Color};
 
-    constructor(options?: ?Map<string, Expression>) {
+    constructor(options?: ?ConfigOptions) {
         this.globals = (null: any);
         this.feature = null;
         this.featureState = null;
@@ -92,7 +92,7 @@ class EvaluationContext {
         return cached;
     }
 
-    getConfig(id: string): ?Expression {
+    getConfig(id: string): ?ConfigOptionValue {
         return this.options ? this.options.get(id) : null;
     }
 }

package/expression/index.js

@@ -33,6 +33,7 @@ import type {FormattedSection} from './types/formatted.js';
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../source/tile_id.js';
 import type {FeatureDistanceData} from '../feature_filter/index.js';
+import type {ConfigOptions} from '../../style/properties.js';
 
 export interface Feature {
     +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
@@ -64,7 +65,7 @@ export class StyleExpression {
     _warningHistory: {[key: string]: boolean};
     _enumValues: ?{[_: string]: any};
 
-    constructor(expression: Expression, propertySpec: ?StylePropertySpecification, options?: ?Map<string, Expression>) {
+    constructor(expression: Expression, propertySpec: ?StylePropertySpecification, options?: ?ConfigOptions) {
         this.expression = expression;
         this._warningHistory = {};
         this._evaluator = new EvaluationContext(options);
@@ -131,7 +132,7 @@ export function isExpression(expression: mixed): boolean {
  *
  * @private
  */
-export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification, options?: ?Map<string, Expression>): Result<StyleExpression, Array<ParsingError>> {
+export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification, options?: ?ConfigOptions): Result<StyleExpression, Array<ParsingError>> {
     const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, options);
 
     // For string-valued properties, coerce to string at the top level rather than asserting.
@@ -248,7 +249,7 @@ export type StylePropertyExpression =
     | CameraExpression
     | CompositeExpression;
 
-export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification, options?: ?Map<string, Expression>): Result<StylePropertyExpression, Array<ParsingError>> {
+export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification, options?: ?ConfigOptions): Result<StylePropertyExpression, Array<ParsingError>> {
     expression = createExpression(expression, propertySpec, options);
     if (expression.result === 'error') {
         return expression;
@@ -330,7 +331,7 @@ export class StylePropertyFunction<T> {
     }
 }
 
-export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification, options?: ?Map<string, Expression>): StylePropertyExpression {
+export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification, options?: ?ConfigOptions): StylePropertyExpression {
     if (isFunction(value)) {
         return (new StylePropertyFunction(value, specification): any);
 

package/expression/parsing_context.js

@@ -16,6 +16,7 @@ import Var from './definitions/var.js';
 
 import type {Expression, ExpressionRegistry} from './expression.js';
 import type {Type} from './types.js';
+import type {ConfigOptions} from '../../style/properties.js';
 
 /**
  * State associated parsing at a given point in an expression tree.
@@ -27,7 +28,7 @@ class ParsingContext {
     key: string;
     scope: Scope;
     errors: Array<ParsingError>;
-    options: ?Map<string, Expression>;
+    options: ?ConfigOptions;
 
     // The expected type of this expression. Provided only to allow Expression
     // implementations to infer argument types: Expression#parse() need not
@@ -41,7 +42,7 @@ class ParsingContext {
         expectedType: ?Type,
         scope: Scope = new Scope(),
         errors: Array<ParsingError> = [],
-        options?: ?Map<string, Expression>
+        options?: ?ConfigOptions
     ) {
         this.registry = registry;
         this.path = path;

package/flow-typed/sinon.js

@@ -9,6 +9,7 @@ declare module "sinon" {
         getCall(i: number): SpyCall
     };
     declare type Stub = {
+        returns(fn: mixed): Spy,
         callsFake(fn: mixed): Spy
     };
     declare class FakeServer {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
   "description": "a specification for mapbox gl styles",
-  "version": "14.0.0",
+  "version": "14.1.0",
   "author": "Mapbox",
   "keywords": [
     "mapbox",