@mapbox/mapbox-gl-style-spec 14.12.0 → 14.13.0

package/expression/definitions/config.ts

@@ -1,7 +1,8 @@
-import {ValueType} from '../types';
+import {typeEquals, ValueType} from '../types';
 import {Color, typeOf, toString as valueToString} from '../values';
 import Formatted from '../types/formatted';
 import ResolvedImage from '../types/resolved_image';
+import * as isConstant from '../is_constant';
 import Literal from './literal';
 
 import type {Type} from '../types';
@@ -9,6 +10,12 @@ import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 
+const FQIDSeparator = '\u001F';
+
+function makeConfigFQID(id: string, ownScope?: string | null, contextScope?: string | null): string {
+    return [id, ownScope, contextScope].filter(Boolean).join(FQIDSeparator);
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function coerceValue(type: string, value: any): any {
     switch (type) {
@@ -43,11 +50,13 @@ class Config implements Expression {
     type: Type;
     key: string;
     scope: string | null | undefined;
+    featureConstant: boolean;
 
-    constructor(type: Type, key: string, scope?: string) {
+    constructor(type: Type, key: string, scope?: string, featureConstant: boolean = false) {
         this.type = type;
         this.key = key;
         this.scope = scope;
+        this.featureConstant = featureConstant;
     }
 
     static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Config | null | void {
@@ -64,23 +73,34 @@ class Config implements Expression {
             return context.error(`Key name of 'config' expression must be a string literal.`);
         }
 
+        let featureConstant = true;
+        let configScopeValue: string | undefined;
+        const configKeyValue = valueToString(configKey.value);
+
         if (args.length >= 3) {
             const configScope = context.parse(args[2], 2);
             if (!(configScope instanceof Literal)) {
                 return context.error(`Scope of 'config' expression must be a string literal.`);
             }
-            return new Config(type, valueToString(configKey.value), valueToString(configScope.value));
+
+            configScopeValue = valueToString(configScope.value);
         }
 
-        return new Config(type, valueToString(configKey.value));
+        if (context.options) {
+            const fqid = makeConfigFQID(configKeyValue, configScopeValue, context._scope);
+            const config = context.options.get(fqid);
+            if (config) {
+                featureConstant = isConstant.isFeatureConstant(config.value || config.default);
+            }
+        }
+
+        return new Config(type, configKeyValue, configScopeValue, featureConstant);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
-        const FQIDSeparator = '\u001F';
-        const configKey = [this.key, this.scope, ctx.scope].filter(Boolean).join(FQIDSeparator);
-
-        const config = ctx.getConfig(configKey);
+        const fqid = makeConfigFQID(this.key, this.scope, ctx.scope);
+        const config = ctx.getConfig(fqid);
         if (!config) return null;
 
         const {type, value, values, minValue, maxValue, stepValue} = config;
@@ -117,7 +137,7 @@ class Config implements Expression {
         }
 
         // @ts-expect-error - TS2367 - This comparison appears to be unintentional because the types 'string' and 'Type' have no overlap.
-        if ((type && type !== this.type) || (result !== undefined && typeOf(result) !== this.type)) {
+        if ((type && type !== this.type) || (result !== undefined && !typeEquals(typeOf(result), this.type))) {
             result = coerceValue(this.type.kind, result);
         }
 
@@ -133,7 +153,7 @@ class Config implements Expression {
     serialize(): SerializedExpression {
         const res = ["config", this.key];
         if (this.scope) {
-            res.concat(this.key);
+            res.concat(this.scope);
         }
         return res;
     }

package/expression/definitions/format.ts

@@ -6,6 +6,7 @@ import {
     StringType,
     ColorType,
     ResolvedImageType,
+    typeEquals,
 } from '../types';
 import Formatted, {FormattedSection} from '../types/formatted';
 import {toString, typeOf} from '../values';
@@ -92,7 +93,7 @@ export default class FormatExpression implements Expression {
     evaluate(ctx: EvaluationContext): Formatted {
         const evaluateSection = (section: FormattedSectionExpression) => {
             const evaluatedContent = section.content.evaluate(ctx);
-            if (typeOf(evaluatedContent) === ResolvedImageType) {
+            if (typeEquals(typeOf(evaluatedContent), ResolvedImageType)) {
                 return new FormattedSection('', evaluatedContent, null, null, null);
             }
 

package/expression/definitions/index.ts

@@ -101,7 +101,7 @@ function rgba(ctx: EvaluationContext, [r, g, b, a]: Expression[]) {
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateRGBA(r, g, b, alpha);
     if (error) throw new RuntimeError(error);
-    return new Color(r as unknown as number / 255 * alpha, g as unknown as number / 255 * alpha, b as unknown as number / 255 * alpha, alpha);
+    return new Color(r as unknown as number / 255, g as unknown as number / 255, b as unknown as number / 255, alpha);
 }
 
 function hsla(ctx: EvaluationContext, [h, s, l, a]: Expression[]) {
@@ -187,7 +187,7 @@ CompoundExpression.register(expressions, {
         [ColorType],
         (ctx, [v]) => {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return v.evaluate(ctx).toRenderColor(null).toArray();
+            return v.evaluate(ctx).toNonPremultipliedRenderColor(null).toArray();
         }
     ],
     'to-hsla': [
@@ -195,7 +195,7 @@ CompoundExpression.register(expressions, {
         [ColorType],
         (ctx, [v]) => {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return v.evaluate(ctx).toRenderColor(null).toHslaArray();
+            return v.evaluate(ctx).toNonPremultipliedRenderColor(null).toHslaArray();
         }
     ],
     'rgb': [
@@ -260,6 +260,11 @@ CompoundExpression.register(expressions, {
         [],
         (ctx) => ctx.geometryType()
     ],
+    'worldview': [
+        StringType,
+        [],
+        (ctx) => ctx.globals.worldview || ""
+    ],
     'id': [
         ValueType,
         [],

package/expression/definitions/literal.ts

@@ -58,7 +58,7 @@ class Literal implements Expression {
             // Constant-folding can generate Literal expressions that you
             // couldn't actually generate with a "literal" expression,
             // so we have to implement an equivalent serialization here
-            return ["rgba" as SerializedExpression].concat(this.value.toRenderColor(null).toArray());
+            return ["rgba" as SerializedExpression].concat(this.value.toNonPremultipliedRenderColor(null).toArray());
         } else if (this.value instanceof Formatted) {
             // Same as Color
             return this.value.serialize();

package/expression/definitions/match.ts

@@ -1,6 +1,6 @@
 import assert from 'assert';
 import {typeOf} from '../values';
-import {ValueType} from '../types';
+import {typeEquals, ValueType} from '../types';
 
 import type {Type} from '../types';
 import type {Expression, SerializedExpression} from '../expression';
@@ -101,7 +101,7 @@ class Match implements Expression {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx));
-        const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
+        const output = (typeEquals(typeOf(input), this.inputType) && this.outputs[this.cases[input]]) || this.otherwise;
         return output.evaluate(ctx);
     }
 

package/expression/index.ts

@@ -60,6 +60,7 @@ export interface GlobalProperties {
     readonly isSupportedScript?: (_: string) => boolean;
     accumulated?: Value;
     brightness?: number;
+    worldview?: string;
 }
 
 export class StyleExpression {

package/expression/is_constant.ts

@@ -32,6 +32,10 @@ function isFeatureConstant(e: Expression): boolean {
         return false;
     }
 
+    if (e instanceof Config) {
+        return e.featureConstant;
+    }
+
     let result = true;
     e.eachChild(arg => {
         if (result && !isFeatureConstant(arg)) { result = false; }

package/expression/parsing_context.ts

@@ -271,5 +271,5 @@ function isConstant(expression: Expression) {
     }
 
     return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed']);
+        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'worldview', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed']);
 }

package/expression/types/formatted.ts

@@ -70,7 +70,7 @@ export default class Formatted {
                 options["font-scale"] = section.scale;
             }
             if (section.textColor) {
-                options["text-color"] = (["rgba"] as Array<unknown>).concat(section.textColor.toRenderColor(null).toArray());
+                options["text-color"] = (["rgba"] as Array<unknown>).concat(section.textColor.toNonPremultipliedRenderColor(null).toArray());
             }
             serialized.push(options);
         }

package/expression/types.ts

@@ -134,3 +134,11 @@ export function isValidNativeType(provided: any, allowedTypes: Array<NativeType>
         }
     });
 }
+
+export function typeEquals(a: Type, b: Type): boolean {
+    if (a.kind === 'array' && b.kind === 'array') {
+        return a.N === b.N && typeEquals(a.itemType, b.itemType);
+    } else {
+        return a.kind === b.kind;
+    }
+}

package/expression/values.ts

@@ -135,9 +135,7 @@ export function toString(value: Value): string {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value as string | number | boolean);
-    } else if (value instanceof Color) {
-        return value.toStringPremultipliedAlpha();
-    } else if (value instanceof Formatted || value instanceof ResolvedImage) {
+    } else if (value instanceof Formatted || value instanceof ResolvedImage || value instanceof Color) {
         return value.toString();
     } else {
         return JSON.stringify(value);

package/group_by_layout.ts

@@ -25,15 +25,7 @@ function stringify(obj: any) {
 function getKey(layer: LayerSpecification) {
     let key = '';
     for (const k of refProperties) {
-        // Ignore minzoom and maxzoom for model layers so that multiple model layers
-        // referencing the same source (but with different zoom ranges) produce the same
-        // key. This ensures they get grouped into a single bucket, preventing a scenario
-        // where shared node data is serialized twice and triggers an assert in struct_array.ts.
-        if (layer.type === 'model' && (k === 'minzoom' || k === 'maxzoom')) {
-            continue;
-        } else {
-            key += `/${stringify(layer[k])}`;
-        }
+        key += `/${stringify(layer[k])}`;
     }
     return key;
 }

package/package.json

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