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

package/composite.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 
 export default function (style) {

package/dist/index.cjs

@@ -148,6 +148,17 @@
   			}
   		}
   	},
+  	iconsets: {
+  		experimental: true,
+  		type: "iconsets",
+  		doc: "A collection of icon sets",
+  		"sdk-support": {
+  			"basic functionality": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			}
+  		}
+  	},
   	schema: {
   		type: "schema",
   		doc: "Definition of the schema for configuration options.",
@@ -689,6 +700,51 @@
   		}
   	}
   };
+  var iconsets = {
+  	"*": {
+  		type: "iconset",
+  		doc: "Specification of an icon set. For sprite icon set, a URL must be provided. For `raster-array` source icon set, a source name must be provided."
+  	}
+  };
+  var iconset = [
+  	"iconset_sprite",
+  	"iconset_source"
+  ];
+  var iconset_sprite = {
+  	type: {
+  		required: true,
+  		type: "enum",
+  		values: {
+  			sprite: {
+  				doc: "A sprite icon set."
+  			}
+  		},
+  		doc: "The type of the icon set."
+  	},
+  	url: {
+  		required: true,
+  		type: "string",
+  		doc: "A base URL for retrieving the icon set and metadata. The extension `.pbf` will be automatically appended. The URL must be absolute, containing the [scheme, authority and path components](https://en.wikipedia.org/wiki/URL#Syntax).",
+  		example: "mapbox://sprites/mapbox/bright"
+  	}
+  };
+  var iconset_source = {
+  	type: {
+  		required: true,
+  		type: "enum",
+  		values: {
+  			source: {
+  				doc: "A source icon set."
+  			}
+  		},
+  		doc: "The type of the icon set."
+  	},
+  	source: {
+  		required: true,
+  		type: "string",
+  		doc: "Name of a source of `raster-array` type to be used for the icon set."
+  	}
+  };
   var sources = {
   	"*": {
   		type: "source",
@@ -1669,6 +1725,32 @@
   			interpolated: false
   		},
   		"property-type": "data-constant"
+  	},
+  	"fill-construct-bridge-guard-rail": {
+  		type: "boolean",
+  		doc: "Determines whether bridge guard rails are added for elevated roads.",
+  		"default": "true",
+  		transition: false,
+  		experimental: true,
+  		"private": true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			},
+  			"data-driven styling": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  				"zoom",
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
   	}
   };
   var layout_circle = {
@@ -3884,6 +3966,17 @@
   				}
   			}
   		},
+  		"at-interpolated": {
+  			doc: "Retrieves an item from an array. If the array contains numeric values and the provided index is non-integer, the expression returns an interpolated value between adjacent items.",
+  			group: "Lookup",
+  			"sdk-support": {
+  				"basic functionality": {
+  					js: "3.11.0",
+  					android: "11.12.0",
+  					ios: "11.12.0"
+  				}
+  			}
+  		},
   		"in": {
   			doc: "Determines whether an item exists in an array or a substring exists in a string. In the specific case when the second and third arguments are string literals, you must wrap at least one of them in a [`literal`](#types-literal) expression to hint correct interpretation to the [type system](#type-system).",
   			group: "Lookup",
@@ -4528,7 +4621,7 @@
   			}
   		},
   		sin: {
-  			doc: "Returns the sine of the input.",
+  			doc: "Returns the sine of the input, interpreted as radians.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -4539,7 +4632,7 @@
   			}
   		},
   		cos: {
-  			doc: "Returns the cosine of the input.",
+  			doc: "Returns the cosine of the input, interpreted as radians.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -4550,7 +4643,7 @@
   			}
   		},
   		tan: {
-  			doc: "Returns the tangent of the input.",
+  			doc: "Returns the tangent of the input, interpreted as radians.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -4561,7 +4654,7 @@
   			}
   		},
   		asin: {
-  			doc: "Returns the arcsine of the input.",
+  			doc: "Returns the arcsine of the input, in radians between −π/2 and π/2.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -4572,7 +4665,7 @@
   			}
   		},
   		acos: {
-  			doc: "Returns the arccosine of the input.",
+  			doc: "Returns the arccosine of the input, in radians between −π/2 and π/2.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -4583,7 +4676,7 @@
   			}
   		},
   		atan: {
-  			doc: "Returns the arctangent of the input.",
+  			doc: "Returns the arctangent of the input, in radians between −π/2 and π/2.",
   			group: "Math",
   			"sdk-support": {
   				"basic functionality": {
@@ -6273,6 +6366,60 @@
   			]
   		},
   		"property-type": "data-driven"
+  	},
+  	"fill-bridge-guard-rail-color": {
+  		type: "color",
+  		"default": "rgba(241, 236, 225, 255)",
+  		doc: "The color of bridge guard rail.",
+  		experimental: true,
+  		"private": true,
+  		transition: true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			},
+  			"data-driven styling": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"measure-light",
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
+  	},
+  	"fill-tunnel-structure-color": {
+  		type: "color",
+  		"default": "rgba(241, 236, 225, 255)",
+  		doc: "The color of tunnel structures (tunnel entrance and tunnel walls).",
+  		transition: true,
+  		experimental: true,
+  		"private": true,
+  		"sdk-support": {
+  			"basic functionality": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			},
+  			"data-driven styling": {
+  				android: "11.11.0",
+  				ios: "11.11.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"measure-light",
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
   	}
   };
   var paint_line = {
@@ -9427,6 +9574,10 @@
   	properties_light_directional: properties_light_directional,
   	properties_light_ambient: properties_light_ambient,
   	properties_light_flat: properties_light_flat,
+  	iconsets: iconsets,
+  	iconset: iconset,
+  	iconset_sprite: iconset_sprite,
+  	iconset_source: iconset_source,
   	sources: sources,
   	source: source,
   	source_vector: source_vector,
@@ -14442,12 +14593,8 @@
       return dist;
   }
   function segmentToSegmentDistance(p1, p2, q1, q2, ruler) {
-      const dist1 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-      ruler.pointToSegmentDistance(p1, q1, q2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-      ruler.pointToSegmentDistance(p2, q1, q2));
-      const dist2 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-      ruler.pointToSegmentDistance(q1, p1, p2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-      ruler.pointToSegmentDistance(q2, p1, p2));
+      const dist1 = Math.min(ruler.pointToSegmentDistance(p1, q1, q2), ruler.pointToSegmentDistance(p2, q1, q2));
+      const dist2 = Math.min(ruler.pointToSegmentDistance(q1, p1, p2), ruler.pointToSegmentDistance(q2, p1, p2));
       return Math.min(dist1, dist2);
   }
   function lineToLineDistance(line1, range1, line2, range2, ruler) {
@@ -15547,12 +15694,11 @@
   });
 
   class Interpolate {
-      constructor(type, operator, interpolation, input, dynamicStops, stops) {
+      constructor(type, operator, interpolation, input, stops) {
           this.type = type;
           this.operator = operator;
           this.interpolation = interpolation;
           this.input = input;
-          this.dynamicStops = dynamicStops;
           this.labels = [];
           this.outputs = [];
           for (const [label, expression] of stops) {
@@ -15600,8 +15746,8 @@
           } else {
               return context.error(`Unknown interpolation type ${ String(interpolation[0]) }`, 1, 0);
           }
-          if (args.length - 1 < 3) {
-              return context.error(`Expected at least 3 arguments, but found only ${ args.length - 1 }.`);
+          if (args.length - 1 < 4) {
+              return context.error(`Expected at least 4 arguments, but found only ${ args.length - 1 }.`);
           }
           if (args.length - 1 > 3 && (args.length - 1) % 2 !== 0) {
               return context.error(`Expected an even number of arguments.`);
@@ -15616,12 +15762,6 @@
           } else if (context.expectedType && context.expectedType.kind !== 'value') {
               outputType = context.expectedType;
           }
-          if (args.length - 1 === 3) {
-              const dynamicStops = context.parse(rest[0], 3, ValueType);
-              if (!dynamicStops)
-                  return null;
-              return new Interpolate(outputType, operator, interpolation, input, dynamicStops, stops);
-          }
           for (let i = 0; i < rest.length; i += 2) {
               const label = rest[i];
               const value = rest[i + 1];
@@ -15645,34 +15785,11 @@
           if (outputType.kind !== 'number' && outputType.kind !== 'color' && !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')) {
               return context.error(`Type ${ toString$1(outputType) } is not interpolatable.`);
           }
-          return new Interpolate(outputType, operator, interpolation, input, null, stops);
+          return new Interpolate(outputType, operator, interpolation, input, stops);
       }
       evaluate(ctx) {
-          let labels = this.labels;
-          let outputs = this.outputs;
-          if (this.dynamicStops) {
-              const dynamicStopsValue = this.dynamicStops.evaluate(ctx);
-              if (dynamicStopsValue.length % 2 !== 0) {
-                  throw new RuntimeError('Expected an even number of arguments.');
-              }
-              labels = [];
-              outputs = [];
-              for (let i = 0; i < dynamicStopsValue.length; i += 2) {
-                  const label = dynamicStopsValue[i];
-                  const output = new Literal(NumberType, dynamicStopsValue[i + 1]);
-                  if (typeof label !== 'number') {
-                      throw new RuntimeError('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.');
-                  }
-                  if (labels.length && labels[labels.length - 1] >= label) {
-                      throw new RuntimeError('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.');
-                  }
-                  labels.push(label);
-                  outputs.push(output);
-              }
-              if (labels.length === 0) {
-                  throw new RuntimeError('Expected at least one input/output pair.');
-              }
-          }
+          const labels = this.labels;
+          const outputs = this.outputs;
           if (labels.length === 1) {
               return outputs[0].evaluate(ctx);
           }
@@ -15721,19 +15838,18 @@
                   ];
               }
           } else {
-              interpolation = ['cubic-bezier'].concat(this.interpolation.controlPoints);
+              interpolation = [
+                  'cubic-bezier',
+                  ...this.interpolation.controlPoints
+              ];
           }
           const serialized = [
               this.operator,
               interpolation,
               this.input.serialize()
           ];
-          if (this.dynamicStops) {
-              serialized.push(this.dynamicStops.serialize());
-          } else {
-              for (let i = 0; i < this.labels.length; i++) {
-                  serialized.push(this.labels[i], this.outputs[i].serialize());
-              }
+          for (let i = 0; i < this.labels.length; i++) {
+              serialized.push(this.labels[i], this.outputs[i].serialize());
           }
           return serialized;
       }
@@ -15880,6 +15996,52 @@
           const t = input.type;
           return new At(t.itemType, index, input);
       }
+      evaluate(ctx) {
+          const index = this.index.evaluate(ctx);
+          const array2 = this.input.evaluate(ctx);
+          if (index < 0) {
+              throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
+          }
+          if (index >= array2.length) {
+              throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array2.length - 1 }.`);
+          }
+          if (index !== Math.floor(index)) {
+              throw new RuntimeError(`Array index must be an integer, but found ${ index } instead. Use at-interpolated to retrieve interpolated result with a fractional index.`);
+          }
+          return array2[index];
+      }
+      eachChild(fn) {
+          fn(this.index);
+          fn(this.input);
+      }
+      outputDefined() {
+          return false;
+      }
+      serialize() {
+          return [
+              'at',
+              this.index.serialize(),
+              this.input.serialize()
+          ];
+      }
+  }
+
+  class AtInterpolated {
+      constructor(type, index, input) {
+          this.type = type;
+          this.index = index;
+          this.input = input;
+      }
+      static parse(args, context) {
+          if (args.length !== 3)
+              return context.error(`Expected 2 arguments, but found ${ args.length - 1 } instead.`);
+          const index = context.parse(args[1], 1, NumberType);
+          const input = context.parse(args[2], 2, array$1(context.expectedType || ValueType));
+          if (!index || !input)
+              return null;
+          const t = input.type;
+          return new AtInterpolated(t.itemType, index, input);
+      }
       evaluate(ctx) {
           const index = this.index.evaluate(ctx);
           const array2 = this.input.evaluate(ctx);
@@ -15911,7 +16073,7 @@
       }
       serialize() {
           return [
-              'at',
+              'at-interpolated',
               this.index.serialize(),
               this.input.serialize()
           ];
@@ -16613,6 +16775,7 @@
       '<=': LessThanOrEqual,
       'array': Assertion,
       'at': At,
+      'at-interpolated': AtInterpolated,
       'boolean': Assertion,
       'case': Case,
       'coalesce': Coalesce,
@@ -17647,14 +17810,10 @@
           return error([new ParsingError$1('', '"interpolate" expressions cannot be used with this property')]);
       }
       if (!zoomCurve) {
-          return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-          new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-          new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant));
+          return success(isFeatureConstant$1 && isLineProgressConstant ? new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) : new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant));
       }
       const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : void 0;
-      return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-      new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-      new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant));
+      return success(isFeatureConstant$1 && isLineProgressConstant ? new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) : new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant));
   }
   class StylePropertyFunction {
       constructor(parameters, specification) {
@@ -19993,7 +20152,6 @@ Use an identity property function instead: ${ example }.`)];
                       valueSpec: styleSpec.layer.type,
                       style: options.style,
                       styleSpec: options.styleSpec,
-                      // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'object' does not exist in type 'ValidationOptions'.
                       object: layer,
                       objectKey: 'type'
                   });
@@ -20003,7 +20161,6 @@ Use an identity property function instead: ${ example }.`)];
               },
               layout(options2) {
                   return validateObject({
-                      // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                       layer,
                       key: options2.key,
                       value: options2.value,
@@ -20019,7 +20176,6 @@ Use an identity property function instead: ${ example }.`)];
               },
               paint(options2) {
                   return validateObject({
-                      // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                       layer,
                       key: options2.key,
                       value: options2.value,
@@ -20515,6 +20671,35 @@ Use an identity property function instead: ${ example }.`)];
       return errors;
   }
 
+  function validateIconset(options) {
+      const iconset = options.value;
+      const key = options.key;
+      const styleSpec = options.styleSpec;
+      const style = options.style;
+      if (!iconset.type) {
+          return [new ValidationError(key, iconset, '"type" is required')];
+      }
+      const type = unbundle(iconset.type);
+      let errors = [];
+      errors = errors.concat(validateObject({
+          key,
+          value: iconset,
+          valueSpec: styleSpec[`iconset_${ type }`],
+          style,
+          styleSpec
+      }));
+      if (type === 'source' && iconset.source) {
+          const source = style.sources && style.sources[iconset.source];
+          const sourceType = source && unbundle(source.type);
+          if (!source) {
+              errors.push(new ValidationError(key, iconset.source, `source "${ iconset.source }" not found`));
+          } else if (sourceType !== 'raster-array') {
+              errors.push(new ValidationError(key, iconset.source, `iconset cannot be used with a source of type ${ String(sourceType) }, it only be used with a "raster-array" source type`));
+          }
+      }
+      return errors;
+  }
+
   const VALIDATORS = {
       '*'() {
           return [];
@@ -20538,7 +20723,8 @@ Use an identity property function instead: ${ example }.`)];
       'formatted': validateFormatted,
       'resolvedImage': validateImage,
       'projection': validateProjection,
-      'import': validateImport
+      'import': validateImport,
+      'iconset': validateIconset
   };
   function validate(options, arrayAsExpression = false) {
       const value = options.value;
@@ -20583,7 +20769,6 @@ Use an identity property function instead: ${ example }.`)];
           valueSpec: styleSpec.$root,
           styleSpec,
           style,
-          // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'objectElementValidators' does not exist in type 'ValidationOptions'.
           objectElementValidators: {
               glyphs: validateGlyphsURL,
               '*': () => []