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

package/expression/definitions/index.ts

@@ -266,6 +266,19 @@ CompoundExpression.register(expressions, {
         [],
         (ctx) => ctx.globals.worldview || ""
     ],
+    'is-active-floor': [
+        BooleanType,
+        varargs(StringType),
+        (ctx, args) => {
+            const hasActiveFloors = ctx.globals.activeFloors && ctx.globals.activeFloors.size > 0;
+            if (!hasActiveFloors) { return false; }
+            const floorIds: Set<string> = ctx.globals.activeFloors;
+            return args.some(arg => {
+                const value = arg.evaluate(ctx) as string;
+                return floorIds.has(value);
+            });
+        }
+    ],
     'id': [
         ValueType,
         [],

package/expression/expression_dependencies.ts

@@ -0,0 +1,33 @@
+import CompoundExpression from "./compound_expression";
+import Config from "./definitions/config";
+
+import type {Expression} from "./expression";
+
+function getConfigDependencies(e: Expression): Set<string> {
+    if (e instanceof Config) {
+        const singleConfig = new Set([e.key]);
+        return singleConfig;
+    }
+
+    let result = new Set<string>();
+    e.eachChild(arg => {
+        result = new Set([...result, ...getConfigDependencies(arg)]);
+    });
+    return result;
+}
+
+function isIndoorDependent(e: Expression): boolean {
+    if (e instanceof CompoundExpression && e.name === 'is-active-floor') {
+        return true;
+    }
+
+    let result = false;
+    e.eachChild(arg => {
+        if (!result && isIndoorDependent(arg)) {
+            result = true;
+        }
+    });
+    return result;
+}
+
+export {getConfigDependencies, isIndoorDependent};

package/expression/index.ts

@@ -9,6 +9,7 @@ import Coalesce from './definitions/coalesce';
 import Let from './definitions/let';
 import definitions from './definitions/index';
 import * as isConstant from './is_constant';
+import * as expressionDependencies from './expression_dependencies';
 import RuntimeError from './runtime_error';
 import {success, error} from '../util/result';
 import {
@@ -60,16 +61,17 @@ export interface GlobalProperties {
     accumulated?: Value;
     brightness?: number;
     worldview?: string;
+    activeFloors?: Set<string>;
 }
 
 export class StyleExpression {
     expression: Expression;
-
     _evaluator: EvaluationContext;
     _defaultValue: Value;
     _warningHistory: {[key: string]: boolean};
     _enumValues?: {[_: string]: unknown};
     configDependencies: Set<string>;
+    isIndoorDependent: boolean;
 
     constructor(expression: Expression, propertySpec?: StylePropertySpecification, scope?: string, options?: ConfigOptions, iconImageUseTheme?: string) {
         this.expression = expression;
@@ -77,7 +79,8 @@ export class StyleExpression {
         this._evaluator = new EvaluationContext(scope, options, iconImageUseTheme);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
-        this.configDependencies = isConstant.getConfigDependencies(expression);
+        this.configDependencies = expressionDependencies.getConfigDependencies(expression);
+        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression);
     }
 
     evaluateWithoutErrorHandling(
@@ -124,7 +127,6 @@ export class StyleExpression {
         this._evaluator.featureTileCoord = featureTileCoord || null;
         this._evaluator.featureDistanceData = featureDistanceData || null;
         this._evaluator.iconImageUseTheme = iconImageUseTheme || null;
-
         try {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const val = this.expression.evaluate(this._evaluator);
@@ -190,6 +192,7 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
     kind: Kind;
     isStateDependent: boolean;
     configDependencies: Set<string>;
+    isIndoorDependent: boolean;
     _styleExpression: StyleExpression;
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
@@ -200,7 +203,8 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
         this.isLightConstant = isLightConstant;
         this.isLineProgressConstant = isLineProgressConstant;
         this.isStateDependent = kind !== ('constant' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
-        this.configDependencies = isConstant.getConfigDependencies(expression.expression);
+        this.configDependencies = expressionDependencies.getConfigDependencies(expression.expression);
+        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression.expression);
     }
 
     evaluateWithoutErrorHandling(
@@ -233,6 +237,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
     kind: Kind;
     zoomStops: Array<number>;
     isStateDependent: boolean;
+    isIndoorDependent: boolean;
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
     configDependencies: Set<string>;
@@ -245,9 +250,10 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
         this.isStateDependent = kind !== ('camera' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression.expression);
         this.isLightConstant = isLightConstant;
         this.isLineProgressConstant = isLineProgressConstant;
-        this.configDependencies = isConstant.getConfigDependencies(expression.expression);
+        this.configDependencies = expressionDependencies.getConfigDependencies(expression.expression);
         this.interpolationType = interpolationType;
     }
 
@@ -287,6 +293,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
 export type ConstantExpression = {
     kind: 'constant';
     configDependencies: Set<string>;
+    isIndoorDependent: boolean;
     readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
         feature?: Feature,
@@ -301,6 +308,7 @@ export type ConstantExpression = {
 export type SourceExpression = {
     kind: 'source';
     isStateDependent: boolean;
+    isIndoorDependent: boolean;
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
     configDependencies: Set<string>;
@@ -317,6 +325,7 @@ export type SourceExpression = {
 export type CameraExpression = {
     kind: 'camera';
     isStateDependent: boolean;
+    isIndoorDependent: boolean;
     configDependencies: Set<string>;
     readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
@@ -333,6 +342,7 @@ export type CameraExpression = {
 export interface CompositeExpression {
     kind: 'composite';
     isStateDependent: boolean;
+    isIndoorDependent: boolean;
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
     configDependencies: Set<string>;
@@ -484,6 +494,7 @@ export function normalizePropertyExpression<T>(
         return {
             kind: 'constant',
             configDependencies: new Set(),
+            isIndoorDependent: false,
             evaluate: () => constant
         } as ConstantExpression;
     }

package/expression/is_constant.ts

@@ -56,19 +56,6 @@ function isStateConstant(e: Expression): boolean {
     return result;
 }
 
-function getConfigDependencies(e: Expression): Set<string> {
-    if (e instanceof Config) {
-        const singleConfig = new Set([e.key]);
-        return singleConfig;
-    }
-
-    let result = new Set<string>();
-    e.eachChild(arg => {
-        result = new Set([...result, ...getConfigDependencies(arg)]);
-    });
-    return result;
-}
-
 function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boolean {
     if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) { return false; }
     let result = true;
@@ -78,4 +65,4 @@ function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boo
     return result;
 }
 
-export {isFeatureConstant, isGlobalPropertyConstant, isStateConstant, getConfigDependencies};
+export {isFeatureConstant, isGlobalPropertyConstant, isStateConstant};

package/package.json

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

package/reference/v8.json

@@ -3137,9 +3137,9 @@
         0.8,
         2
       ],
-      "doc": "Defines the minimum and maximum scaling factors for icon related properties like `icon-size`, `icon-halo-width`, `icon-halo-blur`",
-      "minimum": 0.1,
-      "maximum": 10,
+      "doc": "Limits the possible scaling range for `icon-size`, `icon-halo-width`, `icon-halo-blur` properties to be within [min-scale, max-scale]",
+      "minimum": [0.1, 0.1],
+      "maximum": [10, 10],
       "experimental": true,
       "private": true,
       "expression": {
@@ -3653,9 +3653,9 @@
         0.8,
         2
       ],
-      "doc": "Defines the minimum and maximum scaling factors for text related properties like `text-size`, `text-max-width`, `text-halo-width`, `font-size`",
-      "minimum": 0.1,
-      "maximum": 10,
+      "doc": "Limits the possible scaling range for `text-size`, `text-halo-width`, `text-halo-blur` properties to be within [min-scale, max-scale]",
+      "minimum": [0.1, 0.1],
+      "maximum": [10, 10],
       "experimental": true,
       "private": true,
       "expression": {
@@ -5746,6 +5746,18 @@
           }
         }
       },
+      "is-active-floor": {
+        "doc": "Experimental. Returns `true` if the input floor id belongs to one of the active indoor floors, `false` otherwise. In case of array of strings, returns `true` if any of the input floor ids belongs to one of the active indoor floors, `false` otherwise. Only supported in filters.",
+        "group": "Indoor",
+        "experimental": true,
+        "sdk-support": {
+          "basic functionality": {
+            "js": "3.16.0",
+            "android": "11.16.0",
+            "ios": "11.16.0"
+          }
+        }
+      },
       "random": {
         "doc": "Returns a random value in the specified range (first two input numbers) based on a supplied seed (third input). The seed can be an expression or a constant number or string value.",
         "group": "Math",

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

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)) {

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[] {

package/validate/validate_expression.ts

@@ -4,7 +4,7 @@ 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 {StylePropertySpecification} from '../style-spec';
 import type {Expression} from '../expression/expression';
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';

package/validate/validate_layer.ts

@@ -163,7 +163,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                 const validationErrors = validateArray({
                     key: options.key,
                     value: options.value,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
                     valueSpec: options.valueSpec,
                     style: options.style,
                     styleSpec: options.styleSpec,

package/validate/validate_number.ts

@@ -3,14 +3,12 @@ import ValidationError from '../error/validation_error';
 
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
+import type {NumberPropertySpecification} from '../style-spec';
 
 type NumberValidatorOptions = {
     key: string;
     value: unknown;
-    valueSpec: {
-        minimum?: number;
-        maximum?: number
-    };
+    valueSpec: NumberPropertySpecification;
     style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
     arrayIndex: number;

package/validate/validate_source.ts

@@ -129,9 +129,7 @@ export default function validateSource(options: SourceValidatorOptions): Validat
         return validateEnum({
             key: `${key}.type`,
             value: (value as {type: unknown}).type,
-            valueSpec: {values: getSourceTypeValues(styleSpec)},
-            style,
-            styleSpec
+            valueSpec: {values: getSourceTypeValues(styleSpec)}
         });
     }
 }