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

package/types.ts

@@ -130,6 +130,35 @@ export type ModelsSpecification = {
     [_: string]: ModelSpecification
 };
 
+export type ModelNodeOverrideSpecification = {
+    "orientation"?: [number, number, number]
+};
+export type ModelNodeOverridesSpecification = {
+    [_: string]: ModelNodeOverrideSpecification
+};
+export type ModelMaterialOverrideSpecification = {
+    "model-color"?: ColorSpecification,
+    "model-color-mix-intensity"?: number,
+    "model-opacity"?: number,
+    "model-emissive-strength"?: number
+};
+export type ModelMaterialOverridesSpecification = {
+    [_: string]: ModelMaterialOverrideSpecification
+};
+export type ModelSourceModelsSpecification = {
+    [_: string]: ModelSourceModelSpecification
+};
+export type ModelSourceModelSpecification = {
+    "uri": string,
+    "position"?: [number, number],
+    "orientation"?: [number, number, number],
+    "nodeOverrides"?: ModelNodeOverridesSpecification,
+    "materialOverrides"?: ModelMaterialOverridesSpecification,
+    "nodeOverrideNames"?: Array<string>,
+    "materialOverrideNames"?: Array<string>,
+    "featureProperties"?: unknown
+};
+
 export type IconsetsSpecification = {
     [_: string]: IconsetSpecification
 };
@@ -383,7 +412,7 @@ export type SelectorPropertySpecification = {
 };
 
 export type AppearanceSpecification = {
-    "condition"?: ExpressionSpecification,
+    "condition"?: DataDrivenPropertyValueSpecification<boolean>,
     "name"?: string,
     "properties"?: unknown
 };
@@ -499,7 +528,8 @@ export type ModelSourceSpecification = {
     "type": "model" | "batched-model",
     "maxzoom"?: number,
     "minzoom"?: number,
-    "tiles"?: Array<string>
+    "tiles"?: Array<string>,
+    "models"?: ModelSourceModelsSpecification
 };
 
 export type SourceSpecification =
@@ -1099,6 +1129,10 @@ export type BuildingLayerSpecification = {
          * @experimental This property is experimental and subject to change in future versions.
          */
         "building-facade-floors"?: DataDrivenPropertyValueSpecification<number>,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-facade-unit-width"?: DataDrivenPropertyValueSpecification<number>,
         /**
          * @experimental This property is experimental and subject to change in future versions.
          */
@@ -1116,7 +1150,22 @@ export type BuildingLayerSpecification = {
          * @experimental This property is experimental and subject to change in future versions.
          */
         "building-base"?: DataDrivenPropertyValueSpecification<number>,
-        "building-base-transition"?: TransitionSpecification
+        "building-base-transition"?: TransitionSpecification,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flood-light-wall-radius"?: DataDrivenPropertyValueSpecification<number>,
+        "building-flood-light-wall-radius-transition"?: TransitionSpecification,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flood-light-ground-radius"?: DataDrivenPropertyValueSpecification<number>,
+        "building-flood-light-ground-radius-transition"?: TransitionSpecification,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flip-roof-orientation"?: DataDrivenPropertyValueSpecification<boolean>,
+        "building-flip-roof-orientation-transition"?: TransitionSpecification
     },
     "paint"?: {
         /**
@@ -1166,7 +1215,23 @@ export type BuildingLayerSpecification = {
          * @experimental This property is experimental and subject to change in future versions.
          */
         "building-facade-emissive-chance"?: PropertyValueSpecification<number>,
-        "building-cutoff-fade-range"?: ExpressionSpecification
+        "building-cutoff-fade-range"?: ExpressionSpecification,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flood-light-color"?: PropertyValueSpecification<ColorSpecification>,
+        "building-flood-light-color-transition"?: TransitionSpecification,
+        "building-flood-light-color-use-theme"?: PropertyValueSpecification<string>,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flood-light-intensity"?: PropertyValueSpecification<number>,
+        "building-flood-light-intensity-transition"?: TransitionSpecification,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "building-flood-light-ground-attenuation"?: PropertyValueSpecification<number>,
+        "building-flood-light-ground-attenuation-transition"?: TransitionSpecification
     },
     "appearances"?: Array<AppearanceSpecification>
 };
@@ -1363,7 +1428,11 @@ export type ModelLayerSpecification = {
         "model-height-based-emissive-strength-multiplier"?: DataDrivenPropertyValueSpecification<[number, number, number, number, number]>,
         "model-height-based-emissive-strength-multiplier-transition"?: TransitionSpecification,
         "model-cutoff-fade-range"?: ExpressionSpecification,
-        "model-front-cutoff"?: PropertyValueSpecification<[number, number, number]>
+        "model-front-cutoff"?: PropertyValueSpecification<[number, number, number]>,
+        /**
+         * @experimental This property is experimental and subject to change in future versions.
+         */
+        "model-elevation-reference"?: "sea" | "ground" | "hd-road-markup" | ExpressionSpecification
     },
     "appearances"?: Array<AppearanceSpecification>
 };

package/util/color.ts

@@ -206,46 +206,41 @@ export abstract class RenderColor {
 
         if (this.premultiplied) {
             if (a === 0) return [0, 0, 0, 0];
-
-            r /= a;
-            g /= a;
-            b /= a;
+            const invA = 1 / a; // Single division, then multiply
+            r *= invA;
+            g *= invA;
+            b *= invA;
         }
 
-        const red = Math.min(Math.max(r, 0.0), 1.0);
-        const green = Math.min(Math.max(g, 0.0), 1.0);
-        const blue = Math.min(Math.max(b, 0.0), 1.0);
+        const red = Math.min(Math.max(r, 0), 1);
+        const green = Math.min(Math.max(g, 0), 1);
+        const blue = Math.min(Math.max(b, 0), 1);
 
         const min = Math.min(red, green, blue);
         const max = Math.max(red, green, blue);
+        const delta = max - min;
 
-        const l = (min + max) / 2;
+        const l = (min + max) * 0.5;
 
-        if (min === max) {
+        if (delta === 0) {
             return [0, 0, l * 100, a];
         }
 
-        const delta = max - min;
-
         const s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
 
-        let h = 0;
-        if (max === red) {
-            h = (green - blue) / delta + (green < blue ? 6 : 0);
-        } else if (max === green) {
-            h = (blue - red) / delta + 2;
-        } else if (max === blue) {
-            h = (red - green) / delta + 4;
+        let h: number;
+        switch (max) {
+        case red:
+            h = ((green - blue) / delta + (green < blue ? 6 : 0)) * 60;
+            break;
+        case green:
+            h = ((blue - red) / delta + 2) * 60;
+            break;
+        default: // blue
+            h = ((red - green) / delta + 4) * 60;
         }
 
-        h *= 60;
-
-        return [
-            Math.min(Math.max(h, 0), 360),
-            Math.min(Math.max(s * 100, 0), 100),
-            Math.min(Math.max(l * 100, 0), 100),
-            a
-        ];
+        return [h, s * 100, l * 100, a];
     }
 
     /**

package/util/geometry_util.ts

@@ -16,6 +16,7 @@ function calculateSignedArea(ring: Ring): number {
     for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
         p1 = ring[i];
         p2 = ring[j];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         sum += (p2.x - p1.x) * (p1.y + p2.y);
     }
     return sum;
@@ -44,13 +45,16 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
         if (ccw === undefined) ccw = area < 0;
 
         if (ccw === area < 0) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             if (polygon) polygons.push(polygon);
             polygon = [rings[i]];
 
         } else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             (polygon).push(rings[i]);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     if (polygon) polygons.push(polygon);
 
     // Earcut performance degrades with the # of rings in a polygon. For this

package/validate/validate.ts

@@ -122,6 +122,7 @@ export default function validate(options: ValidatorOptions, arrayAsExpression: b
     }
 
     const errors = validateObject(Object.assign({}, options, {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec
     }));
 

package/validate/validate_appearance.ts

@@ -0,0 +1,101 @@
+import validateObject from './validate_object';
+import ValidationError from '../error/validation_error';
+import validateProperty from './validate_property';
+import {unbundle} from '../util/unbundle_jsonlint';
+import validateExpression from './validate_expression';
+import latest from '../reference/latest';
+
+import type {StyleSpecification, LayerSpecification, AppearanceSpecification} from '../types';
+import type {StyleReference} from '../reference/latest';
+
+export type AppearanceValidatorOptions = {
+    key: string;
+    value: unknown;
+    style: Partial<StyleSpecification>;
+    styleSpec: StyleReference;
+    object?: object;
+    objectKey?: string;
+    layer: LayerSpecification;
+    layerType: string;
+};
+
+export default function validateAppearance(options: AppearanceValidatorOptions): Array<ValidationError> {
+    const {key, layer, layerType} = options;
+    const value = unbundle(options.value) as AppearanceSpecification;
+    const name = unbundle(value.name);
+    const condition = unbundle(value.condition);
+
+    const errors = validateObject({
+        key,
+        value,
+        valueSpec: options.styleSpec.appearance as object,
+        style: options.style,
+        styleSpec: options.styleSpec,
+        objectElementValidators: {
+            condition: (options) => validateCondition(Object.assign({layer, layerType}, options)),
+            properties: (options) => validateProperties(Object.assign({layer, layerType}, options)),
+        }
+    });
+
+    if (name !== 'hidden' && !condition) {
+        errors.push(new ValidationError(options.key, 'name', `Appearance with name different than "hidden" must have a condition`));
+    }
+
+    return errors;
+}
+
+function validateProperties(options: AppearanceValidatorOptions): Array<ValidationError> {
+    const errors: Array<ValidationError> = [];
+
+    const {styleSpec, layer, layerType} = options;
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const paintProperties = styleSpec[`paint_${layerType}`];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const layoutProperties = styleSpec[`layout_${layerType}`];
+    const properties = options.object[options.objectKey] as object;
+
+    for (const propertyKey in properties) {
+        const propertyType =
+            propertyKey in paintProperties ? 'paint' :
+            propertyKey in layoutProperties ? 'layout' :
+            undefined;
+
+        if (!propertyType) {
+            errors.push(new ValidationError(options.key, propertyKey, `unknown property "${propertyKey}" for layer type "${layerType}"`));
+            continue;
+        }
+
+        const propertyValidationOptions = Object.assign({}, options, {
+            key: `${options.key}.${propertyKey}`,
+            object: properties,
+            objectKey: propertyKey,
+            layer,
+            layerType,
+            value: properties[propertyKey] as unknown,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            valueSpec: (propertyType === 'paint' ? paintProperties[propertyKey] : layoutProperties[propertyKey]) as object,
+        });
+
+        errors.push(...validateProperty(propertyValidationOptions, propertyType));
+    }
+
+    return errors;
+}
+
+function validateCondition(options: AppearanceValidatorOptions): Array<ValidationError> {
+    const errors: Array<ValidationError> = [];
+
+    const appearance = options.object as AppearanceSpecification;
+    const condition = appearance.condition;
+
+    errors.push(...validateExpression({
+        key: options.key,
+        value: condition,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        valueSpec: latest['appearance']['condition'],
+        expressionContext: 'appearance'
+    }));
+
+    return errors;
+}

package/validate/validate_array.ts

@@ -72,6 +72,7 @@ export default function validateArray(options: ArrayValidatorOptions): Validatio
         errors = errors.concat(validateArrayElement({
             array,
             arrayIndex: i,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             value: array[i],
             valueSpec: arrayElementSpec,
             style,

package/validate/validate_expression.ts

@@ -4,10 +4,10 @@ import {deepUnbundle} from '../util/unbundle_jsonlint';
 import {isStateConstant, isGlobalPropertyConstant, isFeatureConstant} from '../expression/is_constant';
 import CompoundExpression from '../expression/compound_expression';
 
+import type {StylePropertySpecification} from '../../style-spec/style-spec';
 import type {Expression} from '../expression/expression';
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
-import type {StylePropertySpecification} from '../style-spec';
 
 export type ExpressionValidatorOptions = {
     key: string;
@@ -17,7 +17,7 @@ export type ExpressionValidatorOptions = {
     propertyType?: 'layout' | 'paint' | 'filter';
     style?: Partial<StyleSpecification>;
     styleSpec?: StyleReference;
-    expressionContext?: 'property' | 'filter' | 'cluster-initial' | 'cluster-reduce' | 'cluster-map';
+    expressionContext?: 'property' | 'filter' | 'cluster-initial' | 'cluster-reduce' | 'cluster-map' | 'appearance';
 };
 
 export default function validateExpression(options: ExpressionValidatorOptions): ValidationError[] {
@@ -28,27 +28,37 @@ export default function validateExpression(options: ExpressionValidatorOptions):
         });
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
     const expressionObj = (expression.value as any).expression || (expression.value as any)._styleExpression.expression;
 
     if (options.expressionContext === 'property' && (options.propertyKey === 'text-font') &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         !expressionObj.outputDefined()) {
         return [new ValidationError(options.key, options.value, `Invalid data expression for "${options.propertyKey}". Output values must be contained as literals within the expression.`)];
     }
 
     if (options.expressionContext === 'property' && options.propertyType === 'layout' &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         (!isStateConstant(expressionObj))) {
         return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with layout properties.')];
     }
 
     if (options.expressionContext === 'filter') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return disallowedFilterParameters(expressionObj, options);
     }
 
+    if (options.expressionContext === 'appearance') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return checkDisallowedParameters(expressionObj, options);
+    }
+
     if (options.expressionContext && options.expressionContext.indexOf('cluster') === 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         if (!isGlobalPropertyConstant(expressionObj, ['zoom', 'feature-state'])) {
             return [new ValidationError(options.key, options.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         if (options.expressionContext === 'cluster-initial' && !isFeatureConstant(expressionObj)) {
             return [new ValidationError(options.key, options.value, 'Feature data expressions are not supported with initial expression part of cluster properties.')];
         }
@@ -66,8 +76,11 @@ export function disallowedFilterParameters(e: Expression, options: any): Validat
         'distance-from-center'
     ]);
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (options.valueSpec && options.valueSpec.expression) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (const param of options.valueSpec.expression.parameters) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             disallowedParameters.delete(param);
         }
     }
@@ -79,6 +92,7 @@ export function disallowedFilterParameters(e: Expression, options: any): Validat
 
     if (e instanceof CompoundExpression) {
         if (disallowedParameters.has(e.name)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             return [new ValidationError(options.key, options.value, `["${e.name}"] expression is not supported in a filter for a ${options.object.type} layer with id: ${options.object.id}`)];
         }
     }
@@ -88,3 +102,34 @@ export function disallowedFilterParameters(e: Expression, options: any): Validat
 
     return errors;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function checkDisallowedParameters(e: Expression, options: any): ValidationError[] {
+    const allowedParameters = new Set<string>();
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (options.valueSpec && options.valueSpec.expression) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        for (const param of options.valueSpec.expression.parameters) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            allowedParameters.add(param);
+        }
+    }
+
+    if (allowedParameters.size === 0) {
+        return [];
+    }
+    const errors: ValidationError[] = [];
+
+    if (e instanceof CompoundExpression) {
+        if (!allowedParameters.has(e.name)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+            return [new ValidationError(options.key, options.value, `["${e.name}"] is not an allowed parameter`)];
+        }
+    }
+    e.eachChild((arg) => {
+        errors.push(...checkDisallowedParameters(arg, options));
+    });
+
+    return errors;
+}

package/validate/validate_filter.ts

@@ -3,7 +3,6 @@ import validateExpression from './validate_expression';
 import validateEnum from './validate_enum';
 import {getType, isString, isNumber, isBoolean} from '../util/get_type';
 import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
-import extend from '../util/extend';
 import {isExpressionFilter} from '../feature_filter/index';
 
 import type {StyleReference} from '../reference/latest';
@@ -26,8 +25,9 @@ export default function validateFilter(options: FilterValidatorOptions): Validat
         // We default to a layerType of `fill` because that points to a non-dynamic filter definition within the style-spec.
         const layerType = options.layerType || 'fill';
 
-        return validateExpression(extend({}, options, {
-            expressionContext: 'filter',
+        return validateExpression(Object.assign({}, options, {
+            expressionContext: 'filter' as const,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             valueSpec: options.styleSpec[`filter_${layerType}`]
         }));
     } else {
@@ -51,6 +51,7 @@ function validateNonExpressionFilter(options: FilterValidatorOptions): Validatio
     let errors: ValidationError[] = validateEnum({
         key: `${key}[0]`,
         value: value[0],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec.filter_operator
     });
 
@@ -83,6 +84,7 @@ function validateNonExpressionFilter(options: FilterValidatorOptions): Validatio
                 errors = errors.concat(validateEnum({
                     key: `${key}[${i}]`,
                     value: value[i],
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     valueSpec: styleSpec.geometry_type
                 }));
             } else if (!isString(value[i]) && !isNumber(value[i]) && !isBoolean(value[i])) {

package/validate/validate_fog.ts

@@ -16,6 +16,7 @@ export default function validateFog(options: FogValidatorOptions): ValidationErr
     const fog = options.value;
     const style = options.style;
     const styleSpec = options.styleSpec;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const fogSpec = styleSpec.fog;
 
     if (fog === undefined) {
@@ -31,6 +32,7 @@ export default function validateFog(options: FogValidatorOptions): ValidationErr
         const transitionMatch = key.match(/^(.*)-transition$/);
         const useThemeMatch = key.match(/^(.*)-use-theme$/);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (useThemeMatch && fogSpec[useThemeMatch[1]]) {
             errors = errors.concat(validate({
                 key,
@@ -39,18 +41,22 @@ export default function validateFog(options: FogValidatorOptions): ValidationErr
                 style,
                 styleSpec
             }));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         } else if (transitionMatch && fogSpec[transitionMatch[1]] && fogSpec[transitionMatch[1]].transition) {
             errors = errors.concat(validate({
                 key,
                 value: fog[key],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 valueSpec: styleSpec.transition,
                 style,
                 styleSpec
             }));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         } else if (fogSpec[key]) {
             errors = errors.concat(validate({
                 key,
                 value: fog[key],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
                 valueSpec: fogSpec[key],
                 style,
                 styleSpec

package/validate/validate_function.ts

@@ -17,6 +17,7 @@ import type {StyleSpecification} from '../types';
 import type {StylePropertySpecification} from '../style-spec';
 
 function hasObjectStops(value: object): value is {stops: Array<Record<PropertyKey, unknown>>} {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const stops = value['stops'];
     return Array.isArray(stops) && Array.isArray(stops[0]) && isObject(stops[0][0]);
 }
@@ -51,6 +52,7 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
     const errors = validateObject({
         key: options.key,
         value: options.value,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: options.styleSpec.function,
         style: options.style,
         styleSpec: options.styleSpec,

package/validate/validate_iconset.ts

@@ -38,6 +38,7 @@ export default function validateIconset(options: IconsetValidatorOptions): Valid
     errors = errors.concat(validateObject({
         key,
         value: iconset,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec[`iconset_${type}`],
         style,
         styleSpec

package/validate/validate_import.ts

@@ -1,4 +1,3 @@
-import extend from '../util/extend';
 import validateStyle from './validate_style';
 import validateObject from './validate_object';
 import ValidationError from '../error/validation_error';
@@ -31,8 +30,9 @@ export default function validateImport(options: ImportValidatorOptions): Validat
         enumerable: false
     });
 
-    let errors = validateObject(extend({}, options, {
+    let errors = validateObject(Object.assign({}, options, {
         value: importSpec,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec.import
     }));