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

package/dist/index.d.ts

@@ -80,6 +80,25 @@ type TransitionSpecification = {
 	duration?: number;
 	delay?: number;
 };
+type PropertyFunctionStop<T> = [
+	number,
+	T
+];
+type ZoomAndPropertyFunctionStop<T> = [
+	{
+		zoom: number;
+		value: string | number | boolean;
+	},
+	T
+];
+type FunctionSpecification<T> = {
+	stops: Array<PropertyFunctionStop<T> | ZoomAndPropertyFunctionStop<T>>;
+	base?: number;
+	property?: string;
+	type?: "identity" | "exponential" | "interval" | "categorical";
+	colorSpace?: "rgb" | "lab" | "hcl";
+	default?: T;
+};
 type CameraFunctionSpecification<T> = {
 	type: "exponential";
 	stops: Array<[
@@ -161,7 +180,7 @@ type ExpressionSpecification = [
 	...any[]
 ];
 type PropertyValueSpecification<T> = T | CameraFunctionSpecification<T> | ExpressionSpecification;
-type DataDrivenPropertyValueSpecification<T> = T | CameraFunctionSpecification<T> | SourceFunctionSpecification<T> | CompositeFunctionSpecification<T> | ExpressionSpecification;
+type DataDrivenPropertyValueSpecification<T> = T | FunctionSpecification<T> | CameraFunctionSpecification<T> | SourceFunctionSpecification<T> | CompositeFunctionSpecification<T> | ExpressionSpecification;
 type StyleSpecification = {
 	"version": 8;
 	"fragment"?: boolean;
@@ -543,6 +562,15 @@ type LineLayerSpecification = {
 			number,
 			number
 		];
+		/**
+		 * @experimental This property is experimental and subject to change in future versions.
+		 */
+		"line-trim-fade-range"?: PropertyValueSpecification<[
+			number,
+			number
+		]>;
+		"line-trim-color"?: PropertyValueSpecification<ColorSpecification>;
+		"line-trim-color-transition"?: TransitionSpecification;
 		"line-emissive-strength"?: PropertyValueSpecification<number>;
 		"line-emissive-strength-transition"?: TransitionSpecification;
 		"line-border-width"?: DataDrivenPropertyValueSpecification<number>;
@@ -1325,7 +1353,7 @@ type FeatureFilter = {
 	needGeometry: boolean;
 	needFeature: boolean;
 };
-declare function isExpressionFilter(filter: any): boolean;
+declare function isExpressionFilter(filter: unknown): boolean;
 /**
  * Given a filter expressed as nested arrays, return a new function
  * that evaluates whether a given feature (with a .properties or .tags property)
@@ -1336,7 +1364,7 @@ declare function isExpressionFilter(filter: any): boolean;
  * @param {string} layerType the type of the layer this filter will be applied to.
  * @returns {Function} filter-evaluating function
  */
-declare function createFilter(filter: any, layerType?: string): FeatureFilter;
+declare function createFilter(filter?: FilterSpecification | ExpressionSpecification, layerType?: string): FeatureFilter;
 type SerializedExpression = Array<unknown> | Array<string> | string | number | boolean | null;
 interface Expression {
 	readonly type: Type;
@@ -1559,22 +1587,7 @@ declare function createFunction(parameters: any, propertySpec: any): {
 	interpolationFactor?: undefined;
 	zoomStops?: undefined;
 };
-type Stop = [
-	{
-		zoom: number;
-		value: string | number | boolean;
-	},
-	unknown
-];
-type FunctionParameters = {
-	stops: Array<Stop>;
-	base: number;
-	property: string;
-	type: "identity" | "exponential" | "interval" | "categorical";
-	colorSpace: "rgb" | "lab" | "hcl";
-	default: unknown;
-};
-declare function convertFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification): ExpressionSpecification;
+declare function convertFunction<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification): ExpressionSpecification;
 declare function eachSource(style: StyleSpecification, callback: (_: SourceSpecification) => void): void;
 declare function eachLayer(style: StyleSpecification, callback: (_: LayerSpecification) => void): void;
 type PropertyCallback = (arg1: {
@@ -1638,6 +1651,7 @@ export type StylePropertySpecification = {
 	expression?: ExpressionSpecification$1;
 	transition?: boolean;
 	default?: number;
+	tokens: never;
 } | {
 	type: "string";
 	"property-type": ExpressionType;
@@ -1651,6 +1665,7 @@ export type StylePropertySpecification = {
 	expression?: ExpressionSpecification$1;
 	transition?: boolean;
 	default?: boolean;
+	tokens: never;
 } | {
 	type: "enum";
 	"property-type": ExpressionType;
@@ -1660,12 +1675,14 @@ export type StylePropertySpecification = {
 	};
 	transition?: boolean;
 	default?: string;
+	tokens: never;
 } | {
 	type: "color";
 	"property-type": ExpressionType;
 	expression?: ExpressionSpecification$1;
 	transition?: boolean;
 	default?: string;
+	tokens: never;
 	overridable: boolean;
 } | {
 	type: "array";
@@ -1675,6 +1692,7 @@ export type StylePropertySpecification = {
 	length?: number;
 	transition?: boolean;
 	default?: Array<number>;
+	tokens: never;
 } | {
 	type: "array";
 	value: "string";
@@ -1683,12 +1701,14 @@ export type StylePropertySpecification = {
 	length?: number;
 	transition?: boolean;
 	default?: Array<string>;
+	tokens: never;
 } | {
 	type: "resolvedImage";
 	"property-type": ExpressionType;
 	expression?: ExpressionSpecification$1;
 	transition?: boolean;
 	default?: string;
+	tokens: never;
 };
 export declare const expression: {
 	StyleExpression: typeof StyleExpression;

package/dist/index.es.js

@@ -4985,6 +4985,7 @@ var paint = [
 	"paint_fill-extrusion",
 	"paint_symbol",
 	"paint_raster",
+	"paint_raster-particle",
 	"paint_hillshade",
 	"paint_background",
 	"paint_sky",
@@ -5567,7 +5568,7 @@ var paint_line = {
 	"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,
@@ -5599,6 +5600,81 @@ var paint_line = {
 		},
 		"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,
@@ -12178,7 +12254,6 @@ class Within {
     }
 }
 
-/* @flow */
 const factors = {
     kilometers: 1,
     miles: 1000 / 1609.344,
@@ -12198,13 +12273,6 @@ const E2 = FE * (2 - FE);
 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 {
     /**
@@ -12212,7 +12280,7 @@ class CheapRuler {
      *
      * @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);
@@ -12237,8 +12305,7 @@ class CheapRuler {
      * 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
@@ -12261,8 +12328,8 @@ class CheapRuler {
     /**
      * 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]);
@@ -12276,8 +12343,8 @@ class CheapRuler {
     /**
      * 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]);
@@ -12291,10 +12358,10 @@ class CheapRuler {
     /**
      * 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
@@ -12306,10 +12373,10 @@ class CheapRuler {
     /**
      * 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
@@ -12323,7 +12390,7 @@ class CheapRuler {
     /**
      * 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([
@@ -12342,7 +12409,7 @@ class CheapRuler {
     /**
      * 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([[
@@ -12364,9 +12431,9 @@ class CheapRuler {
     /**
      * 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
@@ -12389,9 +12456,9 @@ class CheapRuler {
      * 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]);
@@ -12401,9 +12468,8 @@ class CheapRuler {
         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];
@@ -12421,16 +12487,19 @@ class CheapRuler {
      * 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];
@@ -12470,10 +12539,10 @@ class CheapRuler {
     /**
      * 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
@@ -12501,10 +12570,10 @@ class CheapRuler {
     /**
      * 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
@@ -12532,9 +12601,9 @@ class CheapRuler {
     /**
      * 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
@@ -12552,9 +12621,9 @@ class CheapRuler {
     /**
      * 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
@@ -12572,20 +12641,31 @@ class CheapRuler {
     /**
      * 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];
@@ -12594,7 +12674,10 @@ function interpolate(a, b, t) {
         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;