@mapbox/mapbox-gl-style-spec 14.28.0 → 14.29.0

package/expression/definitions/interpolate.ts

@@ -111,7 +111,7 @@ class Interpolate implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = null;
+        let outputType: Type | null = null;
         if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
             outputType = ColorType;
         } else if (context.expectedType && context.expectedType.kind !== 'value') {
@@ -129,7 +129,7 @@ class Interpolate implements Expression {
                 return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
-            if (stops.length && stops.at(-1)[0] >= label) {
+            if (stops.length && stops.at(-1)![0] >= label) {
                 return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 
@@ -139,15 +139,15 @@ class Interpolate implements Expression {
             stops.push([label, parsed]);
         }
 
-        if (outputType.kind !== 'number' &&
-            outputType.kind !== 'color' &&
+        if (outputType!.kind !== 'number' &&
+            outputType!.kind !== 'color' &&
             !(
-                outputType.kind === 'array' &&
+                outputType!.kind === 'array' &&
                 outputType.itemType.kind === 'number' &&
                 typeof outputType.N === 'number'
             )
         ) {
-            return context.error(`Type ${toString(outputType)} is not interpolatable.`);
+            return context.error(`Type ${toString(outputType!)} is not interpolatable.`);
         }
 
         return new Interpolate(outputType, operator as InterpolationOperator, interpolation as InterpolationType, input as Expression, stops);
@@ -158,33 +158,32 @@ class Interpolate implements Expression {
         const outputs = this.outputs;
 
         if (labels.length === 1) {
-            return outputs[0].evaluate(ctx) as Color;
+            return outputs[0]!.evaluate(ctx) as Color;
         }
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const value: number = this.input.evaluate(ctx);
-        if (value <= labels[0]) {
-            return outputs[0].evaluate(ctx) as Color;
+        if (value <= labels[0]!) {
+            return outputs[0]!.evaluate(ctx) as Color;
         }
 
         const stopCount = labels.length;
-        if (value >= labels[stopCount - 1]) {
-            return outputs[stopCount - 1].evaluate(ctx) as Color;
+        if (value >= labels[stopCount - 1]!) {
+            return outputs[stopCount - 1]!.evaluate(ctx) as Color;
         }
 
         const index = findStopLessThanOrEqualTo(labels, value);
-        const lower = labels[index];
-        const upper = labels[index + 1];
+        const lower = labels[index]!;
+        const upper = labels[index + 1]!;
         const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const outputLower: Color = outputs[index].evaluate(ctx);
+        const outputLower: Color = outputs[index]!.evaluate(ctx);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const outputUpper: Color = outputs[index + 1].evaluate(ctx);
+        const outputUpper: Color = outputs[index + 1]!.evaluate(ctx);
 
         if (this.operator === 'interpolate') {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-            return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
+            return (interpolate[this.type.kind.toLowerCase() as keyof typeof interpolate] as (from: Color, to: Color, t: number) => Color)(outputLower, outputUpper, t);
         } else if (this.operator === 'interpolate-hcl') {
             return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
         } else {
@@ -221,8 +220,8 @@ class Interpolate implements Expression {
 
         for (let i = 0; i < this.labels.length; i++) {
             serialized.push(
-                this.labels[i],
-                this.outputs[i].serialize()
+                this.labels[i]!,
+                this.outputs[i]!.serialize()
             );
         }
         return serialized;

package/expression/definitions/let.ts

@@ -12,8 +12,7 @@ class Let implements Expression {
 
     constructor(bindings: Array<[string, Expression]>, result: Expression) {
         this.type = result.type;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        this.bindings = [].concat(bindings);
+        this.bindings = ([] as Array<[string, Expression]>).concat(bindings);
         this.result = result;
     }
 

package/expression/definitions/literal.ts

@@ -67,7 +67,7 @@ class Literal implements Expression {
                 typeof this.value === 'string' ||
                 typeof this.value === 'number' ||
                 typeof this.value === 'boolean');
-            return this.value as SerializedExpression;
+            return this.value;
         }
     }
 }

package/expression/definitions/match.ts

@@ -94,14 +94,13 @@ class Match implements Expression {
             return null;
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Match(inputType, outputType, input, cases, outputs, otherwise);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         const input = (this.input.evaluate(ctx)) as number | string;
-        const output = (typeEquals(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);
     }
 
@@ -129,14 +128,14 @@ class Match implements Expression {
             [index: number]: number;
         } = {}; // lookup index into groupedByOutput for a given output expression
         for (const label of sortedLabels) {
-            const outputIndex = outputLookup[this.cases[label]];
+            const outputIndex = outputLookup[this.cases[label]!];
             if (outputIndex === undefined) {
                 // First time seeing this output, add it to the end of the grouped list
-                outputLookup[this.cases[label]] = groupedByOutput.length;
-                groupedByOutput.push([this.cases[label], [label]]);
+                outputLookup[this.cases[label]!] = groupedByOutput.length;
+                groupedByOutput.push([this.cases[label]!, [label]]);
             } else {
                 // We've seen this expression before, add the label to that output's group
-                groupedByOutput[outputIndex][1].push(label);
+                groupedByOutput[outputIndex]![1].push(label);
             }
         }
 
@@ -145,12 +144,12 @@ class Match implements Expression {
         for (const [outputIndex, labels] of groupedByOutput) {
             if (labels.length === 1) {
                 // Only a single label matches this output expression
-                serialized.push(coerceLabel(labels[0]));
+                serialized.push(coerceLabel(labels[0]!));
             } else {
                 // Array of literal labels pointing to this output expression
                 serialized.push(labels.map(coerceLabel));
             }
-            serialized.push(this.outputs[outputIndex].serialize());
+            serialized.push(this.outputs[outputIndex]!.serialize());
         }
         serialized.push(this.otherwise.serialize());
         return serialized;

package/expression/definitions/number_format.ts

@@ -31,48 +31,47 @@ export default class NumberFormat implements Expression {
         this.maxFractionDigits = maxFractionDigits;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | void {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | void {
         if (args.length !== 3)
             return context.error(`Expected two arguments.`);
 
         const number = context.parse(args[1], 1, NumberType);
         if (!number) return null;
 
-        const options = args[2];
+        const options = args[2] as Record<string, unknown>;
         if (typeof options !== "object" || Array.isArray(options))
             return context.error(`NumberFormat options argument must be an object.`);
 
-        let locale = null;
+        let locale: Expression | null | void = null;
         if (options['locale']) {
             locale = context.parseObjectValue(options['locale'], 2, 'locale', StringType);
             if (!locale) return null;
         }
 
-        let currency = null;
+        let currency: Expression | null | void = null;
         if (options['currency']) {
             currency = context.parseObjectValue(options['currency'], 2, 'currency', StringType);
             if (!currency) return null;
         }
 
-        let unit = null;
+        let unit: Expression | null | void = null;
         if (options['unit']) {
             unit = context.parseObjectValue(options['unit'], 2, 'unit', StringType);
             if (!unit) return null;
         }
 
-        let minFractionDigits = null;
+        let minFractionDigits: Expression | null | void = null;
         if (options['min-fraction-digits'] !== undefined) {
             minFractionDigits = context.parseObjectValue(options['min-fraction-digits'], 2, 'min-fraction-digits', NumberType);
             if (!minFractionDigits) return null;
         }
 
-        let maxFractionDigits = null;
+        let maxFractionDigits: Expression | null | void = null;
         if (options['max-fraction-digits'] !== undefined) {
             maxFractionDigits = context.parseObjectValue(options['max-fraction-digits'], 2, 'max-fraction-digits', NumberType);
             if (!maxFractionDigits) return null;
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new NumberFormat(number, locale, currency, unit, minFractionDigits, maxFractionDigits);
     }
 

package/expression/definitions/step.ts

@@ -40,7 +40,7 @@ class Step implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = null;
+        let outputType: Type | null = null;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
@@ -56,7 +56,7 @@ class Step implements Expression {
                 return context.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
-            if (stops.length && stops.at(-1)[0] >= label) {
+            if (stops.length && stops.at(-1)![0] >= label) {
                 return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 
@@ -66,7 +66,7 @@ class Step implements Expression {
             stops.push([label, parsed]);
         }
 
-        return new Step(outputType, input, stops);
+        return new Step(outputType!, input, stops);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -75,21 +75,21 @@ class Step implements Expression {
         const outputs = this.outputs;
 
         if (labels.length === 1) {
-            return outputs[0].evaluate(ctx);
+            return outputs[0]!.evaluate(ctx);
         }
 
         const value = (this.input.evaluate(ctx) as number);
-        if (value <= labels[0]) {
-            return outputs[0].evaluate(ctx);
+        if (value <= labels[0]!) {
+            return outputs[0]!.evaluate(ctx);
         }
 
         const stopCount = labels.length;
-        if (value >= labels[stopCount - 1]) {
-            return outputs[stopCount - 1].evaluate(ctx);
+        if (value >= labels[stopCount - 1]!) {
+            return outputs[stopCount - 1]!.evaluate(ctx);
         }
 
         const index = findStopLessThanOrEqualTo(labels, value);
-        return outputs[index].evaluate(ctx);
+        return outputs[index]!.evaluate(ctx);
     }
 
     eachChild(fn: (_: Expression) => void) {
@@ -107,9 +107,9 @@ class Step implements Expression {
         const serialized = ["step", this.input.serialize()];
         for (let i = 0; i < this.labels.length; i++) {
             if (i > 0) {
-                serialized.push(this.labels[i]);
+                serialized.push(this.labels[i]!);
             }
-            serialized.push(this.outputs[i].serialize());
+            serialized.push(this.outputs[i]!.serialize());
         }
         return serialized;
     }

package/expression/definitions/within.ts

@@ -15,16 +15,16 @@ type GeoJSONPolygons = GeoJSON.Polygon | GeoJSON.MultiPolygon;
 
 const EXTENT = 8192;
 
-function getTileCoordinates(p: GeoJSON.Position, canonical: CanonicalTileID) {
-    const x = mercatorXfromLng(p[0]);
-    const y = mercatorYfromLat(p[1]);
+function getTileCoordinates(p: GeoJSON.Position, canonical: CanonicalTileID): [number, number] {
+    const x = mercatorXfromLng(p[0]!);
+    const y = mercatorYfromLat(p[1]!);
     const tilesAtZoom = Math.pow(2, canonical.z);
     return [Math.round(x * tilesAtZoom * EXTENT), Math.round(y * tilesAtZoom * EXTENT)];
 }
 
 function pointWithinPolygons(point: GeoJSON.Position, polygons: Array<Array<Array<GeoJSON.Position>>>) {
     for (let i = 0; i < polygons.length; i++) {
-        if (pointWithinPolygon(point, polygons[i])) return true;
+        if (pointWithinPolygon(point, polygons[i]!)) return true;
     }
     return false;
 }
@@ -33,8 +33,8 @@ function lineIntersectPolygon(p1: GeoJSON.Position, p2: GeoJSON.Position, polygo
     for (const ring of polygon) {
         // loop through every edge of the ring
         for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
-            const q1 = ring[k];
-            const q2 = ring[j];
+            const q1 = ring[k]!;
+            const q2 = ring[j]!;
             if (segmentIntersectSegment(p1, p2, q1, q2)) {
                 return true;
             }
@@ -46,14 +46,14 @@ function lineIntersectPolygon(p1: GeoJSON.Position, p2: GeoJSON.Position, polygo
 function lineStringWithinPolygon(line: Array<GeoJSON.Position>, polygon: Array<Array<GeoJSON.Position>>) {
     // First, check if geometry points of line segments are all inside polygon
     for (let i = 0; i < line.length; ++i) {
-        if (!pointWithinPolygon(line[i], polygon)) {
+        if (!pointWithinPolygon(line[i]!, polygon)) {
             return false;
         }
     }
 
     // Second, check if there is line segment intersecting polygon edge
     for (let i = 0; i < line.length - 1; ++i) {
-        if (lineIntersectPolygon(line[i], line[i + 1], polygon)) {
+        if (lineIntersectPolygon(line[i]!, line[i + 1]!, polygon)) {
             return false;
         }
     }
@@ -62,7 +62,7 @@ function lineStringWithinPolygon(line: Array<GeoJSON.Position>, polygon: Array<A
 
 function lineStringWithinPolygons(line: Array<GeoJSON.Position>, polygons: Array<Array<Array<GeoJSON.Position>>>) {
     for (let i = 0; i < polygons.length; i++) {
-        if (lineStringWithinPolygon(line, polygons[i])) return true;
+        if (lineStringWithinPolygon(line, polygons[i]!)) return true;
     }
     return false;
 }
@@ -71,8 +71,8 @@ function getTilePolygon(coordinates: Array<Array<GeoJSON.Position>>, bbox: BBox,
     const polygon: Array<Array<number[]>> = [];
     for (let i = 0; i < coordinates.length; i++) {
         const ring: number[][] = [];
-        for (let j = 0; j < coordinates[i].length; j++) {
-            const coord = getTileCoordinates(coordinates[i][j], canonical);
+        for (let j = 0; j < coordinates[i]!.length; j++) {
+            const coord = getTileCoordinates(coordinates[i]![j]!, canonical);
             updateBBox(bbox, coord);
             ring.push(coord);
         }
@@ -85,14 +85,14 @@ function getTilePolygon(coordinates: Array<Array<GeoJSON.Position>>, bbox: BBox,
 function getTilePolygons(coordinates: Array<Array<Array<GeoJSON.Position>>>, bbox: BBox, canonical: CanonicalTileID): Array<Array<Array<number[]>>> {
     const polygons: Array<Array<Array<number[]>>> = [];
     for (let i = 0; i < coordinates.length; i++) {
-        const polygon = getTilePolygon(coordinates[i], bbox, canonical);
+        const polygon = getTilePolygon(coordinates[i]!, bbox, canonical);
         polygons.push(polygon);
     }
 
     return polygons;
 }
 
-function updatePoint(p: GeoJSON.Position, bbox: BBox, polyBBox: Array<number>, worldSize: number) {
+function updatePoint(p: [number, number], bbox: BBox, polyBBox: BBox, worldSize: number) {
     if (p[0] < polyBBox[0] || p[0] > polyBBox[2]) {
         const halfWorldSize = worldSize * 0.5;
         let shift = (p[0] - polyBBox[0] > halfWorldSize) ? -worldSize : (polyBBox[0] - p[0] > halfWorldSize) ? worldSize : 0;
@@ -109,14 +109,14 @@ function resetBBox(bbox: BBox) {
     bbox[2] = bbox[3] = -Infinity;
 }
 
-function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID): Array<number[]> {
+function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBBox: BBox, polyBBox: BBox, canonical: CanonicalTileID): Array<number[]> {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
-    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const shifts: [number, number] = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints: Array<number[]> = [];
     if (!geometry) return tilePoints;
     for (const points of geometry) {
         for (const point of points) {
-            const p = [point.x + shifts[0], point.y + shifts[1]];
+            const p: [number, number] = [point.x + shifts[0], point.y + shifts[1]];
             updatePoint(p, pointBBox, polyBBox, worldSize);
             tilePoints.push(p);
         }
@@ -125,19 +125,18 @@ function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBB
     return tilePoints;
 }
 
-function getTileLines(geometry: Array<Array<Point>> | null | undefined, lineBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID): Array<Array<GeoJSON.Position>> {
+function getTileLines(geometry: Array<Array<Point>> | null | undefined, lineBBox: BBox, polyBBox: BBox, canonical: CanonicalTileID): Array<Array<GeoJSON.Position>> {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
-    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
-    const tileLines: Array<Array<GeoJSON.Position>> = [];
+    const shifts: [number, number] = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const tileLines: Array<Array<[number, number]>> = [];
     if (!geometry) return tileLines;
     for (const line of geometry) {
-        const tileLine = [];
+        const tileLine: Array<[number, number]> = [];
         for (const point of line) {
-            const p: GeoJSON.Position = [point.x + shifts[0], point.y + shifts[1]];
+            const p: [number, number] = [point.x + shifts[0], point.y + shifts[1]];
             updateBBox(lineBBox, p);
             tileLine.push(p);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         tileLines.push(tileLine);
     }
     if (lineBBox[2] - lineBBox[0] <= worldSize / 2) {
@@ -230,9 +229,9 @@ class Within implements Expression {
             const geojson = args[1] as GeoJSON.GeoJSON;
             if (geojson.type === 'FeatureCollection') {
                 for (let i = 0; i < geojson.features.length; ++i) {
-                    const type = geojson.features[i].geometry.type;
+                    const type = geojson.features[i]!.geometry.type;
                     if (type === 'Polygon' || type === 'MultiPolygon') {
-                        return new Within(geojson, geojson.features[i].geometry as GeoJSONPolygons);
+                        return new Within(geojson, geojson.features[i]!.geometry as GeoJSONPolygons);
                     }
                 }
             } else if (geojson.type === 'Feature') {

package/expression/evaluation_context.ts

@@ -11,7 +11,7 @@ import type {ConfigOptions, ConfigOptionValue} from '../types/config_options';
 const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
 
 class EvaluationContext {
-    globals: GlobalProperties;
+    globals: GlobalProperties | null;
     feature: Feature | null | undefined;
     featureState: FeatureState | null | undefined;
     formattedSection: FormattedSection | null | undefined;
@@ -23,7 +23,7 @@ class EvaluationContext {
     options: ConfigOptions | null | undefined;
     iconImageUseTheme: string | null | undefined;
 
-    constructor(scope?: string | null, options?: ConfigOptions | null, iconImageUseTheme?: string) {
+    constructor(scope?: string | null, options?: ConfigOptions | null, iconImageUseTheme?: string | null) {
         this.globals = null;
         this.feature = null;
         this.featureState = null;
@@ -42,7 +42,7 @@ class EvaluationContext {
     }
 
     geometryType(): null | string {
-        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
+        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type]! : this.feature.type : null;
     }
 
     geometry(): Array<Array<Point>> | null | undefined {
@@ -58,7 +58,7 @@ class EvaluationContext {
     }
 
     measureLight(_: string): number {
-        return this.globals.brightness || 0;
+        return this.globals!.brightness || 0;
     }
 
     distanceFromCenter(): number {

package/expression/expression.ts

@@ -19,7 +19,7 @@ export interface Expression {
     serialize: () => SerializedExpression;
 }
 
-export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression | void;
+export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression | null | void;
 
 export type ExpressionRegistration = {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/expression/index.ts

@@ -21,7 +21,7 @@ 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';
@@ -29,7 +29,7 @@ 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';
@@ -66,17 +66,17 @@ export interface GlobalProperties {
 
 export class StyleExpression {
     expression: Expression;
-    _scope?: string;
-    _options?: ConfigOptions;
-    _iconImageUseTheme?: string;
+    _scope?: string | null;
+    _options?: ConfigOptions | null;
+    _iconImageUseTheme?: string | null;
     _evaluator?: EvaluationContext;
     _defaultValue: Value;
     _warningHistory: {[key: string]: boolean};
-    _enumValues?: {[_: string]: unknown};
+    _enumValues?: {[_: string]: unknown} | null;
     configDependencies: Set<string>;
     isIndoorDependent: boolean;
 
-    constructor(expression: Expression, propertySpec?: StylePropertySpecification, scope?: string, options?: ConfigOptions, iconImageUseTheme?: string) {
+    constructor(expression: Expression, propertySpec?: StylePropertySpecification | null, scope?: string | null, options?: ConfigOptions | null, iconImageUseTheme?: string | null) {
         this.expression = expression;
         this._warningHistory = {};
         this._scope = scope;
@@ -100,16 +100,17 @@ export class StyleExpression {
         featureDistanceData?: FeatureDistanceData,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
-        this._evaluator.globals = globals;
-        this._evaluator.feature = feature;
-        this._evaluator.featureState = featureState;
-        this._evaluator.canonical = canonical || null;
-        this._evaluator.availableImages = availableImages || null;
-        this._evaluator.formattedSection = formattedSection;
-        this._evaluator.featureTileCoord = featureTileCoord || null;
-        this._evaluator.featureDistanceData = featureDistanceData || null;
-
-        return this.expression.evaluate(this._evaluator);
+        const evaluator = this._evaluator!;
+        evaluator.globals = globals;
+        evaluator.feature = feature;
+        evaluator.featureState = featureState;
+        evaluator.canonical = canonical || null;
+        evaluator.availableImages = availableImages || null;
+        evaluator.formattedSection = formattedSection;
+        evaluator.featureTileCoord = featureTileCoord || null;
+        evaluator.featureDistanceData = featureDistanceData || null;
+
+        return this.expression.evaluate(evaluator);
     }
 
     evaluate(
@@ -197,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;
@@ -446,9 +467,9 @@ export class StylePropertyFunction<T> {
     _parameters: PropertyValueSpecification<T>;
     _specification: StylePropertySpecification;
 
-    kind: EvaluationKind;
-    evaluate: <T = unknown>(globals: GlobalProperties, feature?: Feature) => T;
-    interpolationFactor: (input: number, lower: number, upper: number) => number | null | undefined;
+    kind!: EvaluationKind;
+    evaluate!: <T = unknown>(globals: GlobalProperties, feature?: Feature) => T;
+    interpolationFactor!: (input: number, lower: number, upper: number) => number | null | undefined;
     zoomStops: Array<number> | null | undefined;
 
     constructor(parameters: PropertyValueSpecification<T>, specification: StylePropertySpecification) {
@@ -556,7 +577,8 @@ function getExpectedType(spec: StylePropertySpecification): Type {
         enum: StringType,
         boolean: BooleanType,
         formatted: FormattedType,
-        resolvedImage: ResolvedImageType
+        resolvedImage: ResolvedImageType,
+        object: ObjectType
     };
 
     if (spec.type === 'array') {

package/expression/parsing_context.ts

@@ -28,7 +28,7 @@ class ParsingContext {
     errors: Array<ParsingError>;
     _scope: string | null | undefined;
     options: ConfigOptions | null | undefined;
-    iconImageUseTheme: string;
+    iconImageUseTheme: string | null | undefined;
 
     // The expected type of this expression. Provided only to allow Expression
     // implementations to infer argument types: Expression#parse() need not
@@ -44,7 +44,7 @@ class ParsingContext {
         errors: Array<ParsingError> = [],
         _scope?: string | null,
         options?: ConfigOptions | null,
-        iconImageUseTheme?: string
+        iconImageUseTheme?: string | null
     ) {
         this.registry = registry;
         this.path = path;

package/expression/stops.ts

@@ -18,8 +18,8 @@ export function findStopLessThanOrEqualTo(stops: Array<number>, input: number):
 
     while (lowerIndex <= upperIndex) {
         currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
-        currentValue = stops[currentIndex];
-        nextValue = stops[currentIndex + 1];
+        currentValue = stops[currentIndex]!;
+        nextValue = stops[currentIndex + 1]!;
 
         if (currentValue <= input) {
             if (currentIndex === lastIndex || input < nextValue) { // Search complete

package/expression/values.ts

@@ -79,7 +79,7 @@ export function isValue(mixed: unknown): boolean {
         return true;
     } else if (typeof mixed === 'object') {
         for (const key in mixed) {
-            if (!isValue(mixed[key])) {
+            if (!isValue((mixed as Record<string, unknown>)[key])) {
                 return false;
             }
         }
@@ -108,7 +108,7 @@ export function typeOf(value: Value): Type {
         return ResolvedImageType;
     } else if (Array.isArray(value)) {
         const length = value.length;
-        let itemType: Type;
+        let itemType: Type | undefined;
 
         for (const item of value) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument