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

package/expression/index.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-import extend from '../util/extend';
 import ParsingError from './parsing_error';
 import ParsingContext from './parsing_context';
 import EvaluationContext from './evaluation_context';
@@ -127,6 +126,7 @@ export class StyleExpression {
         this._evaluator.iconImageUseTheme = iconImageUseTheme || null;
 
         try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const val = this.expression.evaluate(this._evaluator);
             // eslint-disable-next-line no-self-compare
             if (val === null || val === undefined || (typeof val === 'number' && val !== val)) {
@@ -137,9 +137,12 @@ export class StyleExpression {
             }
             return val;
         } catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (!this._warningHistory[e.message]) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 this._warningHistory[e.message] = true;
                 if (typeof console !== 'undefined') {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                     console.warn(`Failed to evaluate expression "${JSON.stringify(this.expression.serialize())}". ${e.message}`);
                 }
             }
@@ -284,7 +287,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
 export type ConstantExpression = {
     kind: 'constant';
     configDependencies: Set<string>;
-    readonly evaluate: (
+    readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
         feature?: Feature,
         featureState?: FeatureState,
@@ -292,8 +295,7 @@ export type ConstantExpression = {
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
         iconImageUseTheme?: string
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) => any;
+    ) => T;
 };
 
 export type SourceExpression = {
@@ -302,29 +304,27 @@ export type SourceExpression = {
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
     configDependencies: Set<string>;
-    readonly evaluate: (
+    readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
         feature?: Feature,
         featureState?: FeatureState,
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) => any;
+    ) => T;
 };
 
 export type CameraExpression = {
     kind: 'camera';
     isStateDependent: boolean;
     configDependencies: Set<string>;
-    readonly evaluate: (
+    readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
         feature?: Feature,
         featureState?: FeatureState,
         canonical?: CanonicalTileID,
         availableImages?: ImageId[],
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) => any;
+    ) => T;
     readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
     zoomStops: Array<number>;
     interpolationType: InterpolationType | null | undefined;
@@ -336,7 +336,7 @@ export interface CompositeExpression {
     isLightConstant: boolean | null | undefined;
     isLineProgressConstant: boolean | null | undefined;
     configDependencies: Set<string>;
-    readonly evaluate: (
+    readonly evaluate: <T = unknown>(
         globals: GlobalProperties,
         feature?: Feature,
         featureState?: FeatureState,
@@ -344,8 +344,7 @@ export interface CompositeExpression {
         availableImages?: ImageId[],
         formattedSection?: FormattedSection,
         iconImageUseTheme?: string
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) => any;
+    ) => T;
     readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
     zoomStops: Array<number>;
     interpolationType: InterpolationType | null | undefined;
@@ -362,33 +361,40 @@ export function createPropertyExpression(
     iconImageUseTheme?: string | null
 ): Result<StylePropertyExpression, Array<ParsingError>> {
     expression = createExpression(expression, propertySpec, scope, options, iconImageUseTheme);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (expression.result === 'error') {
         return expression as Result<StylePropertyExpression, Array<ParsingError>>;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
     const parsed = expression.value.expression;
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const isFeatureConstant = isConstant.isFeatureConstant(parsed);
     if (!isFeatureConstant && !supportsPropertyExpression(propertySpec)) {
         return error([new ParsingError('', 'data expressions not supported')]);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const isZoomConstant = isConstant.isGlobalPropertyConstant(parsed, ['zoom', 'pitch', 'distance-from-center']);
     if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
         return error([new ParsingError('', 'zoom expressions not supported')]);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const isLightConstant = isConstant.isGlobalPropertyConstant(parsed, ['measure-light']);
     if (!isLightConstant && !supportsLightExpression(propertySpec)) {
         return error([new ParsingError('', 'measure-light expression not supported')]);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const isLineProgressConstant = isConstant.isGlobalPropertyConstant(parsed, ['line-progress']);
     if (!isLineProgressConstant && !supportsLineProgressExpression(propertySpec)) {
         return error([new ParsingError('', 'line-progress expression not supported')]);
     }
 
     const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
         return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression, or in the properties of atmosphere.')]);
@@ -400,14 +406,18 @@ export function createPropertyExpression(
 
     if (!zoomCurve) {
         return success((isFeatureConstant && isLineProgressConstant) ?
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             (new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) as ConstantExpression) :
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             (new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant) as SourceExpression));
     }
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
     return success((isFeatureConstant && isLineProgressConstant) ?
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
         (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CameraExpression) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
         (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CompositeExpression));
 }
 
@@ -418,15 +428,14 @@ export class StylePropertyFunction<T> {
     _specification: StylePropertySpecification;
 
     kind: EvaluationKind;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    evaluate: (globals: GlobalProperties, feature?: Feature) => any;
+    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) {
         this._parameters = parameters;
         this._specification = specification;
-        extend(this, createFunction(this._parameters, this._specification));
+        Object.assign(this, createFunction(this._parameters, this._specification));
     }
 
     static deserialize<T>(
@@ -468,15 +477,15 @@ export function normalizePropertyExpression<T>(
         return expression.value;
 
     } else {
-        let constant = value as Color;
+        let constant = value;
         if (typeof value === 'string' && specification.type === 'color') {
-            constant = Color.parse(value);
+            constant = Color.parse(value) as PropertyValueSpecification<T>;
         }
         return {
             kind: 'constant',
             configDependencies: new Set(),
             evaluate: () => constant
-        };
+        } as ConstantExpression;
     }
 }
 

package/expression/parsing_context.ts

@@ -159,8 +159,10 @@ class ParsingContext {
                 if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
                     const ec = new EvaluationContext(this._scope, this.options, this.iconImageUseTheme);
                     try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                         parsed = new Literal(parsed.type, parsed.evaluate(ec));
                     } catch (e) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
                         this.error(e.message);
                         return null;
                     }

package/expression/types/image_variant.ts

@@ -61,6 +61,7 @@ export class ImageVariant {
         let name, iconsetId, params, transform;
 
         try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             ({name, iconsetId, params, transform} = JSON.parse(str) || {});
         } catch (e) {
             return null;
@@ -68,7 +69,9 @@ export class ImageVariant {
 
         if (!name) return null;
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {a, b, c, d, e, f} = transform || {};
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         return new ImageVariant({name, iconsetId}, {params, transform: new DOMMatrix([a, b, c, d, e, f])});
     }
 

package/expression/types.ts

@@ -131,8 +131,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 {
+export function isValidNativeType(provided: unknown, allowedTypes: Array<NativeType>): boolean {
     return allowedTypes.some(t => {
         if (t === 'null') {
             return provided === null;

package/expression/values.ts

@@ -111,6 +111,7 @@ export function typeOf(value: Value): Type {
         let itemType: Type;
 
         for (const item of value) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const t = typeOf(item);
             if (!itemType) {
                 itemType = t;

package/feature_filter/convert.ts

@@ -81,29 +81,37 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
         op === '>='
     ) {
         const [, property, value] = filter;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         converted = convertComparisonOp(property, value, op, expectedTypes);
     } else if (op === 'any') {
         const children = filter.slice(1).map(f => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const types: Record<string, any> = {};
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const child = _convertFilter(f, types);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             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
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
         const children: any[] = (filter).slice(1).map(f => _convertFilter(f, expectedTypes));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return children.length > 1 ? ['all'].concat(children) : [].concat(...children);
     } else if (op === 'none') {
         return ['!', _convertFilter(['any'].concat((filter).slice(1)), {})];
     } else if (op === 'in') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         converted = convertInOp((filter[1]), filter.slice(2));
     } else if (op === '!in') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         converted = convertInOp((filter[1]), filter.slice(2), true);
     } else if (op === 'has') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         converted = convertHasOp((filter[1]));
     } else if (op === '!has') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         converted = ['!', convertHasOp((filter[1]))];
     } else {
         converted = true;

package/feature_filter/index.ts

@@ -98,6 +98,7 @@ function createFilter(filter?: FilterSpecification, scope: string = "", options:
 
     let staticFilter = true;
     try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         staticFilter = extractStaticFilter(filterExp);
     } catch (e) {
         console.warn(
@@ -114,8 +115,10 @@ ${JSON.stringify(filterExp, null, 2)}
     let filterFunc = null;
     let filterSpec = null;
     if (layerType !== 'background' && layerType !== 'sky' && layerType !== 'slot') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         filterSpec = latest[`filter_${layerType}`];
         assert(filterSpec);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
 
         if (compiledStaticFilter.result === 'error') {
@@ -131,6 +134,7 @@ ${JSON.stringify(filterExp, null, 2)}
     let dynamicFilterFunc = null;
     let needFeature = null;
     if (staticFilter !== filterExp) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         const compiledDynamicFilter = createExpression(filterExp, filterSpec, scope, options);
 
         if (compiledDynamicFilter.result === 'error') {
@@ -146,7 +150,9 @@ ${JSON.stringify(filterExp, null, 2)}
     const needGeometry = geometryNeeded(staticFilter);
 
     return {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         filter: filterFunc,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         dynamicFilter: dynamicFilterFunc ? dynamicFilterFunc : undefined,
         needGeometry,
         needFeature: !!needFeature
@@ -177,11 +183,12 @@ function collapseDynamicBooleanExpressions(expression: any): any {
         return expression;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const collapsed = collapsedExpression(expression);
     if (collapsed === true) {
         return collapsed;
     } else {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         return collapsed.map((subExpression) => collapseDynamicBooleanExpressions(subExpression));
     }
 }
@@ -200,35 +207,53 @@ function unionDynamicBranches(filter: any) {
     let isBranchingDynamically = false;
     const branches = [];
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (filter[0] === 'case') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 1; i < filter.length - 1; i += 2) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[i]);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         branches.push(filter[filter.length - 1]);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     } else if (filter[0] === 'match') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 2; i < filter.length - 1; i += 2) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         branches.push(filter[filter.length - 1]);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     } else if (filter[0] === 'step') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         isBranchingDynamically = isBranchingDynamically || isDynamicFilter(filter[1]);
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 1; i < filter.length - 1; i += 2) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             branches.push(filter[i + 1]);
         }
     }
 
     if (isBranchingDynamically) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         filter.length = 0;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         filter.push('any', ...branches);
     }
 
     // traverse and recurse into children
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     for (let i = 1; i < filter.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         unionDynamicBranches(filter[i]);
     }
 }
@@ -239,11 +264,13 @@ function isDynamicFilter(filter: any): boolean {
     if (!Array.isArray(filter)) {
         return false;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     if (isRootExpressionDynamic(filter[0])) {
         return true;
     }
 
     for (let i = 1; i < filter.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const child = filter[i];
         if (isDynamicFilter(child)) {
             return true;
@@ -271,9 +298,12 @@ const dynamicConditionExpressions = new Set([
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function collapsedExpression(expression: any): any {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
     if (dynamicConditionExpressions.has(expression[0])) {
 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         for (let i = 1; i < expression.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             const param = expression[i];
             if (isDynamicFilter(param)) {
                 return true;
@@ -293,6 +323,7 @@ function geometryNeeded(filter: Array<any> | boolean) {
     if (!Array.isArray(filter)) return false;
     if (filter[0] === 'within' || filter[0] === 'distance') return true;
     for (let index = 1; index < filter.length; index++) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         if (geometryNeeded(filter[index])) return true;
     }
     return false;
@@ -301,23 +332,32 @@ function geometryNeeded(filter: Array<any> | boolean) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertFilter(filter?: Array<any> | null): unknown {
     if (!filter) return true;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const op = filter[0];
     if (filter.length <= 1) return (op !== 'any');
     const converted =
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === '==' ? convertComparisonOp(filter[1], filter[2], '==') :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) :
         op === '<' ||
         op === '>' ||
         op === '<=' ||
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === '>=' ? convertComparisonOp(filter[1], filter[2], op) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
         // @ts-expect-error - TS2769 - No overload matches this call.
         op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter)) :
         // @ts-expect-error - TS2769 - No overload matches this call.
         op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter).map(convertNegation)) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === 'in' ? convertInOp(filter[1], filter.slice(2)) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === 'has' ? convertHasOp(filter[1]) :
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         op === '!has' ? convertNegation(convertHasOp(filter[1])) :
         true;
     return converted;

package/format.ts

@@ -8,12 +8,15 @@ function sortKeysBy(obj, reference) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result: Record<string, any> = {};
     for (const key in reference) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (obj[key] !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             result[key] = obj[key];
         }
     }
     for (const key in obj) {
         if (result[key] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             result[key] = obj[key];
         }
     }
@@ -44,7 +47,9 @@ function sortKeysBy(obj, reference) {
 function format(style, space = 2) {
     style = sortKeysBy(style, reference.$root);
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (style.layers) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
         style.layers = style.layers.map((layer) => sortKeysBy(layer, reference.layer));
     }
 

package/function/convert.ts

@@ -95,6 +95,7 @@ function convertZoomAndPropertyFunction<T>(
             featureFunctionStops[zoom] = [];
             zoomStops.push(zoom);
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         featureFunctionStops[zoom].push([stop[0].value, stop[1]]);
     }
 
@@ -107,6 +108,7 @@ function convertZoomAndPropertyFunction<T>(
         const expression: ExpressionSpecification = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
 
         for (const z of zoomStops) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
             appendStopPair(expression, z, output, false);
         }
@@ -116,6 +118,7 @@ function convertZoomAndPropertyFunction<T>(
         const expression: ExpressionSpecification = ['step', ['zoom']];
 
         for (const z of zoomStops) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
             const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
             appendStopPair(expression, z, output, true);
         }
@@ -219,9 +222,11 @@ function convertZoomFunction<T>(parameters: FunctionSpecification<T>, propertySp
     }
 
     for (const stop of stops) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         appendStopPair(expression, stop[0], stop[1], isStep);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     fixupDegenerateStepCurve(expression);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return