@mapbox/mapbox-gl-style-spec 13.22.0-beta.1 → 13.23.0

package/dist/index.cjs

@@ -99,6 +99,21 @@
   			delay: 0
   		}
   	},
+  	projection: {
+  		type: "projection",
+  		doc: "The projection the map should be rendered in. Suported projections are Albers, Equal Earth, Equirectangular (WGS84), Lambert conformal conic, Mercator, Natural Earth, and Winkel Tripel. Terrain, fog, sky and CustomLayerInterface are not supported for projections other than mercator.",
+  		example: {
+  			name: "albers",
+  			center: [
+  				-154,
+  				50
+  			],
+  			parallels: [
+  				55,
+  				65
+  			]
+  		}
+  	},
   	layers: {
   		required: true,
   		type: "array",
@@ -657,7 +672,7 @@
   	},
   	filter: {
   		type: "filter",
-  		doc: "A expression specifying conditions on source features. Only features that match the filter are displayed. Zoom expressions in filters are only evaluated at integer zoom levels. The `feature-state` expression is not supported in filter expressions."
+  		doc: "An expression specifying conditions on source features. Only features that match the filter are displayed. Zoom expressions in filters are only evaluated at integer zoom levels. The `[\"feature-state\", ...]` expression is not supported in filter expressions.  The `[\"pitch\"]` and `[\"distance-from-center\"]` expressions are supported only for filter expressions on the symbol layer."
   	},
   	layout: {
   		type: "layout",
@@ -2481,6 +2496,78 @@
   	value: "*",
   	doc: "A filter selects specific features from a layer."
   };
+  var filter_symbol = {
+  	type: "boolean",
+  	doc: "Expression which determines whether or not to display a symbol. Symbols support dynamic filtering, meaning this expression can 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",
+  			"pitch",
+  			"distance-from-center"
+  		]
+  	}
+  };
+  var filter_fill = {
+  	type: "boolean",
+  	doc: "Expression which determines whether or not to display a polygon. Fill 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_line = {
+  	type: "boolean",
+  	doc: "Expression which determines whether or not to display a Polygon or LineString. Line 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_circle = {
+  	type: "boolean",
+  	doc: "Expression which determines whether or not to display a circle. Circle 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.",
+  	"default": false,
+  	transition: false,
+  	"property-type": "data-driven",
+  	expression: {
+  		interpolated: false,
+  		parameters: [
+  			"zoom",
+  			"feature"
+  		]
+  	}
+  };
   var filter_operator = {
   	type: "enum",
   	values: {
@@ -3010,7 +3097,7 @@
   			}
   		},
   		length: {
-  			doc: "Gets the length of an array or string.",
+  			doc: "Returns the length of an array or string.",
   			group: "Lookup",
   			"sdk-support": {
   				"basic functionality": {
@@ -3022,7 +3109,7 @@
   			}
   		},
   		properties: {
-  			doc: "Gets the feature properties object.  Note that in some cases, it may be more efficient to use [\"get\", \"property_name\"] directly.",
+  			doc: "Returns the feature properties object.  Note that in some cases, it may be more efficient to use `[\"get\", \"property_name\"]` directly.",
   			group: "Feature data",
   			"sdk-support": {
   				"basic functionality": {
@@ -3043,7 +3130,7 @@
   			}
   		},
   		"geometry-type": {
-  			doc: "Gets the feature's geometry type: `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`. `Multi*` feature types are only returned in GeoJSON sources. When working with vector tile sources, use the singular forms.",
+  			doc: "Returns the feature's geometry type: `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`. `Multi*` feature types are only returned in GeoJSON sources. When working with vector tile sources, use the singular forms.",
   			group: "Feature data",
   			"sdk-support": {
   				"basic functionality": {
@@ -3055,7 +3142,7 @@
   			}
   		},
   		id: {
-  			doc: "Gets the feature's id, if it has one.",
+  			doc: "Returns the feature's id, if it has one.",
   			group: "Feature data",
   			"sdk-support": {
   				"basic functionality": {
@@ -3067,8 +3154,8 @@
   			}
   		},
   		zoom: {
-  			doc: "Gets the current zoom level.  Note that in style layout and paint properties, [\"zoom\"] may only appear as the input to a top-level \"step\" or \"interpolate\" expression.",
-  			group: "Zoom",
+  			doc: "Returns the current zoom level.  Note that in style layout and paint properties, [\"zoom\"] may only appear as the input to a top-level \"step\" or \"interpolate\" expression.",
+  			group: "Camera",
   			"sdk-support": {
   				"basic functionality": {
   					js: "0.41.0",
@@ -3078,8 +3165,26 @@
   				}
   			}
   		},
+  		pitch: {
+  			doc: "Returns the current pitch in degrees. `[\"pitch\"]` may only be used in the `filter` expression for a `symbol` layer.",
+  			group: "Camera",
+  			"sdk-support": {
+  				"basic functionality": {
+  					js: "2.6.0"
+  				}
+  			}
+  		},
+  		"distance-from-center": {
+  			doc: "Returns the distance of a `symbol` instance from the center of the map. The distance is measured in pixels divided by the height of the map container. It measures 0 at the center, decreases towards the camera and increase away from the camera. For example, if the height of the map is 1000px, a value of -1 means 1000px away from the center towards the camera, and a value of 1 means a distance of 1000px away from the camera from the center. `[\"distance-from-center\"]` may only be used in the `filter` expression for a `symbol` layer.",
+  			group: "Camera",
+  			"sdk-support": {
+  				"basic functionality": {
+  					js: "2.6.0"
+  				}
+  			}
+  		},
   		"heatmap-density": {
-  			doc: "Gets the kernel density estimation of a pixel in a heatmap layer, which is a relative measure of how many data points are crowded around a particular pixel. Can only be used in the `heatmap-color` property.",
+  			doc: "Returns the kernel density estimation of a pixel in a heatmap layer, which is a relative measure of how many data points are crowded around a particular pixel. Can only be used in the `heatmap-color` property.",
   			group: "Heatmap",
   			"sdk-support": {
   				"basic functionality": {
@@ -3091,7 +3196,7 @@
   			}
   		},
   		"line-progress": {
-  			doc: "Gets the progress along a gradient line. Can only be used in the `line-gradient` property.",
+  			doc: "Returns the progress along a gradient line. Can only be used in the `line-gradient` property.",
   			group: "Feature data",
   			"sdk-support": {
   				"basic functionality": {
@@ -3103,7 +3208,7 @@
   			}
   		},
   		"sky-radial-progress": {
-  			doc: "Gets the distance of a point on the sky from the sun position. Returns 0 at sun position and 1 when the distance reaches `sky-gradient-radius`. Can only be used in the `sky-gradient` property.",
+  			doc: "Returns the distance of a point on the sky from the sun position. Returns 0 at sun position and 1 when the distance reaches `sky-gradient-radius`. Can only be used in the `sky-gradient` property.",
   			group: "sky",
   			"sdk-support": {
   				"basic functionality": {
@@ -3114,7 +3219,7 @@
   			}
   		},
   		accumulated: {
-  			doc: "Gets the value of a cluster property accumulated so far. Can only be used in the `clusterProperties` option of a clustered GeoJSON source.",
+  			doc: "Returns the value of a cluster property accumulated so far. Can only be used in the `clusterProperties` option of a clustered GeoJSON source.",
   			group: "Feature data",
   			"sdk-support": {
   				"basic functionality": {
@@ -3793,6 +3898,92 @@
   		}
   	}
   };
+  var projection = {
+  	name: {
+  		type: "enum",
+  		values: {
+  			albers: {
+  				doc: "An Albers equal-area projection centered on the continental United States. You can configure the projection for a different region by setting `center` and `parallels` properties. You may want to set max bounds to constrain the map to the relevant region."
+  			},
+  			equalEarth: {
+  				doc: "An Equal Earth projection."
+  			},
+  			equirectangular: {
+  				doc: "An Equirectangular projection. This projection is very similar to the Plate Carrée projection."
+  			},
+  			lambertConformalConic: {
+  				doc: "A Lambert conformal conic projection. You can configure the projection for a region by setting `center` and `parallels` properties. You may want to set max bounds to constrain the map to the relevant region."
+  			},
+  			mercator: {
+  				doc: "The Mercator projection is the default projection."
+  			},
+  			naturalEarth: {
+  				doc: "A Natural Earth projection."
+  			},
+  			winkelTripel: {
+  				doc: "A Winkel Tripel projection."
+  			}
+  		},
+  		"default": "mercator",
+  		doc: "The name of the projection to be used for rendering the map.",
+  		required: true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.6.0"
+  			}
+  		}
+  	},
+  	center: {
+  		type: "array",
+  		length: 2,
+  		value: "number",
+  		"property-type": "data-constant",
+  		transition: false,
+  		doc: "The reference longitude and latitude of the projection. `center` takes the form of [lng, lat]. This property is only configurable for conic projections (Albers and Lambert Conformal Conic). All other projections are centered on [0, 0].",
+  		example: [
+  			-96,
+  			37.5
+  		],
+  		requires: [
+  			{
+  				name: [
+  					"albers",
+  					"lambertConformalConic"
+  				]
+  			}
+  		],
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.6.0"
+  			}
+  		}
+  	},
+  	parallels: {
+  		type: "array",
+  		length: 2,
+  		value: "number",
+  		"property-type": "data-constant",
+  		transition: false,
+  		doc: "The standard parallels of the projection, denoting the desired latitude range with minimal distortion. `parallels` takes the form of [lat0, lat1]. This property is only configurable for conic projections (Albers and Lambert Conformal Conic).",
+  		example: [
+  			29.5,
+  			45.5
+  		],
+  		requires: [
+  			{
+  				name: [
+  					"albers",
+  					"lambertConformalConic"
+  				]
+  			}
+  		],
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "2.6.0"
+  			}
+  		}
+  	}
+  };
   var terrain = {
   	source: {
   		type: "string",
@@ -6048,6 +6239,25 @@
   	layout_raster: layout_raster,
   	layout_hillshade: layout_hillshade,
   	filter: filter,
+  	filter_symbol: filter_symbol,
+  	filter_fill: filter_fill,
+  	filter_line: filter_line,
+  	filter_circle: filter_circle,
+  	"filter_fill-extrusion": {
+  	type: "boolean",
+  	doc: "Expression which determines whether or not to display a Polygon. Fill-extrusion 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"
+  		]
+  	}
+  },
+  	filter_heatmap: filter_heatmap,
   	filter_operator: filter_operator,
   	geometry_type: geometry_type,
   	"function": {
@@ -6117,6 +6327,7 @@
   	expression_name: expression_name,
   	fog: fog,
   	light: light,
+  	projection: projection,
   	terrain: terrain,
   	paint: paint,
   	paint_fill: paint_fill,
@@ -9060,6 +9271,8 @@
           this._parseColorCache = {};
           this.availableImages = null;
           this.canonical = null;
+          this.featureTileCoord = null;
+          this.featureDistanceData = null;
       }
       id() {
           return this.feature && 'id' in this.feature ? this.feature.id : null;
@@ -9076,6 +9289,20 @@
       properties() {
           return this.feature && this.feature.properties || {};
       }
+      distanceFromCenter() {
+          if (this.featureTileCoord && this.featureDistanceData) {
+              const c = this.featureDistanceData.center;
+              const scale = this.featureDistanceData.scale;
+              const {x, y} = this.featureTileCoord;
+              const dX = x * scale - c[0];
+              const dY = y * scale - c[1];
+              const bX = this.featureDistanceData.bearing[0];
+              const bY = this.featureDistanceData.bearing[1];
+              const dist = bX * dX + bY * dY;
+              return dist;
+          }
+          return 0;
+      }
       parseColor(input) {
           let cached = this._parseColorCache[input];
           if (!cached) {
@@ -9769,7 +9996,9 @@
           'line-progress',
           'sky-radial-progress',
           'accumulated',
-          'is-supported-script'
+          'is-supported-script',
+          'pitch',
+          'distance-from-center'
       ]);
   }
 
@@ -11251,6 +11480,16 @@
           [],
           ctx => ctx.globals.zoom
       ],
+      'pitch': [
+          NumberType,
+          [],
+          ctx => ctx.globals.pitch || 0
+      ],
+      'distance-from-center': [
+          NumberType,
+          [],
+          ctx => ctx.distanceFromCenter()
+      ],
       'heatmap-density': [
           NumberType,
           [],
@@ -11897,22 +12136,26 @@
           this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
           this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
       }
-      evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData) {
           this._evaluator.globals = globals;
           this._evaluator.feature = feature;
           this._evaluator.featureState = featureState;
           this._evaluator.canonical = canonical;
           this._evaluator.availableImages = availableImages || null;
           this._evaluator.formattedSection = formattedSection;
+          this._evaluator.featureTileCoord = featureTileCoord || null;
+          this._evaluator.featureDistanceData = featureDistanceData || null;
           return this.expression.evaluate(this._evaluator);
       }
-      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData) {
           this._evaluator.globals = globals;
           this._evaluator.feature = feature || null;
           this._evaluator.featureState = featureState || null;
           this._evaluator.canonical = canonical;
           this._evaluator.availableImages = availableImages || null;
           this._evaluator.formattedSection = formattedSection || null;
+          this._evaluator.featureTileCoord = featureTileCoord || null;
+          this._evaluator.featureDistanceData = featureDistanceData || null;
           try {
               const val = this.expression.evaluate(this._evaluator);
               if (val === null || val === undefined || typeof val === 'number' && val !== val) {
@@ -11989,7 +12232,11 @@
       if (!isFeatureConstant$1 && !supportsPropertyExpression(propertySpec)) {
           return error([new ParsingError('', 'data expressions not supported')]);
       }
-      const isZoomConstant = isGlobalPropertyConstant(parsed, ['zoom']);
+      const isZoomConstant = isGlobalPropertyConstant(parsed, [
+          'zoom',
+          'pitch',
+          'distance-from-center'
+      ]);
       if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
           return error([new ParsingError('', 'zoom expressions not supported')]);
       }
@@ -12397,6 +12644,26 @@
       return result;
   }
 
+  function unbundle(value) {
+      if (value instanceof Number || value instanceof String || value instanceof Boolean) {
+          return value.valueOf();
+      } else {
+          return value;
+      }
+  }
+  function deepUnbundle(value) {
+      if (Array.isArray(value)) {
+          return value.map(deepUnbundle);
+      } else if (value instanceof Object && !(value instanceof Number || value instanceof String || value instanceof Boolean)) {
+          const unbundledValue = {};
+          for (const key in value) {
+              unbundledValue[key] = deepUnbundle(value[key]);
+          }
+          return unbundledValue;
+      }
+      return unbundle(value);
+  }
+
   function isExpressionFilter(filter) {
       if (filter === true || filter === false) {
           return true;
@@ -12432,39 +12699,145 @@
           return true;
       }
   }
-  const filterSpec = {
-      'type': 'boolean',
-      'default': false,
-      'transition': false,
-      'property-type': 'data-driven',
-      'expression': {
-          'interpolated': false,
-          'parameters': [
-              'zoom',
-              'feature'
-          ]
-      }
-  };
-  function createFilter(filter) {
+  function createFilter(filter, layerType = 'fill') {
       if (filter === null || filter === undefined) {
           return {
               filter: () => true,
-              needGeometry: false
+              needGeometry: false,
+              needFeature: false
           };
       }
       if (!isExpressionFilter(filter)) {
           filter = convertFilter(filter);
       }
-      const compiled = createExpression(filter, filterSpec);
-      if (compiled.result === 'error') {
-          throw new Error(compiled.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
+      const filterExp = filter;
+      let staticFilter = true;
+      try {
+          staticFilter = extractStaticFilter(filterExp);
+      } catch (e) {
+          console.warn(`Failed to extract static filter. Filter will continue working, but at higher memory usage and slower framerate.
+This is most likely a bug, please report this via https://github.com/mapbox/mapbox-gl-js/issues/new?assignees=&labels=&template=Bug_report.md
+and paste the contents of this message in the report.
+Thank you!
+Filter Expression:
+${ JSON.stringify(filterExp, null, 2) }
+        `);
+      }
+      const filterSpec = v8[`filter_${ layerType }`];
+      const compiledStaticFilter = createExpression(staticFilter, filterSpec);
+      let filterFunc = null;
+      if (compiledStaticFilter.result === 'error') {
+          throw new Error(compiledStaticFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
       } else {
-          const needGeometry = geometryNeeded(filter);
-          return {
-              filter: (globalProperties, feature, canonical) => compiled.value.evaluate(globalProperties, feature, {}, canonical),
-              needGeometry
-          };
+          filterFunc = (globalProperties, feature, canonical) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+      }
+      let dynamicFilterFunc = null;
+      let needFeature = null;
+      if (staticFilter !== filterExp) {
+          const compiledDynamicFilter = createExpression(filterExp, filterSpec);
+          if (compiledDynamicFilter.result === 'error') {
+              throw new Error(compiledDynamicFilter.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
+          } else {
+              dynamicFilterFunc = (globalProperties, feature, canonical, featureTileCoord, featureDistanceData) => compiledDynamicFilter.value.evaluate(globalProperties, feature, {}, canonical, undefined, undefined, featureTileCoord, featureDistanceData);
+              needFeature = !isFeatureConstant(compiledDynamicFilter.value.expression);
+          }
       }
+      filterFunc = filterFunc;
+      const needGeometry = geometryNeeded(staticFilter);
+      return {
+          filter: filterFunc,
+          dynamicFilter: dynamicFilterFunc ? dynamicFilterFunc : undefined,
+          needGeometry,
+          needFeature: !!needFeature
+      };
+  }
+  function extractStaticFilter(filter) {
+      if (!isDynamicFilter(filter)) {
+          return filter;
+      }
+      let result = deepUnbundle(filter);
+      unionDynamicBranches(result);
+      result = collapseDynamicBooleanExpressions(result);
+      return result;
+  }
+  function collapseDynamicBooleanExpressions(expression) {
+      if (!Array.isArray(expression)) {
+          return expression;
+      }
+      const collapsed = collapsedExpression(expression);
+      if (collapsed === true) {
+          return collapsed;
+      } else {
+          return collapsed.map(subExpression => collapseDynamicBooleanExpressions(subExpression));
+      }
+  }
+  function unionDynamicBranches(filter) {
+      let isBranchingDynamically = false;
+      const branches = [];
+      if (filter[0] === 'case') {
+          for (let i = 1; i < filter.length - 1; i += 2) {
+              isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[i]);
+              branches.push(filter[i + 1]);
+          }
+          branches.push(filter[filter.length - 1]);
+      } else if (filter[0] === 'match') {
+          isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
+          for (let i = 2; i < filter.length - 1; i += 2) {
+              branches.push(filter[i + 1]);
+          }
+          branches.push(filter[filter.length - 1]);
+      } else if (filter[0] === 'step') {
+          isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
+          for (let i = 1; i < filter.length - 1; i += 2) {
+              branches.push(filter[i + 1]);
+          }
+      }
+      if (isBranchingDynamically) {
+          filter.length = 0;
+          filter.push('any', ...branches);
+      }
+      for (let i = 1; i < filter.length; i++) {
+          unionDynamicBranches(filter[i]);
+      }
+  }
+  function isDynamicFilter(filter) {
+      if (!Array.isArray(filter)) {
+          return false;
+      }
+      if (isRootExpressionDynamic(filter[0])) {
+          return true;
+      }
+      for (let i = 1; i < filter.length; i++) {
+          const child = filter[i];
+          if (isDynamicFilter(child)) {
+              return true;
+          }
+      }
+      return false;
+  }
+  function isRootExpressionDynamic(expression) {
+      return expression === 'pitch' || expression === 'distance-from-center';
+  }
+  const dynamicConditionExpressions = new Set([
+      'in',
+      '==',
+      '!=',
+      '>',
+      '>=',
+      '<',
+      '<=',
+      'to-boolean'
+  ]);
+  function collapsedExpression(expression) {
+      if (dynamicConditionExpressions.has(expression[0])) {
+          for (let i = 1; i < expression.length; i++) {
+              const param = expression[i];
+              if (isDynamicFilter(param)) {
+                  return true;
+              }
+          }
+      }
+      return expression;
   }
   function compare(a, b) {
       return a < b ? -1 : a > b ? 1 : 0;
@@ -12923,7 +13296,8 @@
       setTransition: 'setTransition',
       setLight: 'setLight',
       setTerrain: 'setTerrain',
-      setFog: 'setFog'
+      setFog: 'setFog',
+      setProjection: 'setProjection'
   };
   function addSource(sourceId, after, commands) {
       commands.push({
@@ -13230,6 +13604,12 @@
                   args: [after.fog]
               });
           }
+          if (!deepEqual(before.projection, after.projection)) {
+              commands.push({
+                  command: operations.setProjection,
+                  args: [after.projection]
+              });
+          }
           const sourcesRemoved = {};
           const removeOrAddSourceCommands = [];
           diffSources(before.sources, after.sources, removeOrAddSourceCommands, sourcesRemoved);
@@ -13304,26 +13684,6 @@
       }
   }
 
-  function unbundle(value) {
-      if (value instanceof Number || value instanceof String || value instanceof Boolean) {
-          return value.valueOf();
-      } else {
-          return value;
-      }
-  }
-  function deepUnbundle(value) {
-      if (Array.isArray(value)) {
-          return value.map(deepUnbundle);
-      } else if (value instanceof Object && !(value instanceof Number || value instanceof String || value instanceof Boolean)) {
-          const unbundledValue = {};
-          for (const key in value) {
-              unbundledValue[key] = deepUnbundle(value[key]);
-          }
-          return unbundledValue;
-      }
-      return unbundle(value);
-  }
-
   function validateObject(options) {
       const key = options.key;
       const object = options.value;
@@ -13628,8 +13988,8 @@
       if (options.expressionContext === 'property' && options.propertyType === 'layout' && !isStateConstant(expressionObj)) {
           return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with layout properties.')];
       }
-      if (options.expressionContext === 'filter' && !isStateConstant(expressionObj)) {
-          return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with filters.')];
+      if (options.expressionContext === 'filter') {
+          return disallowedFilterParameters(expressionObj, options);
       }
       if (options.expressionContext && options.expressionContext.indexOf('cluster') === 0) {
           if (!isGlobalPropertyConstant(expressionObj, [
@@ -13644,6 +14004,30 @@
       }
       return [];
   }
+  function disallowedFilterParameters(e, options) {
+      const disallowedParameters = new Set([
+          'zoom',
+          'feature-state',
+          'pitch',
+          'distance-from-center'
+      ]);
+      for (const param of options.valueSpec.expression.parameters) {
+          disallowedParameters.delete(param);
+      }
+      if (disallowedParameters.size === 0) {
+          return [];
+      }
+      const errors = [];
+      if (e instanceof CompoundExpression) {
+          if (disallowedParameters.has(e.name)) {
+              return [new ValidationError(options.key, options.value, `["${ e.name }"] expression is not supported in a filter for a ${ options.object.type } layer with id: ${ options.object.id }`)];
+          }
+      }
+      e.eachChild(arg => {
+          errors.push(...disallowedFilterParameters(arg, options));
+      });
+      return errors;
+  }
 
   function validateBoolean(options) {
       const value = options.value;
@@ -13687,9 +14071,10 @@
 
   function validateFilter(options) {
       if (isExpressionFilter(deepUnbundle(options.value))) {
+          const layerType = deepUnbundle(options.layerType);
           return validateExpression(extend({}, options, {
               expressionContext: 'filter',
-              valueSpec: { value: 'boolean' }
+              valueSpec: options.styleSpec[`filter_${ layerType || 'fill' }`]
           }));
       } else {
           return validateNonExpressionFilter(options);
@@ -13925,7 +14310,9 @@
                       objectKey: 'type'
                   });
               },
-              filter: validateFilter,
+              filter(options) {
+                  return validateFilter(extend({ layerType: type }, options));
+              },
               layout(options) {
                   return validateObject({
                       layer,
@@ -14221,6 +14608,29 @@
       return validateExpression(options);
   }
 
+  function validateProjection(options) {
+      const projection = options.value;
+      const styleSpec = options.styleSpec;
+      const projectionSpec = styleSpec.projection;
+      const style = options.style;
+      let errors = [];
+      const rootType = getType(projection);
+      if (rootType === 'object') {
+          for (const key in projection) {
+              errors = errors.concat(validate({
+                  key,
+                  value: projection[key],
+                  valueSpec: projectionSpec[key],
+                  style,
+                  styleSpec
+              }));
+          }
+      } else if (rootType !== 'string') {
+          errors = errors.concat([new ValidationError('projection', projection, `object or string expected, ${ rootType } found`)]);
+      }
+      return errors;
+  }
+
   const VALIDATORS = {
       '*'() {
           return [];
@@ -14241,7 +14651,8 @@
       'fog': validateFog,
       'string': validateString,
       'formatted': validateFormatted,
-      'resolvedImage': validateImage
+      'resolvedImage': validateImage,
+      'projection': validateProjection
   };
   function validate(options) {
       const value = options.value;