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

package/style-spec.ts

@@ -1,77 +1,3 @@
-type ExpressionType = 'data-driven' | 'color-ramp' | 'data-constant' | 'constant';
-type ExpressionParameters = Array<'zoom' | 'feature' | 'feature-state' | 'heatmap-density' | 'line-progress' | 'raster-value' | 'sky-radial-progress' | 'pitch' | 'distance-from-center' | 'measure-light' | 'raster-particle-speed'>;
-
-export type ExpressionSpecification = {
-    interpolated: boolean,
-    parameters?: ExpressionParameters,
-    relaxZoomRestriction?: boolean
-};
-
-export type StylePropertySpecification = {
-    type: 'number',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    transition?: boolean,
-    default?: number,
-    tokens: never
-} | {
-    type: 'string',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    transition?: boolean,
-    default?: string,
-    tokens?: boolean
-} | {
-    type: 'boolean',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    transition?: boolean,
-    overridable?: boolean,
-    default?: boolean,
-    tokens?: never
-} | {
-    type: 'enum',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    values: {[_: string]: unknown},
-    transition?: boolean,
-    default?: string,
-    tokens: never
-} | {
-    type: 'color',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    transition?: boolean,
-    default?: string,
-    tokens: never,
-    overridable: boolean
-} | {
-    type: 'array',
-    value: 'number',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    length?: number,
-    transition?: boolean,
-    default?: Array<number>,
-    tokens: never
-} | {
-    type: 'array',
-    value: 'string',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    length?: number,
-    transition?: boolean,
-    default?: Array<string>,
-    tokens: never
-} | {
-    type: 'resolvedImage',
-    'property-type': ExpressionType,
-    expression?: ExpressionSpecification,
-    transition?: boolean,
-    default?: string,
-    tokens: never
-};
-
 import v8 from './reference/v8.json';
 import latest from './reference/latest';
 import format from './format';
@@ -91,6 +17,193 @@ import {eachSource, eachLayer, eachProperty} from './visit';
 import validate from './validate_style';
 import validateMapboxApiSupported from './validate_mapbox_api_supported';
 
+type ExpressionType = 'data-driven' | 'color-ramp' | 'data-constant' | 'constant';
+
+type ExpressionParameter =
+    | 'zoom'
+    | 'pitch'
+    | 'feature'
+    | 'raster-value'
+    | 'feature-state'
+    | 'line-progress'
+    | 'measure-light'
+    | 'heatmap-density'
+    | 'sky-radial-progress'
+    | 'distance-from-center'
+    | 'raster-particle-speed';
+
+export type ExpressionSpecification = {
+    interpolated: boolean,
+    parameters?: ExpressionParameter[],
+    relaxZoomRestriction?: boolean
+};
+
+export type ArrayPropertySpecification =
+    {
+        type: 'array';
+        'property-type': ExpressionType;
+        value: 'enum';
+        expression?: ExpressionSpecification,
+        transition?: boolean,
+        default?: string[],
+        length?: number,
+        values?: {[_: string]: unknown},
+        experimental?: boolean,
+        private?: boolean,
+        requires?: unknown,
+        appearance?: boolean,
+        tokens?: never,
+        minimum?: never,
+        maximum?: never,
+    } | {
+        type: 'array';
+        'property-type': ExpressionType;
+        value: 'number';
+        expression?: ExpressionSpecification;
+        transition?: boolean;
+        default?: number[];
+        minimum?: number;
+        maximum?: number;
+        length?: number;
+        period?: number;
+        units?: string;
+        experimental?: boolean;
+        private?: boolean;
+        requires?: unknown;
+        appearance?: boolean;
+        tokens?: never;
+        values?: never;
+    } | {
+        type: 'array';
+        'property-type': ExpressionType;
+        value: 'string';
+        expression?: ExpressionSpecification;
+        transition?: boolean;
+        default?: string[];
+        length?: number;
+        experimental?: boolean;
+        private?: boolean;
+        requires?: unknown;
+        appearance?: boolean;
+        tokens?: never;
+        minimum?: never;
+        maximum?: never;
+        values?: never;
+    };
+
+export type BooleanPropertySpecification = {
+    type: 'boolean';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: boolean;
+    overridable?: boolean;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+    tokens?: never;
+};
+
+export type ColorPropertySpecification = {
+    type: 'color';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: string;
+    'use-theme'?: boolean;
+    overridable?: boolean;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+    tokens?: never;
+};
+
+export type EnumPropertySpecification = {
+    type: 'enum';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: string;
+    values?: {[_: string]: unknown};
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+    tokens?: never;
+};
+
+export type FormattedPropertySpecification = {
+    type: 'formatted';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: string;
+    tokens?: boolean;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+};
+
+export type NumberPropertySpecification = {
+    type: 'number';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: number;
+    minimum?: number;
+    maximum?: number;
+    period?: number;
+    units?: string;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+    tokens?: never;
+};
+
+export type ResolvedImagePropertySpecification = {
+    type: 'resolvedImage';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: string;
+    tokens?: boolean;
+    'use-theme'?: boolean;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+};
+
+export type StringPropertySpecification = {
+    type: 'string';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition?: boolean;
+    default?: string;
+    tokens?: boolean;
+    experimental?: boolean;
+    private?: boolean;
+    requires?: unknown;
+    appearance?: boolean;
+};
+
+/**
+ * A style property specification is used to describe a value of some style property reference in the v8.json
+ */
+export type StylePropertySpecification =
+    | ArrayPropertySpecification
+    | BooleanPropertySpecification
+    | ColorPropertySpecification
+    | EnumPropertySpecification
+    | FormattedPropertySpecification
+    | NumberPropertySpecification
+    | ResolvedImagePropertySpecification
+    | StringPropertySpecification;
+
 const expression = {
     StyleExpression,
     isExpression,

package/test.js

@@ -4,6 +4,7 @@ import fs from 'fs';
 import {execSync} from 'child_process';
 import {createRequire} from 'module';
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const packageJson = JSON.parse(fs.readFileSync('./package.json').toString());
 
 process.on('unhandledRejection', (/** @type {Error} */ error) => {
@@ -17,7 +18,9 @@ const require = createRequire(import.meta.url);
 const stylePath = require.resolve('mapbox-gl-styles/styles/basic-v9.json');
 
 try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     for (const bin in packageJson.bin) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
         const script = packageJson.bin[bin];
         const command = [script, stylePath].join(' ');
 
@@ -25,6 +28,7 @@ try {
         execSync(command).toString();
     }
 } catch (error) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     console.log(error.message);
     process.exit(1);
 }

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/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

@@ -28,6 +28,7 @@ import type ValidationError from '../error/validation_error';
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
 import type {FunctionValidatorOptions} from './validate_function';
+import type {StylePropertySpecification} from '../style-spec';
 import type {ExpressionValidatorOptions} from './validate_expression';
 
 const VALIDATORS: Record<string, (...args: unknown[]) => ValidationError[]> = {
@@ -72,14 +73,7 @@ export type ValidatorOptions = {
     /**
      * Current spec being evaluated. Tracks value.
      */
-    valueSpec?: {
-        type?: string;
-        expression?: {
-            interpolated?: boolean;
-            parameters?: Array<'zoom' | 'feature'>;
-        };
-        'property-type'?: 'data-driven';
-    };
+    valueSpec?: Partial<StylePropertySpecification>;
 
     /**
      * Current full spec being evaluated.
@@ -122,6 +116,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

@@ -4,10 +4,11 @@ import ValidationError from '../error/validation_error';
 
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
+import type {ArrayPropertySpecification} from '../style-spec';
 
 type ArraySpec = {
     value?: unknown;
-    values?: unknown[];
+    values?: unknown[] | {[_: string]: unknown};
     length?: number;
     minimum?: number;
     maximum?: number;
@@ -16,7 +17,7 @@ type ArraySpec = {
 
 type ArrayElementSpec<T = unknown> = {
     type: string;
-    values: T[];
+    values: T[] | {[_: string]: unknown};
     minimum: number;
     maximum: number;
     function: unknown;
@@ -25,7 +26,7 @@ type ArrayElementSpec<T = unknown> = {
 type ArrayValidatorOptions<T = unknown> = {
     key: string;
     value: T;
-    valueSpec: ArraySpec;
+    valueSpec: ArrayPropertySpecification | ArraySpec;
     style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
     arrayElementValidator: (...args: unknown[]) => ValidationError[];
@@ -60,7 +61,7 @@ export default function validateArray(options: ArrayValidatorOptions): Validatio
     };
 
     if (styleSpec.$version < 7) {
-        arrayElementSpec.function = arraySpec.function;
+        arrayElementSpec.function = (arraySpec as ArraySpec).function;
     }
 
     if (isObject(arraySpec.value)) {
@@ -72,6 +73,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_enum.ts

@@ -1,17 +1,12 @@
 import ValidationError from '../error/validation_error';
 import {unbundle} from '../util/unbundle_jsonlint';
 
-import type {StyleReference} from '../reference/latest';
-import type {StyleSpecification} from '../types';
+import type {EnumPropertySpecification} from '../style-spec';
 
 type EnumValidatorOptions = {
     key: string;
     value: unknown;
-    valueSpec?: {
-        values: unknown[];
-    };
-    style?: Partial<StyleSpecification>;
-    styleSpec?: StyleReference;
+    valueSpec: EnumPropertySpecification | {values: unknown[] | {[_: string]: unknown}};
 };
 
 export default function validateEnum(options: EnumValidatorOptions): ValidationError[] {