@mapbox/mapbox-gl-style-spec 14.11.0-beta.2 → 14.12.0-beta.1

package/dist/index.es.js

@@ -148,6 +148,7 @@ var $root = {
 		doc: "A collection of icon sets",
 		"sdk-support": {
 			"basic functionality": {
+				js: "3.11.0",
 				android: "11.11.0",
 				ios: "11.11.0"
 			}
@@ -1320,6 +1321,13 @@ var layer = {
 					}
 				}
 			},
+			building: {
+				doc: "A procedural 3D building.",
+				"sdk-support": {
+				},
+				experimental: true,
+				"private": true
+			},
 			raster: {
 				doc: "Raster map textures such as satellite imagery.",
 				"sdk-support": {
@@ -1461,6 +1469,7 @@ var layout = [
 	"layout_circle",
 	"layout_heatmap",
 	"layout_fill-extrusion",
+	"layout_building",
 	"layout_symbol",
 	"layout_raster",
 	"layout_raster-particle",
@@ -1858,6 +1867,115 @@ var layout_heatmap = {
 		"property-type": "constant"
 	}
 };
+var layout_building = {
+	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": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "constant"
+	},
+	"building-roof-shape": {
+		type: "enum",
+		values: {
+			flat: {
+				doc: "Use regular extruded buildings with flat roofs."
+			},
+			hipped: {
+				doc: "Use hipped roof for the procedurally generated buildings."
+			},
+			gabled: {
+				doc: "Use gabled roof for the procedurally generated buildings."
+			},
+			parapet: {
+				doc: "Use parapet roof for the procedurally generated buildings."
+			},
+			mansard: {
+				doc: "Use mansard roof for the procedurally generated buildings."
+			},
+			skillion: {
+				doc: "Use skillion roof for the procedurally generated buildings."
+			},
+			pyramidal: {
+				doc: "Use pyramidal roof for the procedurally generated buildings."
+			}
+		},
+		"default": "flat",
+		doc: "Roof type to use for the procedural buildings.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
+	},
+	"building-height": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		units: "meters",
+		doc: "The height of the procedural buildings.",
+		transition: true,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-driven"
+	},
+	"building-base": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		units: "meters",
+		doc: "The height with which to extrude the base of this layer. Must be less than or equal to `building-height`.",
+		transition: true,
+		requires: [
+			"building-height"
+		],
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: false
+		},
+		"property-type": "data-driven"
+	}
+};
 var layout_line = {
 	"line-cap": {
 		type: "enum",
@@ -3799,6 +3917,20 @@ var filter_circle = {
 		]
 	}
 };
+var filter_building = {
+	type: "boolean",
+	doc: "Expression which determines whether or not to display a Polygon. Building layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
+	"default": false,
+	transition: false,
+	"property-type": "data-driven",
+	expression: {
+		interpolated: false,
+		parameters: [
+			"zoom",
+			"feature"
+		]
+	}
+};
 var filter_heatmap = {
 	type: "boolean",
 	doc: "Expression used to determine whether a point is being displayed or not. Heatmap layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
@@ -6104,6 +6236,7 @@ var paint = [
 	"paint_circle",
 	"paint_heatmap",
 	"paint_fill-extrusion",
+	"paint_building",
 	"paint_symbol",
 	"paint_raster",
 	"paint_raster-particle",
@@ -6416,6 +6549,189 @@ var paint_fill = {
 		"property-type": "data-driven"
 	}
 };
+var paint_building = {
+	"building-opacity": {
+		type: "number",
+		"default": 1,
+		minimum: 0,
+		maximum: 1,
+		doc: "The opacity of the entire procedural buildings layer. This is rendered on a per-layer, not per-feature, basis, and data-driven styling is not available.",
+		transition: true,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"property-type": "data-constant"
+	},
+	"building-ambient-occlusion-wall-intensity": {
+		"property-type": "data-constant",
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		"private": true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "Controls the intensity of shading concave angles between walls and building elements, such as facades and rooftop.",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-intensity": {
+		"property-type": "data-constant",
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		maximum: 1,
+		experimental: true,
+		"private": true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "Controls the intensity of shading near ground",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-radius": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 3,
+		minimum: 0,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		transition: true,
+		doc: "The extent of the ambient occlusion effect on the ground beneath the procedural buildings in meters.",
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-ambient-occlusion-ground-attenuation": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 0.69,
+		minimum: 0,
+		maximum: 1,
+		doc: "Provides a control to further fine-tune the look of the ambient occlusion on the ground beneath the procedural buildings. Lower values give the effect a more solid look while higher values make it smoother.",
+		transition: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-vertical-scale": {
+		"property-type": "data-constant",
+		type: "number",
+		experimental: true,
+		"private": true,
+		"default": 1,
+		minimum: 0,
+		doc: "A global multiplier that can be used to scale base and height of the procedural buildings.",
+		transition: true,
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"sdk-support": {
+			"basic functionality": {
+			}
+		}
+	},
+	"building-cast-shadows": {
+		type: "boolean",
+		"default": true,
+		doc: "Enable/Disable shadow casting for this layer",
+		transition: false,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			}
+		},
+		"property-type": "data-constant"
+	},
+	"building-color": {
+		type: "color",
+		"default": "rgba(193, 154, 127, 1)",
+		doc: "Color buildings. This can be styled using different building parts (e.g. windows, wall, roof, etc.). This won't be used if `building-roof-shape` has a value `flat`.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"feature",
+				"feature-state"
+			]
+		},
+		"property-type": "data-driven"
+	},
+	"building-emissive-strength": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		doc: "Controls the intensity of light emitted on the source features.",
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+			},
+			"data-driven styling": {
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"feature",
+				"feature-state",
+				"measure-light"
+			]
+		},
+		"property-type": "data-driven"
+	}
+};
 var paint_line = {
 	"line-opacity": {
 		type: "number",
@@ -9646,6 +9962,7 @@ var v8 = {
 		"property-type": "constant"
 	}
 },
+	layout_building: layout_building,
 	layout_line: layout_line,
 	layout_symbol: layout_symbol,
 	layout_raster: layout_raster,
@@ -9718,6 +10035,7 @@ var v8 = {
 		]
 	}
 },
+	filter_building: filter_building,
 	filter_heatmap: filter_heatmap,
 	filter_operator: filter_operator,
 	geometry_type: geometry_type,
@@ -10472,6 +10790,7 @@ var v8 = {
 		"property-type": "data-constant"
 	}
 },
+	paint_building: paint_building,
 	paint_line: paint_line,
 	paint_circle: paint_circle,
 	paint_heatmap: paint_heatmap,
@@ -12142,11 +12461,15 @@ function array(from, to, t) {
         return number(d, to[i], t);
     });
 }
+function easeIn(x) {
+    return x * x * x * x * x;
+}
 
 var interpolate$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   array: array,
   color: color,
+  easeIn: easeIn,
   number: number
 });
 
@@ -12492,6 +12815,7 @@ class Formatted {
     }
 }
 
+const separator = '\x1F';
 class ImageId {
     constructor(id) {
         if (typeof id === 'string') {
@@ -12505,30 +12829,20 @@ class ImageId {
         return new ImageId(id);
     }
     static toString(id) {
-        return JSON.stringify({
-            name: id.name,
-            iconsetId: id.iconsetId
-        });
+        return id.iconsetId ? `${ id.name }${ separator }${ id.iconsetId }` : id.name;
     }
     static parse(str) {
-        try {
-            const {name, iconsetId} = JSON.parse(str);
-            return new ImageId({
-                name,
-                iconsetId
-            });
-        } catch (e) {
-            return null;
-        }
+        const [name, iconsetId] = str.split(separator);
+        return new ImageId({
+            name,
+            iconsetId
+        });
     }
     static isEqual(a, b) {
         return a.name === b.name && a.iconsetId === b.iconsetId;
     }
     toString() {
-        return JSON.stringify({
-            name: this.name,
-            iconsetId: this.iconsetId
-        });
+        return ImageId.toString(this);
     }
     serialize() {
         return {
@@ -13143,16 +13457,7 @@ class ImageExpression {
             for (const key in params) {
                 if (params[key]) {
                     try {
-                        const color = params[key].evaluate(ctx);
-                        const msg = `Ignoring image parameter "${ key }" with semi-transparent color ${ color.toString() }`;
-                        if (color.a !== 1) {
-                            if (!this._imageWarnHistory[msg]) {
-                                console.warn(msg);
-                                this._imageWarnHistory[msg] = true;
-                            }
-                            continue;
-                        }
-                        result[key] = color;
+                        result[key] = params[key].evaluate(ctx);
                     } catch (err) {
                         continue;
                     }
@@ -13630,6 +13935,306 @@ class CollatorExpression {
     }
 }
 
+var pointGeometry;
+var hasRequiredPointGeometry;
+
+function requirePointGeometry () {
+	if (hasRequiredPointGeometry) return pointGeometry;
+	hasRequiredPointGeometry = 1;
+	pointGeometry = Point;
+	/**
+	 * A standalone point geometry with useful accessor, comparison, and
+	 * modification methods.
+	 *
+	 * @class Point
+	 * @param {Number} x the x-coordinate. this could be longitude or screen
+	 * pixels, or any other sort of unit.
+	 * @param {Number} y the y-coordinate. this could be latitude or screen
+	 * pixels, or any other sort of unit.
+	 * @example
+	 * var point = new Point(-77, 38);
+	 */
+	function Point(x, y) {
+	    this.x = x;
+	    this.y = y;
+	}
+	Point.prototype = {
+	    /**
+	     * Clone this point, returning a new point that can be modified
+	     * without affecting the old one.
+	     * @return {Point} the clone
+	     */
+	    clone: function () {
+	        return new Point(this.x, this.y);
+	    },
+	    /**
+	     * Add this point's x & y coordinates to another point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    add: function (p) {
+	        return this.clone()._add(p);
+	    },
+	    /**
+	     * Subtract this point's x & y coordinates to from point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    sub: function (p) {
+	        return this.clone()._sub(p);
+	    },
+	    /**
+	     * Multiply this point's x & y coordinates by point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    multByPoint: function (p) {
+	        return this.clone()._multByPoint(p);
+	    },
+	    /**
+	     * Divide this point's x & y coordinates by point,
+	     * yielding a new point.
+	     * @param {Point} p the other point
+	     * @return {Point} output point
+	     */
+	    divByPoint: function (p) {
+	        return this.clone()._divByPoint(p);
+	    },
+	    /**
+	     * Multiply this point's x & y coordinates by a factor,
+	     * yielding a new point.
+	     * @param {Point} k factor
+	     * @return {Point} output point
+	     */
+	    mult: function (k) {
+	        return this.clone()._mult(k);
+	    },
+	    /**
+	     * Divide this point's x & y coordinates by a factor,
+	     * yielding a new point.
+	     * @param {Point} k factor
+	     * @return {Point} output point
+	     */
+	    div: function (k) {
+	        return this.clone()._div(k);
+	    },
+	    /**
+	     * Rotate this point around the 0, 0 origin by an angle a,
+	     * given in radians
+	     * @param {Number} a angle to rotate around, in radians
+	     * @return {Point} output point
+	     */
+	    rotate: function (a) {
+	        return this.clone()._rotate(a);
+	    },
+	    /**
+	     * Rotate this point around p point by an angle a,
+	     * given in radians
+	     * @param {Number} a angle to rotate around, in radians
+	     * @param {Point} p Point to rotate around
+	     * @return {Point} output point
+	     */
+	    rotateAround: function (a, p) {
+	        return this.clone()._rotateAround(a, p);
+	    },
+	    /**
+	     * Multiply this point by a 4x1 transformation matrix
+	     * @param {Array<Number>} m transformation matrix
+	     * @return {Point} output point
+	     */
+	    matMult: function (m) {
+	        return this.clone()._matMult(m);
+	    },
+	    /**
+	     * Calculate this point but as a unit vector from 0, 0, meaning
+	     * that the distance from the resulting point to the 0, 0
+	     * coordinate will be equal to 1 and the angle from the resulting
+	     * point to the 0, 0 coordinate will be the same as before.
+	     * @return {Point} unit vector point
+	     */
+	    unit: function () {
+	        return this.clone()._unit();
+	    },
+	    /**
+	     * Compute a perpendicular point, where the new y coordinate
+	     * is the old x coordinate and the new x coordinate is the old y
+	     * coordinate multiplied by -1
+	     * @return {Point} perpendicular point
+	     */
+	    perp: function () {
+	        return this.clone()._perp();
+	    },
+	    /**
+	     * Return a version of this point with the x & y coordinates
+	     * rounded to integers.
+	     * @return {Point} rounded point
+	     */
+	    round: function () {
+	        return this.clone()._round();
+	    },
+	    /**
+	     * Return the magitude of this point: this is the Euclidean
+	     * distance from the 0, 0 coordinate to this point's x and y
+	     * coordinates.
+	     * @return {Number} magnitude
+	     */
+	    mag: function () {
+	        return Math.sqrt(this.x * this.x + this.y * this.y);
+	    },
+	    /**
+	     * Judge whether this point is equal to another point, returning
+	     * true or false.
+	     * @param {Point} other the other point
+	     * @return {boolean} whether the points are equal
+	     */
+	    equals: function (other) {
+	        return this.x === other.x && this.y === other.y;
+	    },
+	    /**
+	     * Calculate the distance from this point to another point
+	     * @param {Point} p the other point
+	     * @return {Number} distance
+	     */
+	    dist: function (p) {
+	        return Math.sqrt(this.distSqr(p));
+	    },
+	    /**
+	     * Calculate the distance from this point to another point,
+	     * without the square root step. Useful if you're comparing
+	     * relative distances.
+	     * @param {Point} p the other point
+	     * @return {Number} distance
+	     */
+	    distSqr: function (p) {
+	        var dx = p.x - this.x, dy = p.y - this.y;
+	        return dx * dx + dy * dy;
+	    },
+	    /**
+	     * Get the angle from the 0, 0 coordinate to this point, in radians
+	     * coordinates.
+	     * @return {Number} angle
+	     */
+	    angle: function () {
+	        return Math.atan2(this.y, this.x);
+	    },
+	    /**
+	     * Get the angle from this point to another point, in radians
+	     * @param {Point} b the other point
+	     * @return {Number} angle
+	     */
+	    angleTo: function (b) {
+	        return Math.atan2(this.y - b.y, this.x - b.x);
+	    },
+	    /**
+	     * Get the angle between this point and another point, in radians
+	     * @param {Point} b the other point
+	     * @return {Number} angle
+	     */
+	    angleWith: function (b) {
+	        return this.angleWithSep(b.x, b.y);
+	    },
+	    /*
+	     * Find the angle of the two vectors, solving the formula for
+	     * the cross product a x b = |a||b|sin(θ) for θ.
+	     * @param {Number} x the x-coordinate
+	     * @param {Number} y the y-coordinate
+	     * @return {Number} the angle in radians
+	     */
+	    angleWithSep: function (x, y) {
+	        return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
+	    },
+	    _matMult: function (m) {
+	        var x = m[0] * this.x + m[1] * this.y, y = m[2] * this.x + m[3] * this.y;
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _add: function (p) {
+	        this.x += p.x;
+	        this.y += p.y;
+	        return this;
+	    },
+	    _sub: function (p) {
+	        this.x -= p.x;
+	        this.y -= p.y;
+	        return this;
+	    },
+	    _mult: function (k) {
+	        this.x *= k;
+	        this.y *= k;
+	        return this;
+	    },
+	    _div: function (k) {
+	        this.x /= k;
+	        this.y /= k;
+	        return this;
+	    },
+	    _multByPoint: function (p) {
+	        this.x *= p.x;
+	        this.y *= p.y;
+	        return this;
+	    },
+	    _divByPoint: function (p) {
+	        this.x /= p.x;
+	        this.y /= p.y;
+	        return this;
+	    },
+	    _unit: function () {
+	        this._div(this.mag());
+	        return this;
+	    },
+	    _perp: function () {
+	        var y = this.y;
+	        this.y = this.x;
+	        this.x = -y;
+	        return this;
+	    },
+	    _rotate: function (angle) {
+	        var cos = Math.cos(angle), sin = Math.sin(angle), x = cos * this.x - sin * this.y, y = sin * this.x + cos * this.y;
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _rotateAround: function (angle, p) {
+	        var cos = Math.cos(angle), sin = Math.sin(angle), x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y), y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
+	        this.x = x;
+	        this.y = y;
+	        return this;
+	    },
+	    _round: function () {
+	        this.x = Math.round(this.x);
+	        this.y = Math.round(this.y);
+	        return this;
+	    }
+	};
+	/**
+	 * Construct a point from an array if necessary, otherwise if the input
+	 * is already a Point, or an unknown type, return it unchanged
+	 * @param {Array<Number>|Point|*} a any kind of input value
+	 * @return {Point} constructed point, or passed-through value.
+	 * @example
+	 * // this
+	 * var point = Point.convert([0, 1]);
+	 * // is equivalent to
+	 * var point = new Point(0, 1);
+	 */
+	Point.convert = function (a) {
+	    if (a instanceof Point) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return new Point(a[0], a[1]);
+	    }
+	    return a;
+	};
+	return pointGeometry;
+}
+
+requirePointGeometry();
+
 function calculateSignedArea(ring) {
     let sum = 0;
     for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
@@ -19050,7 +19655,15 @@ const operations = {
     /**
    * { command: 'updateImport', args: [importId, importSpecification | styleUrl] }
    */
-    updateImport: 'updateImport'
+    updateImport: 'updateImport',
+    /*
+   *  { command: 'addIconset', args: [iconsetId, IconsetSpecification] }
+   */
+    addIconset: 'addIconset',
+    /*
+   *  { command: 'removeIconset', args: [iconsetId] }
+   */
+    removeIconset: 'removeIconset'
 };
 function addSource(sourceId, after, commands) {
     commands.push({
@@ -19357,6 +19970,47 @@ function diffImports(before = [], after = [], commands) {
         });
     }
 }
+function diffIconsets(before, after, commands) {
+    before = before || {};
+    after = after || {};
+    let iconsetId;
+    for (iconsetId in before) {
+        if (!before.hasOwnProperty(iconsetId))
+            continue;
+        if (!after.hasOwnProperty(iconsetId)) {
+            commands.push({
+                command: operations.removeIconset,
+                args: [iconsetId]
+            });
+        }
+    }
+    for (iconsetId in after) {
+        if (!after.hasOwnProperty(iconsetId))
+            continue;
+        const iconset = after[iconsetId];
+        if (!before.hasOwnProperty(iconsetId)) {
+            commands.push({
+                command: operations.addIconset,
+                args: [
+                    iconsetId,
+                    iconset
+                ]
+            });
+        } else if (!deepEqual(before[iconsetId], iconset)) {
+            commands.push({
+                command: operations.removeIconset,
+                args: [iconsetId]
+            });
+            commands.push({
+                command: operations.addIconset,
+                args: [
+                    iconsetId,
+                    iconset
+                ]
+            });
+        }
+    }
+}
 function diffStyles(before, after) {
     if (!before)
         return [{
@@ -19458,6 +20112,9 @@ function diffStyles(before, after) {
                 args: [after.camera]
             });
         }
+        if (!deepEqual(before.iconsets, after.iconsets)) {
+            diffIconsets(before.iconsets, after.iconsets, commands);
+        }
         if (!deepEqual(before['color-theme'], after['color-theme'])) {
             return [{
                     command: operations.setStyle,
@@ -20211,8 +20868,8 @@ function validateLayer(options) {
                     'raster-particle'
                 ].includes(type)) {
                 errors.push(new ValidationError(key, layer.source, `raster-array source can only be used with layer type 'raster'.`));
-            } else if (type === 'line' && layer.paint && (layer.paint['line-gradient'] || layer.paint['line-trim-offset']) && (sourceType !== 'geojson' || !source.lineMetrics)) {
-                errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`));
+            } else if (type === 'line' && layer.paint && (layer.paint['line-gradient'] || layer.paint['line-trim-offset']) && (sourceType === 'geojson' && !source.lineMetrics)) {
+                errors.push(new ValidationError(key, layer, `layer "${ layer.id }" specifies a line-gradient, which requires the GeoJSON source to have \`lineMetrics\` enabled.`));
             } else if (type === 'raster-particle' && sourceType !== 'raster-array') {
                 errors.push(new ValidationError(key, layer.source, `layer "${ layer.id }" requires a 'raster-array' source.`));
             }