@mapbox/mapbox-gl-style-spec 14.2.0 → 14.3.0

package/expression/definitions/config.js

@@ -0,0 +1,142 @@
+// @flow
+
+import {
+    type Type,
+    ValueType
+} from '../types.js';
+import {Color, typeOf, toString as valueToString} from '../values.js';
+import Formatted from '../types/formatted.js';
+import ResolvedImage from '../types/resolved_image.js';
+import Literal from './literal.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+
+function coerceValue(type: string, value: any): any {
+    switch (type) {
+    case 'string': return valueToString(value);
+    case 'number': return +value;
+    case 'boolean': return !!value;
+    case 'color': return Color.parse(value);
+    case 'formatted': {
+        return Formatted.fromString(valueToString(value));
+    }
+    case 'resolvedImage': {
+        return ResolvedImage.fromString(valueToString(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;
+}
+
+class Config implements Expression {
+    type: Type;
+    key: string;
+    scope: ?string;
+
+    constructor(type: Type, key: string, scope?: string) {
+        this.type = type;
+        this.key = key;
+        this.scope = scope;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Config {
+        let type = context.expectedType;
+        if (type === null || type === undefined) {
+            type = ValueType;
+        }
+        if (args.length < 2 || args.length > 3) {
+            return context.error(`Invalid number of arguments for 'config' expression.`);
+        }
+
+        const configKey = context.parse(args[1], 1);
+        if (!(configKey instanceof Literal)) {
+            return context.error(`Key name of 'config' expression must be a string literal.`);
+        }
+
+        if (args.length >= 3) {
+            const configScope = context.parse(args[2], 2);
+            if (!(configScope instanceof Literal)) {
+                return context.error(`Scope of 'config' expression must be a string literal.`);
+            }
+            return new Config(type, valueToString(configKey.value), valueToString(configScope.value));
+        }
+
+        return new Config(type, valueToString(configKey.value));
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        const FQIDSeparator = '\u001F';
+        const configKey = [this.key, this.scope, ctx.scope].filter(Boolean).join(FQIDSeparator);
+
+        const config = ctx.getConfig(configKey);
+        if (!config) return null;
+
+        const {type, value, values, minValue, maxValue, stepValue} = config;
+
+        const defaultValue = config.default.evaluate(ctx);
+
+        let result = defaultValue;
+        if (value) {
+            // temporarily override scope to parent to evaluate config expressions passed from the parent
+            const originalScope = ctx.scope;
+            ctx.scope = (originalScope || '').split(FQIDSeparator).slice(1).join(FQIDSeparator);
+            result = value.evaluate(ctx);
+            ctx.scope = originalScope;
+        }
+        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);
+            }
+        }
+
+        if (value !== undefined && result !== undefined && values && !values.includes(result)) {
+            // The result is not among the allowed values. Instead, use the default value from the option.
+            result = defaultValue;
+            if (type) {
+                result = coerceValue(type, result);
+            }
+        }
+
+        if ((type && type !== this.type) || (result !== undefined && typeOf(result) !== this.type)) {
+            result = coerceValue(this.type.kind, result);
+        }
+
+        return result;
+    }
+
+    eachChild() { }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        const res = ["config", this.key];
+        if (this.scope) {
+            res.concat(this.key);
+        }
+        return res;
+    }
+}
+
+export default Config;

package/expression/definitions/index.js

@@ -45,6 +45,7 @@ import FormatExpression from './format.js';
 import ImageExpression from './image.js';
 import Length from './length.js';
 import Within from './within.js';
+import Config from './config.js';
 import Distance from './distance.js';
 import {mulberry32} from '../../util/random.js';
 
@@ -110,7 +111,9 @@ const expressions: ExpressionRegistry = {
     // $FlowFixMe[method-unbinding]
     'within': Within,
     // $FlowFixMe[method-unbinding]
-    'distance': Distance
+    'distance': Distance,
+    // $FlowFixMe[method-unbinding]
+    'config': Config
 };
 
 function rgba(ctx: EvaluationContext, [r, g, b, a]: Array<Expression>) {
@@ -145,70 +148,6 @@ 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;
-}
-
-const FQIDSeparator = '\u001F';
-
-function getConfig(ctx: EvaluationContext, key: string, scope: ?string) {
-    // Create a fully qualified key from the requested scope
-    // and the scope from the current evaluation context
-    key = [key, scope, ctx.scope].filter(Boolean).join(FQIDSeparator);
-
-    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 = defaultValue;
-    if (value) {
-        // temporarily override scope to parent to evaluate config expressions passed from the parent
-        const originalScope = ctx.scope;
-        ctx.scope = (originalScope || '').split(FQIDSeparator).slice(1).join(FQIDSeparator);
-        result = value.evaluate(ctx);
-        ctx.scope = originalScope;
-    }
-
-    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) {
     while (i <= j) {
         const m = (i + j) >> 1;
@@ -301,18 +240,6 @@ 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],
@@ -368,6 +295,11 @@ CompoundExpression.register(expressions, {
         [],
         (ctx) => ctx.globals.rasterValue || 0
     ],
+    'raster-particle-speed': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.rasterParticleSpeed || 0
+    ],
     'sky-radial-progress': [
         NumberType,
         [],

package/expression/index.js

@@ -51,6 +51,7 @@ export interface GlobalProperties {
     heatmapDensity?: number,
     lineProgress?: number,
     rasterValue?: number,
+    rasterParticleSpeed?: number,
     skyRadialProgress?: number,
     +isSupportedScript?: (_: string) => boolean,
     accumulated?: Value,

package/expression/is_constant.js

@@ -3,6 +3,7 @@
 import CompoundExpression from './compound_expression.js';
 import Within from './definitions/within.js';
 import Distance from './definitions/distance.js';
+import Config from './definitions/config.js';
 import type {Expression} from './expression.js';
 
 function isFeatureConstant(e: Expression): boolean {
@@ -53,11 +54,10 @@ function isStateConstant(e: Expression): boolean {
 }
 
 function isConfigConstant(e: Expression): boolean {
-    if (e instanceof CompoundExpression) {
-        if (e.name === 'config') {
-            return false;
-        }
+    if (e instanceof Config) {
+        return false;
     }
+
     let result = true;
     e.eachChild(arg => {
         if (result && !isConfigConstant(arg)) { result = false; }

package/expression/parsing_context.js

@@ -11,6 +11,7 @@ import CompoundExpression from './compound_expression.js';
 import CollatorExpression from './definitions/collator.js';
 import Within from './definitions/within.js';
 import Distance from './definitions/distance.js';
+import Config from './definitions/config.js';
 import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant.js';
 import Var from './definitions/var.js';
 
@@ -202,17 +203,17 @@ function isConstant(expression: Expression) {
         return isConstant(expression.boundExpression);
     } else if (expression instanceof CompoundExpression && expression.name === 'error') {
         return false;
-    } else if (expression instanceof CompoundExpression && expression.name === 'config') {
-        return false;
     } else if (expression instanceof CollatorExpression) {
         // Although the results of a Collator expression with fixed arguments
         // 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) {
+    } else if (expression instanceof Within) {
         return false;
     } else if (expression instanceof Distance) {
         return false;
+    } else if (expression instanceof Config) {
+        return false;
     }
 
     const isTypeAnnotation = expression instanceof Coercion ||
@@ -238,5 +239,5 @@ function isConstant(expression: Expression) {
     }
 
     return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light']);
+        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed']);
 }

package/flow-typed/webgl2.js

@@ -24,6 +24,8 @@ declare class WebGL2RenderingContext extends WebGLRenderingContext {
     QUERY_RESULT: 0x8866;
     MIN: 0x8007;
     MAX: 0x8008;
+    INTERLEAVED_ATTRIBS: 0x8C8C;
+    SEPARATE_ATTRIBS: 0x8C8D;
 
     createVertexArray: () => WebGLVertexArrayObject | null;
     deleteVertexArray: (vertexArray: WebGLVertexArrayObject | null) => void;

package/package.json

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

package/reference/v8.json

@@ -912,6 +912,17 @@
       "type": "*",
       "doc": "Contains the description of the raster data layers and the bands contained within the tiles."
     },
+    "volatile": {
+      "type": "boolean",
+      "default": false,
+      "doc": "A setting to determine whether a source's tiles are cached locally.",
+      "sdk-support": {
+        "basic functionality": {
+          "android": "9.3.0",
+          "ios": "5.10.0"
+        }
+      }
+    },
     "*": {
       "type": "*",
       "doc": "Other keys to configure the data source."
@@ -1163,6 +1174,17 @@
             }
           }
         },
+        "raster-particle": {
+          "doc": "Particle animation driven by textures such as wind maps.",
+          "sdk-support": {
+            "basic functionality": {
+              "js": "0.10.0",
+              "android": "2.0.1",
+              "ios": "2.0.0",
+              "macos": "0.1.0"
+            }
+          }
+        },
         "hillshade": {
           "doc": "Client-side hillshading visualization based on DEM data. Currently, the implementation only supports Mapbox Terrain RGB and Mapzen Terrarium tiles.",
           "sdk-support": {
@@ -1273,6 +1295,7 @@
     "layout_fill-extrusion",
     "layout_symbol",
     "layout_raster",
+    "layout_raster-particle",
     "layout_hillshade",
     "layout_background",
     "layout_sky",
@@ -3191,6 +3214,37 @@
       "property-type": "constant"
     }
   },
+  "layout_raster-particle": {
+    "visibility": {
+      "type": "enum",
+      "values": {
+        "visible": {
+          "doc": "The layer is shown."
+        },
+        "none": {
+          "doc": "The layer is not shown."
+        }
+      },
+      "default": "visible",
+      "doc": "Whether this layer is displayed.",
+      "sdk-support": {
+        "basic functionality": {
+          "js": "0.10.0",
+          "android": "2.0.1",
+          "ios": "2.0.0"
+        },
+        "expressions support": {
+          "js": "3.0.0",
+          "android": "11.0.0",
+          "ios": "11.0.0"
+        }
+      },
+      "expression": {
+        "interpolated": false
+      },
+      "property-type": "constant"
+    }
+  },
   "layout_hillshade": {
     "visibility": {
       "type": "enum",
@@ -3739,7 +3793,7 @@
         }
       },
       "image": {
-        "doc": "Returns a [`ResolvedImage`](/mapbox-gl-js/style-spec/types/#resolvedimage) for use in [`icon-image`](/mapbox-gl-js/style-spec/layers/#layout-symbol-icon-image), `*-pattern` entries, and as a section in the [`'format'`](#types-format) expression. A [`'coalesce'`](#coalesce) expression containing `image` expressions will evaluate to the first listed image that is currently in the style. This validation process is synchronous and requires the image to have been added to the style before requesting it in the `'image'` argument.",
+        "doc": "Returns a [`ResolvedImage`](/mapbox-gl-js/style-spec/types/#resolvedimage) for use in [`icon-image`](/mapbox-gl-js/style-spec/layers/#layout-symbol-icon-image), `*-pattern` entries, and as a section in the [`'format'`](#types-format) expression. A [`'coalesce'`](#coalesce) expression containing `image` expressions will evaluate to the first listed image that is currently in the style. This validation process is synchronous and requires the image to have been added to the style before requesting it in the `'image'` argument. To implement crossfading between two images within a symbol layer using the [`icon-image-cross-fade`](/mapbox-gl-js/style-spec/layers/#paint-symbol-icon-image-cross-fade) attribute, include a second image as the second argument in the `'image'` expression.",
         "group": "Types",
         "sdk-support": {
           "basic functionality": {
@@ -4483,6 +4537,17 @@
           }
         }
       },
+      "raster-particle-speed": {
+        "doc": "Returns the length of the particle velocity vector. Can only be used in the `raster-particle-color` property.",
+        "group": "Raster Particle Animation",
+        "sdk-support": {
+          "basic functionality": {
+            "js": "3.3.0",
+            "android": "",
+            "ios": ""
+          }
+        }
+      },
       "random": {
         "doc": "Returns a random value in the specified range (first two input numbers) based on a supplied seed (third input). The seed can be an expression or a constant number or string value.",
         "group": "Math",
@@ -7022,6 +7087,9 @@
           "measure-light"
         ]
       },
+      "requires": [
+        "icon-image"
+      ],
       "sdk-support": {
         "basic functionality": {
           "js": "3.0.0",
@@ -7361,10 +7429,6 @@
     },
     "raster-color-range": {
       "type": "array",
-      "default": [
-        0,
-        1
-      ],
       "length": 2,
       "value": "number",
       "property-type": "data-constant",
@@ -7378,7 +7442,7 @@
           "zoom"
         ]
       },
-      "doc": "When `raster-color` is active, specifies the range over which `raster-color` is tabulated. Units correspond to the computed raster value via `raster-color-mix`.",
+      "doc": "When `raster-color` is active, specifies the range over which `raster-color` is tabulated. Units correspond to the computed raster value via `raster-color-mix`. For `rasterarray` sources, if `raster-color-range` is unspecified, the source's stated data range is used.",
       "example": [
         0.5,
         10
@@ -7575,7 +7639,7 @@
         ]
       },
       "property-type": "data-constant"
-   },
+    },
     "raster-array-band": {
       "type": "string",
       "required": false,
@@ -7598,7 +7662,7 @@
     },
     "raster-elevation": {
       "type": "number",
-      "doc": "Specifies an uniform elevation from the ground, in meters. Only supported with image sources.",
+      "doc": "Specifies an uniform elevation from the ground, in meters.",
       "default": 0,
       "minimum": 0,
       "transition": true,
@@ -7618,6 +7682,133 @@
       "property-type": "data-constant"
     }
   },
+  "paint_raster-particle": {
+    "raster-particle-array-band": {
+      "type": "string",
+      "required": false,
+      "property-type": "data-constant",
+      "transition": false,
+      "doc": "Displayed band of raster array source layer",
+      "example": "band-name",
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      }
+    },
+    "raster-particle-count": {
+      "type": "number",
+      "doc": "Defines the amount of particles per tile.",
+      "default": 512,
+      "minimum": 1,
+      "transition": false,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      },
+      "property-type": "data-constant"
+    },
+    "raster-particle-color": {
+      "type": "color",
+      "doc": "Defines a color map by which to colorize a raster particle layer, parameterized by the `[\"raster-particle-speed\"]` expression and evaluated at 256 uniformly spaced steps over the range specified by `raster-particle-max-speed`.",
+      "transition": false,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        },
+        "data-driven styling": {}
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "raster-particle-speed"
+        ]
+      },
+      "property-type": "color-ramp"
+    },
+    "raster-particle-max-speed": {
+      "type": "number",
+      "doc": "Defines the maximum speed for particles. Velocities with magnitudes equal to or exceeding this value are clamped to the max value.",
+      "default": 1,
+      "minimum": 1,
+      "transition": false,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      },
+      "property-type": "data-constant"
+    },
+    "raster-particle-speed-factor": {
+      "type": "number",
+      "doc": "Defines a coefficient for the speed of particles’ motion.",
+      "default": 0.2,
+      "minimum": 0,
+      "maximum": 1,
+      "transition": true,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
+    },
+    "raster-particle-fade-opacity-factor": {
+      "type": "number",
+      "doc": "Defines defines the opacity coefficient applied to the faded particles in each frame. In practice, this property controls the length of the particle tail.",
+      "default": 0.98,
+      "minimum": 0,
+      "maximum": 1,
+      "transition": true,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
+    },
+    "raster-particle-reset-rate-factor": {
+      "type": "number",
+      "doc": "Defines a coefficient for a time period at which particles will restart at a random position, to avoid degeneration (empty areas without particles).",
+      "default": 0.8,
+      "minimum": 0,
+      "maximum": 1,
+      "transition": false,
+      "sdk-support": {
+        "basic functionality": {
+          "js": "",
+          "android": "",
+          "ios": ""
+        }
+      },
+      "property-type": "data-constant"
+    }
+  },
   "paint_hillshade": {
     "hillshade-illumination-direction": {
       "type": "number",

package/style-spec.js

@@ -1,7 +1,7 @@
 // @flow
 
 type ExpressionType = 'data-driven' | 'color-ramp' | 'data-constant' | 'constant';
-type ExpressionParameters = Array<'zoom' | 'feature' | 'feature-state' | 'heatmap-density' | 'line-progress' | 'raster-value' | 'sky-radial-progress' | 'pitch' | 'distance-from-center' | 'measure-light'>;
+type ExpressionParameters = Array<'zoom' | 'feature' | 'feature-state' | 'heatmap-density' | 'line-progress' | 'raster-value' | 'sky-radial-progress' | 'pitch' | 'distance-from-center' | 'measure-light' | 'raster-particle-speed'>;
 
 export type ExpressionSpecification = {
     interpolated: boolean,