@mapbox/mapbox-gl-style-spec 14.5.0-beta.1 → 14.5.1

package/dist/index.cjs

@@ -4991,6 +4991,7 @@
   	"paint_fill-extrusion",
   	"paint_symbol",
   	"paint_raster",
+  	"paint_raster-particle",
   	"paint_hillshade",
   	"paint_background",
   	"paint_sky",
@@ -5573,7 +5574,7 @@
   	"line-trim-offset": {
   		type: "array",
   		value: "number",
-  		doc: "The line part between [trim-start, trim-end] will be marked as transparent to make a route vanishing effect. The line trim-off offset is based on the whole line range [0.0, 1.0].",
+  		doc: "The line part between [trim-start, trim-end] will be painted using `line-trim-color,` which is transparent by default to produce a route vanishing effect. The line trim-off offset is based on the whole line range [0.0, 1.0].",
   		length: 2,
   		"default": [
   			0,
@@ -5605,6 +5606,81 @@
   		},
   		"property-type": "constant"
   	},
+  	"line-trim-fade-range": {
+  		type: "array",
+  		value: "number",
+  		doc: "The fade range for the trim-start and trim-end points is defined by the `line-trim-offset` property. The first element of the array represents the fade range from the trim-start point toward the end of the line, while the second element defines the fade range from the trim-end point toward the beginning of the line. The fade result is achieved by interpolating between `line-trim-color` and the color specified by the `line-color` or the `line-gradient` property.",
+  		experimental: true,
+  		length: 2,
+  		"default": [
+  			0,
+  			0
+  		],
+  		minimum: [
+  			0,
+  			0
+  		],
+  		maximum: [
+  			1,
+  			1
+  		],
+  		transition: false,
+  		requires: [
+  			"line-trim-offset",
+  			{
+  				source: "geojson",
+  				has: {
+  					lineMetrics: true
+  				}
+  			}
+  		],
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"measure-light"
+  			]
+  		},
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "3.6.0",
+  				android: "11.6.0",
+  				ios: "11.6.0"
+  			}
+  		},
+  		"property-type": "data-constant"
+  	},
+  	"line-trim-color": {
+  		type: "color",
+  		doc: "The color to be used for rendering the trimmed line section that is defined by the `line-trim-offset` property.",
+  		experimental: true,
+  		"default": "transparent",
+  		transition: true,
+  		requires: [
+  			"line-trim-offset",
+  			{
+  				source: "geojson",
+  				has: {
+  					lineMetrics: true
+  				}
+  			}
+  		],
+  		"sdk-support": {
+  			"basic functionality": {
+  				js: "3.6.0",
+  				android: "11.6.0",
+  				ios: "11.6.0"
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"zoom",
+  				"measure-light"
+  			]
+  		},
+  		"property-type": "data-constant"
+  	},
   	"line-emissive-strength": {
   		type: "number",
   		"default": 0,
@@ -6235,11 +6311,11 @@
   		"property-type": "data-driven"
   	},
   	"icon-occlusion-opacity": {
-  		doc: "The opacity at which the icon will be drawn in case of being depth occluded. Not supported on globe zoom levels.",
+  		doc: "The opacity at which the icon will be drawn in case of being depth occluded. Not supported on globe zoom levels. Absent value means behavior prior to this property introduction.",
   		type: "number",
-  		"default": 1,
   		minimum: 0,
   		maximum: 1,
+  		"default": 1,
   		transition: true,
   		requires: [
   			"icon-image"
@@ -6585,10 +6661,10 @@
   	},
   	"text-occlusion-opacity": {
   		type: "number",
-  		doc: "The opacity at which the text will be drawn in case of being depth occluded. Not supported on globe zoom levels.",
-  		"default": 1,
+  		doc: "The opacity at which the text will be drawn in case of being depth occluded. Not supported on globe zoom levels. Absent value means behavior prior to this property introduction.",
   		minimum: 0,
   		maximum: 1,
+  		"default": 1,
   		transition: true,
   		requires: [
   			"text-field"
@@ -12184,7 +12260,6 @@
       }
   }
 
-  /* @flow */
   const factors = {
       kilometers: 1,
       miles: 1000 / 1609.344,
@@ -12204,13 +12279,6 @@
   const RAD = Math.PI / 180;
   /**
    * A collection of very fast approximations to common geodesic measurements. Useful for performance-sensitive code that measures things on a city scale.
-   *
-   * @param {number} lat latitude
-   * @param {string} [units='kilometers']
-   * @returns {CheapRuler}
-   * @example
-   * const ruler = cheapRuler(35.05, 'miles');
-   * //=ruler
    */
   class CheapRuler {
       /**
@@ -12218,7 +12286,7 @@
        *
        * @param {number} y
        * @param {number} z
-       * @param {string} [units='kilometers']
+       * @param {keyof typeof factors} [units='kilometers']
        * @returns {CheapRuler}
        * @example
        * const ruler = cheapRuler.fromTile(1567, 12);
@@ -12243,8 +12311,7 @@
        * Creates a ruler instance for very fast approximations to common geodesic measurements around a certain latitude.
        *
        * @param {number} lat latitude
-       * @param {string} [units='kilometers']
-       * @returns {CheapRuler}
+       * @param {keyof typeof factors} [units='kilometers']
        * @example
        * const ruler = cheapRuler(35.05, 'miles');
        * //=ruler
@@ -12267,8 +12334,8 @@
       /**
        * Given two points of the form [longitude, latitude], returns the distance.
        *
-       * @param {Array<number>} a point [longitude, latitude]
-       * @param {Array<number>} b point [longitude, latitude]
+       * @param {[number, number]} a point [longitude, latitude]
+       * @param {[number, number]} b point [longitude, latitude]
        * @returns {number} distance
        * @example
        * const distance = ruler.distance([30.5, 50.5], [30.51, 50.49]);
@@ -12282,8 +12349,8 @@
       /**
        * Returns the bearing between two points in angles.
        *
-       * @param {Array<number>} a point [longitude, latitude]
-       * @param {Array<number>} b point [longitude, latitude]
+       * @param {[number, number]} a point [longitude, latitude]
+       * @param {[number, number]} b point [longitude, latitude]
        * @returns {number} bearing
        * @example
        * const bearing = ruler.bearing([30.5, 50.5], [30.51, 50.49]);
@@ -12297,10 +12364,10 @@
       /**
        * Returns a new point given distance and bearing from the starting point.
        *
-       * @param {Array<number>} p point [longitude, latitude]
+       * @param {[number, number]} p point [longitude, latitude]
        * @param {number} dist distance
        * @param {number} bearing
-       * @returns {Array<number>} point [longitude, latitude]
+       * @returns {[number, number]} point [longitude, latitude]
        * @example
        * const point = ruler.destination([30.5, 50.5], 0.1, 90);
        * //=point
@@ -12312,10 +12379,10 @@
       /**
        * Returns a new point given easting and northing offsets (in ruler units) from the starting point.
        *
-       * @param {Array<number>} p point [longitude, latitude]
+       * @param {[number, number]} p point [longitude, latitude]
        * @param {number} dx easting
        * @param {number} dy northing
-       * @returns {Array<number>} point [longitude, latitude]
+       * @returns {[number, number]} point [longitude, latitude]
        * @example
        * const point = ruler.offset([30.5, 50.5], 10, 10);
        * //=point
@@ -12329,7 +12396,7 @@
       /**
        * Given a line (an array of points), returns the total line distance.
        *
-       * @param {Array<Array<number>>} points [longitude, latitude]
+       * @param {[number, number][]} points [longitude, latitude]
        * @returns {number} total line distance
        * @example
        * const length = ruler.lineDistance([
@@ -12348,7 +12415,7 @@
       /**
        * Given a polygon (an array of rings, where each ring is an array of points), returns the area.
        *
-       * @param {Array<Array<Array<number>>>} polygon
+       * @param {[number, number][][]} polygon
        * @returns {number} area value in the specified units (square kilometers by default)
        * @example
        * const area = ruler.area([[
@@ -12370,9 +12437,9 @@
       /**
        * Returns the point at a specified distance along the line.
        *
-       * @param {Array<Array<number>>} line
+       * @param {[number, number][]} line
        * @param {number} dist distance
-       * @returns {Array<number>} point [longitude, latitude]
+       * @returns {[number, number]} point [longitude, latitude]
        * @example
        * const point = ruler.along(line, 2.5);
        * //=point
@@ -12395,9 +12462,9 @@
        * Returns the distance from a point `p` to a line segment `a` to `b`.
        *
        * @pointToSegmentDistance
-       * @param {Array<number>} p point [longitude, latitude]
-       * @param {Array<number>} p1 segment point 1 [longitude, latitude]
-       * @param {Array<number>} p2 segment point 2 [longitude, latitude]
+       * @param {[number, number]} p point [longitude, latitude]
+       * @param {[number, number]} a segment point 1 [longitude, latitude]
+       * @param {[number, number]} b segment point 2 [longitude, latitude]
        * @returns {number} distance
        * @example
        * const distance = ruler.pointToSegmentDistance([-67.04, 50.5], [-67.05, 50.57], [-67.03, 50.54]);
@@ -12407,9 +12474,8 @@
           let [x, y] = a;
           let dx = wrap(b[0] - x) * this.kx;
           let dy = (b[1] - y) * this.ky;
-          let t = 0;
           if (dx !== 0 || dy !== 0) {
-              t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
+              const t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
               if (t > 1) {
                   x = b[0];
                   y = b[1];
@@ -12427,16 +12493,19 @@
        * from the given point, index is the start index of the segment with the closest point,
        * and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
        *
-       * @param {Array<Array<number>>} line
-       * @param {Array<number>} p point [longitude, latitude]
-       * @returns {Object} {point, index, t}
+       * @param {[number, number][]} line
+       * @param {[number, number]} p point [longitude, latitude]
+       * @returns {{point: [number, number], index: number, t: number}} {point, index, t}
        * @example
        * const point = ruler.pointOnLine(line, [-67.04, 50.5]).point;
        * //=point
        */
       pointOnLine(line, p) {
           let minDist = Infinity;
-          let minX, minY, minI, minT;
+          let minX = line[0][0];
+          let minY = line[0][1];
+          let minI = 0;
+          let minT = 0;
           for (let i = 0; i < line.length - 1; i++) {
               let x = line[i][0];
               let y = line[i][1];
@@ -12476,10 +12545,10 @@
       /**
        * Returns a part of the given line between the start and the stop points (or their closest points on the line).
        *
-       * @param {Array<number>} start point [longitude, latitude]
-       * @param {Array<number>} stop point [longitude, latitude]
-       * @param {Array<Array<number>>} line
-       * @returns {Array<Array<number>>} line part of a line
+       * @param {[number, number]} start point [longitude, latitude]
+       * @param {[number, number]} stop point [longitude, latitude]
+       * @param {[number, number][]} line
+       * @returns {[number, number][]} line part of a line
        * @example
        * const line2 = ruler.lineSlice([-67.04, 50.5], [-67.05, 50.56], line1);
        * //=line2
@@ -12507,10 +12576,10 @@
       /**
        * Returns a part of the given line between the start and the stop points indicated by distance along the line.
        *
-       * @param {number} start distance
-       * @param {number} stop distance
-       * @param {Array<Array<number>>} line
-       * @returns {Array<Array<number>>} line part of a line
+       * @param {number} start start distance
+       * @param {number} stop stop distance
+       * @param {[number, number][]} line
+       * @returns {[number, number][]} part of a line
        * @example
        * const line2 = ruler.lineSliceAlong(10, 20, line1);
        * //=line2
@@ -12538,9 +12607,9 @@
       /**
        * Given a point, returns a bounding box object ([w, s, e, n]) created from the given point buffered by a given distance.
        *
-       * @param {Array<number>} p point [longitude, latitude]
+       * @param {[number, number]} p point [longitude, latitude]
        * @param {number} buffer
-       * @returns {Array<number>} box object ([w, s, e, n])
+       * @returns {[number, number, number, number]} bbox ([w, s, e, n])
        * @example
        * const bbox = ruler.bufferPoint([30.5, 50.5], 0.01);
        * //=bbox
@@ -12558,9 +12627,9 @@
       /**
        * Given a bounding box, returns the box buffered by a given distance.
        *
-       * @param {Array<number>} box object ([w, s, e, n])
+       * @param {[number, number, number, number]} bbox ([w, s, e, n])
        * @param {number} buffer
-       * @returns {Array<number>} box object ([w, s, e, n])
+       * @returns {[number, number, number, number]} bbox ([w, s, e, n])
        * @example
        * const bbox = ruler.bufferBBox([30.5, 50.5, 31, 51], 0.2);
        * //=bbox
@@ -12578,20 +12647,31 @@
       /**
        * Returns true if the given point is inside in the given bounding box, otherwise false.
        *
-       * @param {Array<number>} p point [longitude, latitude]
-       * @param {Array<number>} box object ([w, s, e, n])
+       * @param {[number, number]} p point [longitude, latitude]
+       * @param {[number, number, number, number]} bbox ([w, s, e, n])
        * @returns {boolean}
        * @example
        * const inside = ruler.insideBBox([30.5, 50.5], [30, 50, 31, 51]);
        * //=inside
        */
       insideBBox(p, bbox) {
+          // eslint-disable-line
           return wrap(p[0] - bbox[0]) >= 0 && wrap(p[0] - bbox[2]) <= 0 && p[1] >= bbox[1] && p[1] <= bbox[3];
       }
   }
+  /**
+   * @param {[number, number]} a
+   * @param {[number, number]} b
+   */
   function equals(a, b) {
       return a[0] === b[0] && a[1] === b[1];
   }
+  /**
+   * @param {[number, number]} a
+   * @param {[number, number]} b
+   * @param {number} t
+   * @returns {[number, number]}
+   */
   function interpolate(a, b, t) {
       const dx = wrap(b[0] - a[0]);
       const dy = b[1] - a[1];
@@ -12600,7 +12680,10 @@
           a[1] + dy * t
       ];
   }
-  // normalize a degree value into [-180..180] range
+  /**
+   * normalize a degree value into [-180..180] range
+   * @param {number} deg
+   */
   function wrap(deg) {
       while (deg < -180)
           deg += 360;