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

package/dist/index.cjs

@@ -154,6 +154,7 @@
   		doc: "A collection of icon sets",
   		"sdk-support": {
   			"basic functionality": {
+  				js: "3.11.0",
   				android: "11.11.0",
   				ios: "11.11.0"
   			}
@@ -1326,6 +1327,13 @@
   					}
   				}
   			},
+  			building: {
+  				doc: "A procedural 3D building.",
+  				"sdk-support": {
+  				},
+  				experimental: true,
+  				"private": true
+  			},
   			raster: {
   				doc: "Raster map textures such as satellite imagery.",
   				"sdk-support": {
@@ -1467,6 +1475,7 @@
   	"layout_circle",
   	"layout_heatmap",
   	"layout_fill-extrusion",
+  	"layout_building",
   	"layout_symbol",
   	"layout_raster",
   	"layout_raster-particle",
@@ -1864,6 +1873,115 @@
   		"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",
@@ -3805,6 +3923,20 @@
   		]
   	}
   };
+  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.",
@@ -6110,6 +6242,7 @@
   	"paint_circle",
   	"paint_heatmap",
   	"paint_fill-extrusion",
+  	"paint_building",
   	"paint_symbol",
   	"paint_raster",
   	"paint_raster-particle",
@@ -6422,6 +6555,189 @@
   		"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",
@@ -9652,6 +9968,7 @@
   		"property-type": "constant"
   	}
   },
+  	layout_building: layout_building,
   	layout_line: layout_line,
   	layout_symbol: layout_symbol,
   	layout_raster: layout_raster,
@@ -9724,6 +10041,7 @@
   		]
   	}
   },
+  	filter_building: filter_building,
   	filter_heatmap: filter_heatmap,
   	filter_operator: filter_operator,
   	geometry_type: geometry_type,
@@ -10478,6 +10796,7 @@
   		"property-type": "data-constant"
   	}
   },
+  	paint_building: paint_building,
   	paint_line: paint_line,
   	paint_circle: paint_circle,
   	paint_heatmap: paint_heatmap,
@@ -12148,11 +12467,15 @@
           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
   });
 
@@ -12498,6 +12821,7 @@
       }
   }
 
+  const separator = '\x1F';
   class ImageId {
       constructor(id) {
           if (typeof id === 'string') {
@@ -12511,30 +12835,20 @@
           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 {
@@ -13149,16 +13463,7 @@
               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;
                       }
@@ -13636,6 +13941,306 @@
       }
   }
 
+  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++) {
@@ -19056,7 +19661,15 @@ ${ JSON.stringify(filterExp, null, 2) }
       /**
      * { 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({
@@ -19363,6 +19976,47 @@ ${ JSON.stringify(filterExp, null, 2) }
           });
       }
   }
+  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 [{
@@ -19464,6 +20118,9 @@ ${ JSON.stringify(filterExp, null, 2) }
                   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,
@@ -20217,8 +20874,8 @@ Use an identity property function instead: ${ example }.`)];
                       '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.`));
               }