Accept an expression as an argument in the distance expression

GitOrigin-RevId: ffdfab90b2875f6b3697860d44d92ea063e164b1

Author: underoot

src/style-spec/expression/definitions/distance.ts

@@ -1,9 +1,11 @@
 import {isValue} from '../values';
-import {NumberType} from '../types';
+import {NumberType, ValueType} from '../types';
 import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
 import {lngFromMercatorX, latFromMercatorY} from '../../util/mercator';
 import TinyQueue from "tinyqueue";
 import EXTENT from '../../data/extent';
+import Literal from './literal';
+import {isGlobalPropertyConstant, isStateConstant} from '../is_constant';
 
 // Geodesic scale factors (cheap-ruler math): meters per degree lon/lat at a given latitude.
 // Only the three distance operations used in this file are implemented.
@@ -587,70 +589,130 @@ function isTypeValid(type: string) {
         type === "MultiPolygon"
     );
 }
+
+// Resolves a GeoJSON value (Feature / FeatureCollection / bare geometry) down
+// to the geometries `distance` measures against -- one per feature for a
+// FeatureCollection, one otherwise. Shared by parse-time (literal argument)
+// and evaluate-time (e.g. a `["config", ...]` argument, whose value isn't
+// known until evaluation) resolution. Returns null if the value isn't valid
+// GeoJSON, or if any feature has a geometry type other than
+// Point/LineString/Polygon (and their Multi* variants).
+function extractDistanceGeometry(value: unknown): Array<DistanceGeometry> | null {
+    if (!isValue(value) || typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const geojson = value as GeoJSON.GeoJSON;
+    if (geojson.type === 'FeatureCollection') {
+        if (geojson.features.length === 0) return null;
+        const geometries: Array<DistanceGeometry> = [];
+        for (const feature of geojson.features) {
+            if (!isTypeValid(feature.geometry.type)) return null;
+            geometries.push(feature.geometry as DistanceGeometry);
+        }
+        return geometries;
+    }
+    if (geojson.type === 'Feature') {
+        return isTypeValid(geojson.geometry.type) ? [geojson.geometry as DistanceGeometry] : null;
+    }
+    if (isTypeValid(geojson.type)) {
+        return [geojson as DistanceGeometry];
+    }
+    return null;
+}
+
 class Distance implements Expression {
     type: Type;
-    geojson: GeoJSON.GeoJSON;
-    geometries: DistanceGeometry;
+    geojson: Expression;
 
-    constructor(geojson: GeoJSON.GeoJSON, geometries: DistanceGeometry) {
+    constructor(geojson: Expression) {
         this.type = NumberType;
         this.geojson = geojson;
-        this.geometries = geometries;
     }
 
     static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Distance | null | void {
         if (args.length !== 2) {
             return context.error(`'distance' expression requires either one argument, but found ' ${args.length - 1} instead.`);
         }
-        if (isValue(args[1])) {
-            const geojson = args[1] as GeoJSON.GeoJSON;
-            if (geojson.type === 'FeatureCollection') {
-                for (let i = 0; i < geojson.features.length; ++i) {
-                    if (isTypeValid(geojson.features[i]!.geometry.type)) {
-                        return new Distance(geojson, geojson.features[i]!.geometry as DistanceGeometry);
-                    }
-                }
-            } else if (geojson.type === 'Feature') {
-                if (isTypeValid(geojson.geometry.type)) {
-                    return new Distance(geojson, geojson.geometry as DistanceGeometry);
-                }
-            } else if (isTypeValid(geojson.type)) {
-                return new Distance(geojson, geojson as DistanceGeometry);
+
+        const arg = args[1];
+        // A bare GeoJSON value (Feature / FeatureCollection / bare geometry)
+        // isn't valid expression syntax on its own, so wrap it as a literal
+        // like ["literal", {...}] would be. Anything else -- e.g.
+        // `["config", "key"]` -- is left as-is and parsed as a regular
+        // sub-expression, resolved to GeoJSON at evaluation time so a config
+        // value can change at runtime without re-parsing the style.
+        const isBareGeoJSON = isValue(arg) && !Array.isArray(arg);
+        const parsed = context.parse(isBareGeoJSON ? ['literal', arg] : arg, 1, ValueType);
+        if (!parsed) return null;
+
+        for (const [globalProperties, name] of [
+            [['measure-light'], 'brightness'],
+            [['pitch'], 'pitch'],
+            [['distance-from-center'], 'distance-from-center'],
+        ] as Array<[Array<string>, string]>) {
+            if (!isGlobalPropertyConstant(parsed, globalProperties)) {
+                return context.error(`'distance' expression may not depend on ${name}.`);
             }
         }
-        return context.error(
-            "'distance' expression needs to be an array with format [\'Distance\', GeoJSONObj]."
-        );
+        if (!isStateConstant(parsed)) {
+            return context.error(`'distance' expression may not depend on feature-state.`);
+        }
+
+        // Literal arguments can be validated eagerly; a config-driven
+        // argument can't be checked until it's evaluated.
+        if (parsed instanceof Literal && !extractDistanceGeometry(parsed.value)) {
+            return context.error(
+                "'distance' expression needs to be an array with format [\'Distance\', GeoJSONObj]."
+            );
+        }
+
+        return new Distance(parsed);
     }
 
     evaluate(ctx: EvaluationContext): number | null {
+        const geometries = extractDistanceGeometry(this.geojson.evaluate(ctx));
+        if (!geometries) {
+            console.warn("Distance Expression: could not resolve a valid Point/LineString/Polygon GeoJSON geometry.");
+            return null;
+        }
+
         const geometry = ctx.geometry();
         const canonical = ctx.canonicalID();
-        if (geometry != null && canonical != null) {
-            if (ctx.geometryType() === 'Point') {
-                return pointsToGeometryDistance(geometry, canonical, this.geometries);
-            }
-            if (ctx.geometryType() === 'LineString') {
-                return linesToGeometryDistance(geometry, canonical, this.geometries);
-            }
-            if (ctx.geometryType() === 'Polygon') {
-                return polygonsToGeometryDistance(geometry, canonical, this.geometries);
-            }
-            console.warn("Distance Expression: currently only evaluates valid Point/LineString/Polygon geometries.");
-        } else {
+        if (geometry == null || canonical == null) {
             console.warn("Distance Expression: requires valid feature and canonical information.");
+            return null;
         }
-        return null;
+
+        const geometryType = ctx.geometryType();
+        const distanceTo = geometryType === 'Point' ? pointsToGeometryDistance :
+            geometryType === 'LineString' ? linesToGeometryDistance :
+            geometryType === 'Polygon' ? polygonsToGeometryDistance : null;
+        if (!distanceTo) {
+            console.warn("Distance Expression: currently only evaluates valid Point/LineString/Polygon geometries.");
+            return null;
+        }
+
+        // A FeatureCollection reference resolves to one geometry per feature;
+        // report the distance to the closest one.
+        let dist = Infinity;
+        for (const g of geometries) {
+            const tempDist = distanceTo(geometry, canonical, g);
+            if (tempDist == null || isNaN(tempDist)) return tempDist;
+            if ((dist = Math.min(dist, tempDist)) === 0) break;
+        }
+        return dist;
     }
 
-    eachChild() {}
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.geojson);
+    }
 
     outputDefined(): boolean {
         return true;
     }
 
     serialize(): Array<unknown> {
-        return ['distance', this.geojson];
+        return ['distance', this.geojson.serialize()];
     }
 }
 

src/style-spec/expression/index.ts

@@ -21,15 +21,15 @@ import {
 } from '../util/properties';
 import {isFunction, createFunction} from '../function/index';
 import {Color} from './values';
-import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types';
+import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, ObjectType, array} from './types';
 
 import type {Type, EvaluationKind} from './types';
 import type {Value} from './values';
 import type {Expression} from './expression';
 import type {StylePropertySpecification} from '../style-spec';
 import type {Result} from '../util/result';
 import type {InterpolationType} from './definitions/interpolate';
-import type {PropertyValueSpecification} from '../types';
+import type {PropertyValueSpecification, OptionSpecification} from '../types';
 import type {FormattedSection} from './types/formatted';
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../types/tile_id';
@@ -198,6 +198,26 @@ export function createExpression(
     return success(new StyleExpression(parsed, propertySpec, scope, options, iconImageUseTheme));
 }
 
+// Parse a config option's default or value with the option's declared type
+// fed to the expression parser. This drives implicit string→color coercion
+// inside expressions (e.g. `["interpolate", ..., "hsl(...)"]` on a color
+// option). Skipped for array options (the parser doesn't model the schema's
+// `array: true` flag) and for primitive values (they keep their original
+// literal shape so `getConfig` round-trips unchanged).
+//
+// A plain (non-array) object -- e.g. a GeoJSON geometry for an `object`-typed
+// option -- isn't valid expression syntax on its own (the parser rejects bare
+// objects to avoid ambiguity with legacy function specs); treat it like
+// `["literal", {...}]` instead, so both a schema `default` and a runtime
+// value can be written as a bare object.
+export function createConfigExpression(value: unknown, option: OptionSpecification = {} as OptionSpecification): Result<StyleExpression, Array<ParsingError>> {
+    const propertySpec = (option.type && !option.array && Array.isArray(value)) ?
+        {type: option.type, 'property-type': 'data-constant'} as unknown as StylePropertySpecification :
+        undefined;
+    const isBareObject = value !== null && typeof value === 'object' && !Array.isArray(value);
+    return createExpression(isBareObject ? ['literal', value] : value, propertySpec);
+}
+
 export class ZoomConstantExpression<Kind extends EvaluationKind> {
     kind: Kind;
     isStateDependent: boolean;
@@ -557,7 +577,8 @@ function getExpectedType(spec: StylePropertySpecification): Type {
         enum: StringType,
         boolean: BooleanType,
         formatted: FormattedType,
-        resolvedImage: ResolvedImageType
+        resolvedImage: ResolvedImageType,
+        object: ObjectType
     };
 
     if (spec.type === 'array') {

src/style-spec/reference/v8.json

@@ -380,6 +380,16 @@
         },
         "color": {
           "doc": "The result will be coerced to a color."
+        },
+        "object": {
+          "doc": "The result will be coerced to an object.",
+          "sdk-support": {
+            "basic functionality": {
+              "js": "3.29.0",
+              "android": "11.29.0",
+              "ios": "11.29.0"
+            }
+          }
         }
       }
     },
@@ -5637,13 +5647,18 @@
         }
       },
       "distance": {
-        "doc": "Returns the shortest distance in meters between the evaluated feature and the input geometry. The input value can be a valid GeoJSON of type `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, `Feature`, or `FeatureCollection`. Distance values returned may vary in precision due to loss in precision from encoding geometries, particularly below zoom level 13.",
+        "doc": "Returns the shortest distance in meters between the evaluated feature and the input geometry. The input value can be a valid GeoJSON of type `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, `Feature`, or `FeatureCollection`, or expression that returns a valid GeoJSON. Distance values returned may vary in precision due to loss in precision from encoding geometries, particularly below zoom level 13.",
         "group": "Math",
         "sdk-support": {
           "basic functionality": {
             "js": "3.0.0",
             "android": "9.2.0",
             "ios": "5.9.0"
+          },
+          "expressions support": {
+            "js": "3.29.0",
+            "android": "11.29.0",
+            "ios": "11.29.0"
           }
         }
       },

src/style-spec/types.ts

@@ -366,7 +366,7 @@ export type SchemaSpecification = {
 
 export type OptionSpecification = {
     "default": unknown | ExpressionSpecification,
-    "type"?: "string" | "number" | "boolean" | "color",
+    "type"?: "string" | "number" | "boolean" | "color" | "object",
     "array"?: boolean,
     "minValue"?: number,
     "maxValue"?: number,

src/style-spec/types/config_options.ts

@@ -7,7 +7,7 @@ export type ConfigOptionValue = {
     minValue?: number;
     maxValue?: number;
     stepValue?: number;
-    type?: 'string' | 'number' | 'boolean' | 'color';
+    type?: 'string' | 'number' | 'boolean' | 'color' | 'object';
 };
 
 export type ConfigOptions = Map<string, ConfigOptionValue>;

src/style-spec/validate/validate_option.ts

@@ -20,18 +20,32 @@ export default function validateOption(options: ValidatorOptions): ValidationErr
     const isArrayOption = isObject(optionValue) && unbundle(optionValue.array) === true;
     const declaredType = !isArrayOption && isObject(optionValue) ? unbundle(optionValue.type) : undefined;
 
+    const validateDefault = (elementOptions: ValidatorOptions): ValidationError[] => {
+        const defaultValue = elementOptions.value;
+        if (isObject(defaultValue)) {
+            // A plain object default (e.g. a GeoJSON geometry for an
+            // `object`-typed option) isn't an expression or a legacy
+            // function spec -- validate it as a bare value like a runtime
+            // `config` value, instead of running it through
+            // validateFunction()/validateExpression() (see `validate()`).
+            return validateSpec({...elementOptions, valueSpec: {...elementOptions.valueSpec, type: '*', expression: undefined} as unknown as typeof elementOptions.valueSpec});
+        }
+        // Only propagate the declared type when the default is an
+        // expression (array-form). Primitive defaults keep the previous
+        // permissive validation, mirroring the runtime parser's narrowing
+        // in style.ts/parser.cpp.
+        if (declaredType && Array.isArray(defaultValue)) {
+            return validateSpec({...elementOptions, valueSpec: {...elementOptions.valueSpec, type: declaredType} as typeof elementOptions.valueSpec});
+        }
+        return validateSpec(elementOptions);
+    };
+
     return validateObject({
         ...options,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec.option,
-        objectElementValidators: declaredType ? {
-            // Only propagate the declared type when the default is an
-            // expression (array-form). Primitive defaults keep the previous
-            // permissive validation, mirroring the runtime parser's narrowing
-            // in style.ts/parser.cpp.
-            default: (elementOptions: ValidatorOptions): ValidationError[] => (Array.isArray(elementOptions.value) ?
-                validateSpec({...elementOptions, valueSpec: {...elementOptions.valueSpec, type: declaredType} as typeof elementOptions.valueSpec}) :
-                validateSpec(elementOptions)),
-        } as Record<string, ObjectElementValidator> : undefined,
+        objectElementValidators: {
+            default: validateDefault,
+        } as Record<string, ObjectElementValidator>,
     });
 }