@mapbox/mapbox-gl-style-spec 14.12.0-beta.1 → 14.13.0-beta.1

package/expression/definitions/var.ts

@@ -26,6 +26,7 @@ class Var implements Expression {
         return new Var(name, context.scope.get(name));
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         return this.boundExpression.evaluate(ctx);
     }

package/expression/definitions/within.ts

@@ -85,6 +85,7 @@ function getTilePolygon(coordinates: Array<Array<GeoJSON.Position>>, bbox: BBox,
         }
         polygon.push(ring);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return polygon;
 }
 
@@ -94,6 +95,7 @@ function getTilePolygons(coordinates: Array<Array<Array<GeoJSON.Position>>>, bbo
         const polygon = getTilePolygon(coordinates[i], bbox, canonical);
         polygons.push(polygon);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return polygons;
 }
 
@@ -118,6 +120,7 @@ function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBB
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints = [];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (!geometry) return tilePoints;
     for (const points of geometry) {
         for (const point of points) {
@@ -126,6 +129,7 @@ function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBB
             tilePoints.push(p);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return tilePoints;
 }
 
@@ -230,12 +234,12 @@ class Within implements Expression {
         if (args.length !== 2)
             return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
         if (isValue(args[1])) {
-            const geojson = (args[1] as any);
+            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;
                     if (type === 'Polygon' || type === 'MultiPolygon') {
-                        return new Within(geojson, geojson.features[i].geometry);
+                        return new Within(geojson, geojson.features[i].geometry as GeoJSONPolygons);
                     }
                 }
             } else if (geojson.type === 'Feature') {

package/expression/expression.ts

@@ -6,7 +6,9 @@ export type SerializedExpression = Array<unknown> | Array<string> | string | num
 
 export interface Expression {
     readonly type: Type;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     value?: any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate: (ctx: EvaluationContext) => any;
     eachChild: (fn: (arg1: Expression) => void) => void;
     /**
@@ -20,6 +22,7 @@ export interface Expression {
 export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression | void;
 
 export type ExpressionRegistration = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     new(...args: any[]): Expression;
     readonly parse: ExpressionParser;
     _classRegistryKey?: string;

package/expression/index.ts

@@ -41,7 +41,7 @@ export interface Feature {
     readonly type: 0 | 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
     readonly id?: string | number | null;
     readonly properties: Record<PropertyKey, unknown>;
-    readonly patterns?: Record<PropertyKey, string>;
+    readonly patterns?: Record<PropertyKey, string[]>;
     readonly geometry?: Array<Array<Point>>;
 }
 
@@ -60,6 +60,7 @@ export interface GlobalProperties {
     readonly isSupportedScript?: (_: string) => boolean;
     accumulated?: Value;
     brightness?: number;
+    worldview?: string;
 }
 
 export class StyleExpression {
@@ -89,6 +90,7 @@ export class StyleExpression {
         formattedSection?: FormattedSection,
         featureTileCoord?: Point,
         featureDistanceData?: FeatureDistanceData,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
@@ -111,6 +113,7 @@ export class StyleExpression {
         formattedSection?: FormattedSection,
         featureTileCoord?: Point,
         featureDistanceData?: FeatureDistanceData,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
@@ -201,6 +204,7 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -212,6 +216,7 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -246,6 +251,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -257,6 +263,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -279,6 +286,7 @@ export type ConstantExpression = {
         featureState?: FeatureState,
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) => any;
 };
 
@@ -295,6 +303,7 @@ export type SourceExpression = {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) => any;
 };
 
@@ -308,6 +317,7 @@ export type CameraExpression = {
         featureState?: FeatureState,
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) => any;
     readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
     zoomStops: Array<number>;
@@ -327,6 +337,7 @@ export interface CompositeExpression {
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) => any;
     readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
     zoomStops: Array<number>;
@@ -336,6 +347,7 @@ export interface CompositeExpression {
 export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
 
 export function createPropertyExpression(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     expression: any,
     propertySpec: StylePropertySpecification,
     scope?: string | null,
@@ -343,6 +355,7 @@ export function createPropertyExpression(
 ): Result<StylePropertyExpression, Array<ParsingError>> {
     expression = createExpression(expression, propertySpec, scope, options);
     if (expression.result === 'error') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return expression;
     }
 
@@ -398,6 +411,7 @@ export class StylePropertyFunction<T> {
     _specification: StylePropertySpecification;
 
     kind: EvaluationKind;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate: (globals: GlobalProperties, feature?: Feature) => any;
     interpolationFactor: (input: number, lower: number, upper: number) => number | null | undefined;
     zoomStops: Array<number> | null | undefined;
@@ -435,7 +449,7 @@ export function normalizePropertyExpression<T>(
     options?: ConfigOptions | null,
 ): StylePropertyExpression {
     if (isFunction(value)) {
-        return new StylePropertyFunction(value, specification) as any;
+        return new StylePropertyFunction(value, specification) as unknown as StylePropertyExpression;
 
     } else if (isExpression(value) || (Array.isArray(value) && value.length > 0)) {
         const expression = createPropertyExpression(value, specification, scope, options);
@@ -446,7 +460,7 @@ export function normalizePropertyExpression<T>(
         return expression.value;
 
     } else {
-        let constant: any = value;
+        let constant = value as Color;
         if (typeof value === 'string' && specification.type === 'color') {
             constant = Color.parse(value);
         }
@@ -494,6 +508,7 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
         }
     });
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return result;
 }
 

package/expression/is_constant.ts

@@ -32,6 +32,10 @@ function isFeatureConstant(e: Expression): boolean {
         return false;
     }
 
+    if (e instanceof Config) {
+        return e.featureConstant;
+    }
+
     let result = true;
     e.eachChild(arg => {
         if (result && !isFeatureConstant(arg)) { result = false; }

package/expression/parsing_context.ts

@@ -271,5 +271,5 @@ function isConstant(expression: Expression) {
     }
 
     return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed']);
+        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'worldview', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed']);
 }

package/expression/types/formatted.ts

@@ -70,7 +70,7 @@ export default class Formatted {
                 options["font-scale"] = section.scale;
             }
             if (section.textColor) {
-                options["text-color"] = (["rgba"] as Array<unknown>).concat(section.textColor.toRenderColor(null).toArray());
+                options["text-color"] = (["rgba"] as Array<unknown>).concat(section.textColor.toNonPremultipliedRenderColor(null).toArray());
             }
             serialized.push(options);
         }

package/expression/types/image_variant.ts

@@ -72,8 +72,8 @@ export class ImageVariant {
         return new ImageVariant({name, iconsetId}, {params, transform: new DOMMatrix([a, b, c, d, e, f])});
     }
 
-    scaleSelf(factor: number): this {
-        this.options.transform.scaleSelf(factor);
+    scaleSelf(factor: number, yFactor?: number): this {
+        this.options.transform.scaleSelf(factor, yFactor);
         return this;
     }
 }

package/expression/types.ts

@@ -120,6 +120,7 @@ export function isValidType(provided: Type, allowedTypes: Array<Type>): boolean
     return allowedTypes.some(t => t.kind === provided.kind);
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidNativeType(provided: any, allowedTypes: Array<NativeType>): boolean {
     return allowedTypes.some(t => {
         if (t === 'null') {
@@ -133,3 +134,11 @@ export function isValidNativeType(provided: any, allowedTypes: Array<NativeType>
         }
     });
 }
+
+export function typeEquals(a: Type, b: Type): boolean {
+    if (a.kind === 'array' && b.kind === 'array') {
+        return a.N === b.N && typeEquals(a.itemType, b.itemType);
+    } else {
+        return a.kind === b.kind;
+    }
+}

package/expression/values.ts

@@ -135,9 +135,7 @@ export function toString(value: Value): string {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value as string | number | boolean);
-    } else if (value instanceof Color) {
-        return value.toStringPremultipliedAlpha();
-    } else if (value instanceof Formatted || value instanceof ResolvedImage) {
+    } else if (value instanceof Formatted || value instanceof ResolvedImage || value instanceof Color) {
         return value.toString();
     } else {
         return JSON.stringify(value);

package/feature_filter/convert.ts

@@ -1,6 +1,6 @@
 import {isExpressionFilter} from './index';
 
-import type {FilterSpecification} from '../types';
+import type {FilterSpecification, ExpressionSpecification} from '../types';
 
 type ExpectedTypes = {
     [_: string]: 'string' | 'number' | 'boolean';
@@ -80,17 +80,19 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
         op === '<=' ||
         op === '>='
     ) {
-        const [, property, value] = (filter as any);
+        const [, property, value] = filter;
         converted = convertComparisonOp(property, value, op, expectedTypes);
     } else if (op === 'any') {
-        const children = (filter as any).slice(1).map(f => {
+        const children = filter.slice(1).map(f => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const types: Record<string, any> = {};
             const child = _convertFilter(f, types);
             const typechecks = runtimeTypeChecks(types);
             return typechecks === true ? child : ['case', typechecks, child, false];
-        });
+        }) as ExpressionSpecification;
         return ['any'].concat(children);
     } else if (op === 'all') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const children: any[] = (filter).slice(1).map(f => _convertFilter(f, expectedTypes));
         return children.length > 1 ? ['all'].concat(children) : [].concat(...children);
     } else if (op === 'none') {
@@ -125,13 +127,16 @@ function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
         conditions.push(['==', ['typeof', get], expectedTypes[property]]);
     }
     if (conditions.length === 0) return true;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (conditions.length === 1) return conditions[0];
     return ['all'].concat(conditions);
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null) {
     let get;
     if (property === '$type') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return [op, ['geometry-type'], value];
     } else if (property === '$id') {
         get = ['id'];
@@ -140,7 +145,7 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
     }
 
     if (expectedTypes && value !== null) {
-        const type = ((typeof value) as any);
+        const type = typeof value as 'string' | 'number' | 'boolean';
         expectedTypes[property] = type;
     }
 
@@ -158,10 +163,11 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
         ];
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return [op, get, value];
 }
 
-function convertInOp(property: string, values: Array<any>, negate: boolean = false) {
+function convertInOp(property: string, values: Array<unknown>, negate: boolean = false) {
     if (values.length === 0) return negate;
 
     let get: string[];
@@ -193,6 +199,7 @@ function convertInOp(property: string, values: Array<any>, negate: boolean = fal
     }
 
     return [negate ? 'all' : 'any'].concat(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         values.map(v => [negate ? '!=' : '==', get, v]) as any[]
     );
 }

package/feature_filter/index.ts

@@ -121,6 +121,7 @@ ${JSON.stringify(filterExp, null, 2)}
         if (compiledStaticFilter.result === 'error') {
             throw new Error(compiledStaticFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
         } else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             filterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
         }
     }
@@ -135,6 +136,7 @@ ${JSON.stringify(filterExp, null, 2)}
         if (compiledDynamicFilter.result === 'error') {
             throw new Error(compiledDynamicFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
         } else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             dynamicFilterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => compiledDynamicFilter.value.evaluate(globalProperties, feature, {}, canonical, undefined, undefined, featureTileCoord, featureDistanceData);
             needFeature = !isFeatureConstant(compiledDynamicFilter.value.expression);
         }
@@ -151,6 +153,7 @@ ${JSON.stringify(filterExp, null, 2)}
     };
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function extractStaticFilter(filter: any): any {
     if (!isDynamicFilter(filter)) {
         return filter;
@@ -168,6 +171,7 @@ function extractStaticFilter(filter: any): any {
     return result;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function collapseDynamicBooleanExpressions(expression: any): any {
     if (!Array.isArray(expression)) {
         return expression;
@@ -177,6 +181,7 @@ function collapseDynamicBooleanExpressions(expression: any): any {
     if (collapsed === true) {
         return collapsed;
     } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return collapsed.map((subExpression) => collapseDynamicBooleanExpressions(subExpression));
     }
 }
@@ -190,6 +195,7 @@ function collapseDynamicBooleanExpressions(expression: any): any {
  *
  * @param {Array<any>} filter the filter expression mutated in-place.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function unionDynamicBranches(filter: any) {
     let isBranchingDynamically = false;
     const branches = [];
@@ -227,6 +233,7 @@ function unionDynamicBranches(filter: any) {
     }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isDynamicFilter(filter: any): boolean {
     // Base Cases
     if (!Array.isArray(filter)) {
@@ -262,6 +269,7 @@ const dynamicConditionExpressions = new Set([
     'to-boolean'
 ]);
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function collapsedExpression(expression: any): any {
     if (dynamicConditionExpressions.has(expression[0])) {
 
@@ -280,6 +288,7 @@ function compare(a: number, b: number) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function geometryNeeded(filter: Array<any> | boolean) {
     if (!Array.isArray(filter)) return false;
     if (filter[0] === 'within' || filter[0] === 'distance') return true;
@@ -289,6 +298,7 @@ function geometryNeeded(filter: Array<any> | boolean) {
     return false;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertFilter(filter?: Array<any> | null): unknown {
     if (!filter) return true;
     const op = filter[0];
@@ -313,22 +323,28 @@ function convertFilter(filter?: Array<any> | null): unknown {
     return converted;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertComparisonOp(property: string, value: any, op: string) {
     switch (property) {
     case '$type':
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return [`filter-type-${op}`, value];
     case '$id':
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return [`filter-id-${op}`, value];
     default:
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return [`filter-${op}`, property, value];
     }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertDisjunctionOp(filters: Array<Array<any>>) {
 // @ts-expect-error - TS2769 - No overload matches this call.
     return ['any'].concat(filters.map(convertFilter));
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertInOp(property: string, values: Array<any>) {
     if (values.length === 0) { return false; }
     switch (property) {

package/format.ts

@@ -5,6 +5,7 @@ import reference from './reference/latest';
 import stringifyPretty from 'json-stringify-pretty-compact';
 
 function sortKeysBy(obj, reference) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result: Record<string, any> = {};
     for (const key in reference) {
         if (obj[key] !== undefined) {

package/function/convert.ts

@@ -33,6 +33,7 @@ export default function convertFunction<T>(parameters: FunctionSpecification<T>,
     if (zoomAndFeatureDependent) {
         return convertZoomAndPropertyFunction(parameters, propertySpec, stops as Array<ZoomAndPropertyFunctionStop<T>>);
     } else if (zoomDependent) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return convertZoomFunction(parameters, propertySpec, stops as PropertyFunctionStop<T>[]);
     } else {
         return convertPropertyFunction(parameters, propertySpec, stops as PropertyFunctionStop<T>[]);
@@ -76,7 +77,9 @@ function convertZoomAndPropertyFunction<T>(
     propertySpec: StylePropertySpecification,
     stops: Array<ZoomAndPropertyFunctionStop<T>>,
 ): ExpressionSpecification {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const featureFunctionParameters: Record<string, any> = {};
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const featureFunctionStops: Record<string, any> = {};
     const zoomStops = [];
     for (let s = 0; s < stops.length; s++) {
@@ -221,6 +224,7 @@ function convertZoomFunction<T>(parameters: FunctionSpecification<T>, propertySp
 
     fixupDegenerateStepCurve(expression);
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return expression;
 }
 
@@ -250,7 +254,7 @@ function getFunctionType<T>(parameters: FunctionSpecification<T>, propertySpec:
         return parameters.type;
     } else {
         assert(propertySpec.expression);
-        return (propertySpec.expression as any).interpolated ? 'exponential' : 'interval';
+        return propertySpec.expression.interpolated ? 'exponential' : 'interval';
     }
 }
 

package/function/index.ts

@@ -17,6 +17,7 @@ export function isFunction(value) {
 }
 
 function identityFunction(x) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return x;
 }
 
@@ -32,6 +33,7 @@ export function createFunction(parameters, propertySpec) {
 
         if (parameters.stops) {
             parameters.stops = parameters.stops.map((stop) => {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return [stop[0], Color.parse(stop[1])];
             });
         }
@@ -73,6 +75,7 @@ export function createFunction(parameters, propertySpec) {
     }
 
     if (zoomAndFeatureDependent) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const featureFunctions: Record<string, any> = {};
         const zoomStops = [];
         for (let s = 0; s < parameters.stops.length; s++) {
@@ -101,8 +104,10 @@ export function createFunction(parameters, propertySpec) {
             kind: 'composite',
             interpolationType,
             interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             zoomStops: featureFunctionStops.map(s => s[0]),
             evaluate({zoom}, properties) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return evaluateExponentialFunction({
                     stops: featureFunctionStops,
                     base: parameters.base
@@ -116,7 +121,9 @@ export function createFunction(parameters, propertySpec) {
             kind: 'camera',
             interpolationType,
             interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             zoomStops: parameters.stops.map(s => s[0]),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
     } else {
@@ -125,8 +132,10 @@ export function createFunction(parameters, propertySpec) {
             evaluate(_, feature) {
                 const value = feature && feature.properties ? feature.properties[parameters.property] : undefined;
                 if (value === undefined) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                     return coalesce(parameters.default, propertySpec.default);
                 }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
             }
         };
@@ -134,26 +143,36 @@ export function createFunction(parameters, propertySpec) {
 }
 
 function coalesce(a, b, c) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (a !== undefined) return a;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (b !== undefined) return b;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (c !== undefined) return c;
 }
 
 function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
     const evaluated = typeof input === keyType ? hashedStops[input] : undefined; // Enforce strict typing on input
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return coalesce(evaluated, parameters.default, propertySpec.default);
 }
 
 function evaluateIntervalFunction(parameters, propertySpec, input) {
     // Edge cases
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (getType(input) !== 'number') return coalesce(parameters.default, propertySpec.default);
     const n = parameters.stops.length;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (n === 1) return parameters.stops[0][1];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     const index = findStopLessThanOrEqualTo(parameters.stops.map((stop) => stop[0]), input);
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return parameters.stops[index][1];
 }
 
@@ -161,12 +180,17 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
     const base = parameters.base !== undefined ? parameters.base : 1;
 
     // Edge cases
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (getType(input) !== 'number') return coalesce(parameters.default, propertySpec.default);
     const n = parameters.stops.length;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (n === 1) return parameters.stops[0][1];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     const index = findStopLessThanOrEqualTo(parameters.stops.map((stop) => stop[0]), input);
     const t = interpolationFactor(
         input, base,
@@ -179,6 +203,7 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
 
     if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
         const colorspace = colorSpaces[parameters.colorSpace];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         interp = (a, b) => colorspace.reverse(colorspace.interpolate(colorspace.forward(a), colorspace.forward(b), t));
     }
 
@@ -191,11 +216,13 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
                 if (evaluatedLower === undefined || evaluatedUpper === undefined) {
                     return undefined;
                 }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return interp(evaluatedLower, evaluatedUpper, t);
             }
         };
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return interp(outputLower, outputUpper, t);
 }
 
@@ -209,6 +236,7 @@ function evaluateIdentityFunction(parameters, propertySpec, input) {
     } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
         input = undefined;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return coalesce(input, parameters.default, propertySpec.default);
 }