@mapbox/mapbox-gl-style-spec 14.8.0-beta.1 → 14.9.0-beta.1

package/expression/types/resolved_image.ts

@@ -1,12 +1,25 @@
+import {ImageIdWithOptions} from "./image_id_with_options";
+
+import type Color from "../../util/color";
+
+export type RasterizationOptions = {
+    params: Record<string, Color>;
+    transform?: DOMMatrix;
+}
+
 export type ResolvedImageOptions = {
     namePrimary: string;
+    optionsPrimary: RasterizationOptions | null | undefined;
     nameSecondary: string | null | undefined;
+    optionsSecondary: RasterizationOptions | null | undefined;
     available: boolean;
 };
 
 export default class ResolvedImage {
     namePrimary: string;
+    optionsPrimary: RasterizationOptions | null | undefined;
     nameSecondary: string | null | undefined;
+    optionsSecondary: RasterizationOptions | null | undefined;
     available: boolean;
 
     constructor(options: ResolvedImageOptions) {
@@ -14,25 +27,54 @@ export default class ResolvedImage {
         if (options.nameSecondary) {
             this.nameSecondary = options.nameSecondary;
         }
+        if (options.optionsPrimary) {
+            this.optionsPrimary = options.optionsPrimary;
+        }
+        if (options.optionsSecondary) {
+            this.optionsSecondary = options.optionsSecondary;
+        }
         this.available = options.available;
     }
 
     toString(): string {
-        if (this.nameSecondary) {
+        if (this.namePrimary && this.nameSecondary) {
             return `[${this.namePrimary},${this.nameSecondary}]`;
         }
+
         return this.namePrimary;
     }
 
-    static fromString(namePrimary: string, nameSecondary?: string | null): ResolvedImage | null {
-        if (!namePrimary) return null; // treat empty values as no image
-        return new ResolvedImage({namePrimary, nameSecondary, available: false});
+    getPrimary(): ImageIdWithOptions {
+        return new ImageIdWithOptions(this.namePrimary, {
+            params: this.optionsPrimary ? (this.optionsPrimary.params || {}) : {},
+        });
     }
 
-    serialize(): Array<string> {
+    getSerializedPrimary(): string {
+        return this.getPrimary().serialize();
+    }
+
+    getSecondary(): ImageIdWithOptions | null {
         if (this.nameSecondary) {
-            return ["image", this.namePrimary, this.nameSecondary];
+            return new ImageIdWithOptions(this.nameSecondary, {
+                params: this.optionsSecondary ? (this.optionsSecondary.params || {}) : {},
+            });
         }
-        return ["image", this.namePrimary];
+
+        return null;
+    }
+
+    static from(image: string | ResolvedImage): ResolvedImage {
+        return typeof image === 'string' ? ResolvedImage.build(image) : image;
+    }
+
+    static build(
+        namePrimary: string,
+        nameSecondary?: string | null,
+        optionsPrimary?: RasterizationOptions | null,
+        optionsSecondary?: RasterizationOptions | null
+    ): ResolvedImage | null {
+        if (!namePrimary) return null; // treat empty values as no image
+        return new ResolvedImage({namePrimary, nameSecondary, optionsPrimary, optionsSecondary, available: false});
     }
 }

package/expression/values.ts

@@ -13,14 +13,14 @@ export function validateRGBA(r: unknown, g: unknown, b: unknown, a?: unknown): s
         typeof g === 'number' && g >= 0 && g <= 255 &&
         typeof b === 'number' && b >= 0 && b <= 255
     )) {
-        const value = typeof a === 'number' ? [r, g, b, a] : [r, g, b];
+        const value = (typeof a === 'number' ? [r, g, b, a] : [r, g, b]) as number[];
         return `Invalid rgba value [${value.join(', ')}]: 'r', 'g', and 'b' must be between 0 and 255.`;
     }
 
     if (!(
         typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1)
     )) {
-        return `Invalid rgba value [${[r, g, b, a].join(', ')}]: 'a' must be between 0 and 1.`;
+        return `Invalid rgba value [${([r, g, b, a] as number[]).join(', ')}]: 'a' must be between 0 and 1.`;
     }
 
     return null;
@@ -30,7 +30,7 @@ export function validateHSLA(h: unknown, s: unknown, l: unknown, a?: unknown): s
     if (!(
         typeof h === 'number' && h >= 0 && h <= 360
     )) {
-        const value = typeof a === 'number' ? [h, s, l, a] : [h, s, l];
+        const value = (typeof a === 'number' ? [h, s, l, a] : [h, s, l]) as number[];
         return `Invalid hsla value [${value.join(', ')}]: 'h' must be between 0 and 360.`;
     }
 
@@ -38,14 +38,14 @@ export function validateHSLA(h: unknown, s: unknown, l: unknown, a?: unknown): s
         typeof s === 'number' && s >= 0 && s <= 100 &&
         typeof l === 'number' && l >= 0 && l <= 100
     )) {
-        const value = typeof a === 'number' ? [h, s, l, a] : [h, s, l];
+        const value = (typeof a === 'number' ? [h, s, l, a] : [h, s, l]) as number[];
         return `Invalid hsla value [${value.join(', ')}]: 's', and 'l' must be between 0 and 100.`;
     }
 
     if (!(
         typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1)
     )) {
-        return `Invalid hsla value [${[h, s, l, a].join(', ')}]: 'a' must be between 0 and 1.`;
+        return `Invalid hsla value [${([h, s, l, a] as number[]).join(', ')}]: 'a' must be between 0 and 1.`;
     }
 
     return null;
@@ -136,8 +136,10 @@ export function toString(value: Value): string {
     if (value === null) {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
-        return String(value);
-    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+        return String(value as string | number | boolean);
+    } else if (value instanceof Color) {
+        return value.toStringPremultipliedAlpha();
+    } else if (value instanceof Formatted || value instanceof ResolvedImage) {
         return value.toString();
     } else {
         return JSON.stringify(value);

package/feature_filter/index.ts

@@ -2,6 +2,7 @@ import latest from '../reference/latest';
 import {deepUnbundle} from '../util/unbundle_jsonlint';
 import {createExpression} from '../expression/index';
 import {isFeatureConstant} from '../expression/is_constant';
+import assert from 'assert';
 
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../types/tile_id';
@@ -21,6 +22,7 @@ export type FilterExpression = (
     featureTileCoord?: Point,
     featureDistanceData?: FeatureDistanceData,
 ) => boolean;
+
 export type FeatureFilter = {
     filter: FilterExpression;
     dynamicFilter?: FilterExpression;
@@ -109,14 +111,18 @@ ${JSON.stringify(filterExp, null, 2)}
     }
 
     // Compile the static component of the filter
-    const filterSpec = latest[`filter_${layerType}`];
-    const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
-
     let filterFunc = null;
-    if (compiledStaticFilter.result === 'error') {
-        throw new Error(compiledStaticFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
-    } else {
-        filterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+    let filterSpec = null;
+    if (layerType !== 'background' && layerType !== 'sky' && layerType !== 'slot') {
+        filterSpec = latest[`filter_${layerType}`];
+        assert(filterSpec);
+        const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
+
+        if (compiledStaticFilter.result === 'error') {
+            throw new Error(compiledStaticFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
+        } else {
+            filterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+        }
     }
 
     // If the static component is not equal to the entire filter then we have a dynamic component

package/function/index.ts

@@ -204,7 +204,7 @@ function evaluateIdentityFunction(parameters, propertySpec, input) {
     } else if (propertySpec.type === 'formatted') {
         input = Formatted.fromString(input.toString());
     } else if (propertySpec.type === 'resolvedImage') {
-        input = ResolvedImage.fromString(input.toString());
+        input = ResolvedImage.build(input.toString());
     } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
         input = undefined;
     }

package/group_by_layout.ts

@@ -29,6 +29,25 @@ function getKey(layer: LayerSpecification) {
     return key;
 }
 
+function containsKey(obj: any, key: string) {
+    function recursiveSearch(item) {
+        if (typeof item === 'string' && item === key) {
+            return true;
+        }
+
+        if (Array.isArray(item)) {
+            return item.some(recursiveSearch);
+        }
+
+        if (item && typeof item === 'object') {
+            return Object.values(item).some(recursiveSearch);
+        }
+
+        return false;
+    }
+    return recursiveSearch(obj);
+}
+
 /**
  * Given an array of layers, return an array of arrays of layers where all
  * layers in each group have identical layout-affecting properties. These
@@ -53,17 +72,30 @@ export default function groupByLayout(
     const groups: Record<string, any> = {};
 
     for (let i = 0; i < layers.length; i++) {
+        const layer = layers[i];
+        let k = cachedKeys && cachedKeys[layer.id];
+
+        if (!k) {
+            k =  getKey(layer);
+            // The usage of "line-progress" inside "line-width" makes the property act like a layout property.
+            // We need to split it from the group to avoid conflicts in the bucket creation.
+            if (layer.type === 'line' && layer["paint"]) {
+                const lineWidth = layer["paint"]['line-width'];
+                if (containsKey(lineWidth, 'line-progress')) {
+                    k += `/${stringify(layer["paint"]['line-width'])}`;
+                }
+            }
+        }
 
-        const k = (cachedKeys && cachedKeys[layers[i].id]) || getKey(layers[i]);
         // update the cache if there is one
         if (cachedKeys)
-            cachedKeys[layers[i].id] = k;
+            cachedKeys[layer.id] = k;
 
         let group = groups[k];
         if (!group) {
             group = groups[k] = [];
         }
-        group.push(layers[i]);
+        group.push(layer);
     }
 
     const result = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.8.0-beta.1",
+  "version": "14.9.0-beta.1",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",