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

package/validate/validate_function.ts

@@ -15,9 +15,9 @@ import {
 import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
 import type {StylePropertySpecification} from '../style-spec';
+import type {ArraySpec} from './validate_array';
 
-function hasObjectStops(value: object): value is {stops: Array<Record<PropertyKey, unknown>>} {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+function hasObjectStops(value: Record<PropertyKey, unknown>): value is {stops: Array<Record<PropertyKey, unknown>>} {
     const stops = value['stops'];
     return Array.isArray(stops) && Array.isArray(stops[0]) && isObject(stops[0][0]);
 }
@@ -25,11 +25,13 @@ function hasObjectStops(value: object): value is {stops: Array<Record<PropertyKe
 export type FunctionValidatorOptions = {
     key: string;
     value: unknown;
-    valueSpec: unknown;
+    valueSpec?: unknown;
     style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
 };
 
+type FunctionValidator = (options: FunctionValidatorOptions) => ValidationError[];
+
 export default function validateFunction(options: FunctionValidatorOptions): ValidationError[] {
     const key = options.key;
     const value = options.value;
@@ -38,7 +40,7 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
         return [new ValidationError(key, value, `object expected, ${getType(value)} found`)];
     }
 
-    const functionValueSpec = options.valueSpec;
+    const functionValueSpec = options.valueSpec as StylePropertySpecification;
     const functionType = unbundle(value.type);
     let stopKeyType: string | undefined;
     let stopDomainValues: Partial<Record<string | number, boolean>> = {};
@@ -70,14 +72,14 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
         errors.push(new ValidationError(options.key, options.value, 'missing required property "stops"'));
     }
 
-    if (functionType === 'exponential' && (functionValueSpec as {expression?: unknown}).expression && !supportsInterpolation(functionValueSpec as StylePropertySpecification)) {
+    if (functionType === 'exponential' && functionValueSpec.expression && !supportsInterpolation(functionValueSpec)) {
         errors.push(new ValidationError(options.key, options.value, 'exponential functions not supported'));
     }
 
     if (options.styleSpec.$version >= 8) {
-        if (isPropertyFunction && !supportsPropertyExpression(functionValueSpec as StylePropertySpecification)) {
+        if (isPropertyFunction && !supportsPropertyExpression(functionValueSpec)) {
             errors.push(new ValidationError(options.key, options.value, 'property functions not supported'));
-        } else if (isZoomFunction && !supportsZoomExpression(functionValueSpec as StylePropertySpecification)) {
+        } else if (isZoomFunction && !supportsZoomExpression(functionValueSpec)) {
             errors.push(new ValidationError(options.key, options.value, 'zoom functions not supported'));
         }
     }
@@ -99,10 +101,10 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
         errors = errors.concat(validateArray({
             key: options.key,
             value,
-            valueSpec: options.valueSpec,
+            valueSpec: options.valueSpec as ArraySpec,
             style: options.style,
             styleSpec: options.styleSpec,
-            arrayElementValidator: validateFunctionStop
+            arrayElementValidator: validateFunctionStop as (...args: unknown[]) => ValidationError[]
         }));
 
         if (Array.isArray(value) && value.length === 0) {
@@ -157,7 +159,7 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
                 valueSpec: {zoom: {}},
                 style: options.style,
                 styleSpec: options.styleSpec,
-                objectElementValidators: {zoom: validateNumber, value: validateStopDomainValue}
+                objectElementValidators: {zoom: validateNumber as FunctionValidator, value: validateStopDomainValue}
             }));
         } else {
             errors = errors.concat(validateStopDomainValue({
@@ -182,7 +184,7 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
         }));
     }
 
-    function validateStopDomainValue(options: FunctionValidatorOptions, stop?: unknown[]): ValidationError[] {
+    function validateStopDomainValue(options: FunctionValidatorOptions, stop?: object): ValidationError[] {
         const type = getType(options.value);
         const value = unbundle(options.value);
 
@@ -200,14 +202,13 @@ export default function validateFunction(options: FunctionValidatorOptions): Val
 
         if (type !== 'number' && functionType !== 'categorical') {
             let message = `number expected, ${type} found`;
-            if (supportsPropertyExpression(functionValueSpec as StylePropertySpecification) && functionType === undefined) {
+            if (supportsPropertyExpression(functionValueSpec) && functionType === undefined) {
                 message += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.';
             }
             return [new ValidationError(options.key, reportValue, message)];
         }
 
         if (functionType === 'categorical' && type === 'number' && (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value)) {
-            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- value narrowed to number|string|boolean by the check above
             return [new ValidationError(options.key, reportValue, `integer expected, found ${String(value)}`)];
         }
 

package/validate/validate_layer.ts

@@ -11,6 +11,7 @@ import {isObject, isString} from '../util/get_type';
 
 import type {StyleReference} from '../reference/latest';
 import type {PropertyValidatorOptions} from './validate_property';
+import type {ArraySpec} from './validate_array';
 import type {StyleSpecification, LayerSpecification, GeoJSONSourceSpecification} from '../types';
 
 type LayerValidatorOptions = {
@@ -43,7 +44,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
     if (layer.id) {
         const layerId = unbundle(layer.id) as string;
         for (let i = 0; i < options.arrayIndex; i++) {
-            const otherLayer = style.layers[i];
+            const otherLayer = style.layers![i]!;
             if (unbundle(otherLayer.id) === layerId) {
                 errors.push(new ValidationError(key, layer.id, `duplicate layer id "${layerId}", previously used at line ${(otherLayer.id as {__line__?: number}).__line__}`));
             }
@@ -59,7 +60,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
 
         let parent: LayerSpecification | undefined;
 
-        style.layers.forEach((layer) => {
+        style.layers!.forEach((layer) => {
             if (unbundle(layer.id) === ref) parent = layer;
         });
 
@@ -94,10 +95,10 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                 errors.push(new ValidationError(key, layer.source, 'raster-dem source can only be used with layer type \'hillshade\'.'));
             } else if (sourceType === 'raster-array' && !['raster', 'raster-particle'].includes(type)) {
                 errors.push(new ValidationError(key, layer.source, `raster-array source can only be used with layer type \'raster\'.`));
-            } else if (type === 'line' && layer.paint && layer.paint['line-gradient'] &&
+            } else if (type === 'line' && layer.paint && (layer.paint as Record<string, unknown>)['line-gradient'] &&
                     (sourceType === 'geojson' && !(source as GeoJSONSourceSpecification).lineMetrics)) {
                 errors.push(new ValidationError(key, layer, `layer "${layer.id as string}" specifies a line-gradient, which requires the GeoJSON source to have \`lineMetrics\` enabled.`));
-            } else if (type === 'line' && layer.paint && layer.paint['line-trim-offset'] &&
+            } else if (type === 'line' && layer.paint && (layer.paint as Record<string, unknown>)['line-trim-offset'] &&
                     (sourceType === 'geojson' && !(source as GeoJSONSourceSpecification).lineMetrics)) {
                 errors.push(new ValidationError(key, layer, `layer "${layer.id as string}" specifies a line-trim-offset, which requires the GeoJSON source to have \`lineMetrics\` enabled.`));
             } else if (type === 'raster-particle' && sourceType !== 'raster-array') {
@@ -143,8 +144,8 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     style: options.style,
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
-                        '*'(options: PropertyValidatorOptions) {
-                            return validateLayoutProperty({layerType: type, ...options});
+                        '*'(options) {
+                            return validateLayoutProperty({layerType: type, ...options} as PropertyValidatorOptions);
                         }
                     }
                 });
@@ -158,8 +159,8 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     style: options.style,
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
-                        '*'(options: PropertyValidatorOptions) {
-                            return validatePaintProperty({layerType: type, layer, ...options});
+                        '*'(options) {
+                            return validatePaintProperty({layerType: type, layer, ...options} as PropertyValidatorOptions);
                         }
                     }
                 });
@@ -169,7 +170,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     key: options.key,
                     value: options.value,
 
-                    valueSpec: options.valueSpec,
+                    valueSpec: options.valueSpec as ArraySpec,
                     style: options.style,
                     styleSpec: options.styleSpec,
                     arrayElementValidator: (options) => validateAppearance(({layerType: type, layer, ...(options as object)}) as AppearanceValidatorOptions)

package/validate/validate_light.ts

@@ -34,7 +34,7 @@ export default function validateLight(options: LightValidatorOptions): Validatio
         const useThemeMatch = key.match(USE_THEME_KEY_RE);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        if (useThemeMatch && lightSpec[useThemeMatch[1]]) {
+        if (useThemeMatch && lightSpec[useThemeMatch[1]!]) {
             errors = errors.concat(validate({
                 key,
                 value: light[key],
@@ -43,7 +43,7 @@ export default function validateLight(options: LightValidatorOptions): Validatio
                 styleSpec
             }));
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        } else if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
+        } else if (transitionMatch && lightSpec[transitionMatch[1]!] && lightSpec[transitionMatch[1]!]!.transition) {
             errors = errors.concat(validate({
                 key,
                 value: light[key],

package/validate/validate_lights.ts

@@ -49,7 +49,7 @@ export default function validateLights(options: LightsValidatorOptions): Validat
     if (lights) {
         for (let i = 0; i < options.arrayIndex; i++) {
             const lightType = unbundle(light.type);
-            const otherLight = lights[i];
+            const otherLight = lights[i]!;
             if (unbundle(otherLight.type) === lightType) {
                 errors.push(new ValidationError(key, light.id, `duplicate light type "${light.type}", previously defined at line ${(otherLight.id as {__line__?: number}).__line__}`));
             }
@@ -77,7 +77,7 @@ export default function validateLights(options: LightsValidatorOptions): Validat
                 const useThemeMatch = propertyKey.match(USE_THEME_KEY_RE);
 
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                if (useThemeMatch && lightPropertySpec[useThemeMatch[1]]) {
+                if (useThemeMatch && lightPropertySpec[useThemeMatch[1]!]) {
                     errors = errors.concat(validate({
                         key,
                         value: properties[propertyKey],
@@ -86,7 +86,7 @@ export default function validateLights(options: LightsValidatorOptions): Validat
                         styleSpec
                     }));
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                } else if (transitionMatch && lightPropertySpec[transitionMatch[1]] && lightPropertySpec[transitionMatch[1]].transition) {
+                } else if (transitionMatch && lightPropertySpec[transitionMatch[1]!] && lightPropertySpec[transitionMatch[1]!].transition) {
                     errors = errors.concat(validate({
                         key,
                         value: light[key],

package/validate/validate_number.ts

@@ -5,10 +5,15 @@ import type {StyleReference} from '../reference/latest';
 import type {StyleSpecification} from '../types';
 import type {NumberPropertySpecification} from '../style-spec';
 
+type NumberValueSpecification = Omit<NumberPropertySpecification, 'minimum' | 'maximum'> & {
+    minimum?: number | number[];
+    maximum?: number | number[];
+};
+
 type NumberValidatorOptions = {
     key: string;
     value: unknown;
-    valueSpec: NumberPropertySpecification;
+    valueSpec: NumberValueSpecification;
     style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
     arrayIndex: number;
@@ -29,11 +34,10 @@ export default function validateNumber(options: NumberValidatorOptions): Validat
     }
 
     if ('minimum' in valueSpec) {
-        let specMin = valueSpec.minimum;
+        let specMin = valueSpec.minimum as number;
         if (Array.isArray(valueSpec.minimum)) {
             const i = options.arrayIndex;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            specMin = valueSpec.minimum[i];
+            specMin = valueSpec.minimum[i]!;
         }
         if (value < specMin) {
             return [new ValidationError(key, value, `${value} is less than the minimum value ${specMin}`)];
@@ -41,11 +45,10 @@ export default function validateNumber(options: NumberValidatorOptions): Validat
     }
 
     if ('maximum' in valueSpec) {
-        let specMax = valueSpec.maximum;
+        let specMax = valueSpec.maximum as number;
         if (Array.isArray(valueSpec.maximum)) {
             const i = options.arrayIndex;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            specMax = valueSpec.maximum[i];
+            specMax = valueSpec.maximum[i]!;
         }
         if (value > specMax) {
             return [new ValidationError(key, value, `${value} is greater than the maximum value ${specMax}`)];

package/validate/validate_object.ts

@@ -15,16 +15,18 @@ type ObjectElementValidatorOptions = {
     objectKey?: string;
 };
 
+export type ObjectElementValidator = (options: ObjectElementValidatorOptions, object?: object) => ValidationError[];
+
 type ObjectValidatorOptions = {
     key: string;
     value: unknown;
-    valueSpec?: object;
+    valueSpec?: Record<PropertyKey, unknown>;
     style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
     object?: object;
     objectKey?: string;
     layer?: LayerSpecification;
-    objectElementValidators?: Record<string, (options: ObjectElementValidatorOptions) => ValidationError[]>;
+    objectElementValidators?: Record<string, ObjectElementValidator>;
 };
 
 export default function validateObject(options: ObjectValidatorOptions): ValidationError[] {
@@ -47,25 +49,24 @@ export default function validateObject(options: ObjectValidatorOptions): Validat
         // inherited properties as if they were user-supplied.
         if (!Object.hasOwn(object, objectKey)) continue;
 
-        const elementSpecKey = objectKey.split('.')[0]; // treat 'paint.*' as 'paint'
+        const elementSpecKey = objectKey.split('.')[0]!; // treat 'paint.*' as 'paint'
         // Object.hasOwn: a bare lookup like `elementSpecs[objectKey]` would
         // find inherited keys from Object.prototype (e.g. "__proto__",
         // "constructor", "toString") when the user-supplied key matches one,
         // returning a non-spec value that then fails as a validator.
         const hasSpec = Object.hasOwn(elementSpecs, elementSpecKey);
         const hasWildcardSpec = Object.hasOwn(elementSpecs, '*');
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const elementSpec = hasSpec ? elementSpecs[elementSpecKey] : (hasWildcardSpec ? elementSpecs['*'] : undefined);
 
-        let validateElement: ((options: ObjectElementValidatorOptions, object?: unknown) => ValidationError[]) | undefined;
+        let validateElement: ObjectElementValidator | undefined;
         if (Object.hasOwn(elementValidators, elementSpecKey)) {
-            validateElement = elementValidators[elementSpecKey];
+            validateElement = elementValidators[elementSpecKey]!;
         } else if (hasSpec) {
-            validateElement = validateSpec;
+            validateElement = validateSpec as ObjectElementValidator;
         } else if (Object.hasOwn(elementValidators, '*')) {
-            validateElement = elementValidators['*'];
+            validateElement = elementValidators['*']!;
         } else if (hasWildcardSpec) {
-            validateElement = validateSpec;
+            validateElement = validateSpec as ObjectElementValidator;
         }
 
         if (!validateElement) {
@@ -91,7 +92,7 @@ export default function validateObject(options: ObjectValidatorOptions): Validat
             continue;
         }
 
-        const elementSpec = elementSpecs[elementSpecKey] as {required?: boolean; default?: unknown};
+        const elementSpec = elementSpecs[elementSpecKey]! as {required?: boolean; default?: unknown};
         if (elementSpec.required && elementSpec['default'] === undefined && (!Object.hasOwn(object, elementSpecKey) || object[elementSpecKey] === undefined)) {
             errors.push(new ValidationError(key, object, `missing required property "${elementSpecKey}"`));
         }

package/validate/validate_option.ts

@@ -5,6 +5,7 @@ import {isObject} from '../util/get_type';
 
 import type ValidationError from '../error/validation_error';
 import type {ValidatorOptions} from './validate';
+import type {ObjectElementValidator} from './validate_object';
 
 // Validator for a single config option (one entry in `schema`). Wraps the
 // generic object validator to inherit the option's declared `type` when
@@ -19,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)),
-        } : undefined,
+        objectElementValidators: {
+            default: validateDefault,
+        } as Record<string, ObjectElementValidator>,
     });
 }

package/validate/validate_property.ts

@@ -31,13 +31,13 @@ export default function validateProperty(options: PropertyValidatorOptions, prop
     const layer = options.layer;
     const styleSpec = options.styleSpec;
     const value = options.value;
-    const propertyKey = options.objectKey;
+    const propertyKey = options.objectKey!;
     const layerSpec = styleSpec[`${propertyType}_${options.layerType}`] as Record<string, StylePropertySpecification> | undefined;
 
     if (!layerSpec) return [];
 
     const useThemeMatch = propertyKey.match(USE_THEME_KEY_RE);
-    if (useThemeMatch && layerSpec[useThemeMatch[1]]) {
+    if (useThemeMatch && layerSpec[useThemeMatch[1]!]) {
         if (isExpression(deepUnbundle(value))) {
             const errors: ValidationError[] = [];
             return errors.concat(validate({
@@ -69,7 +69,7 @@ export default function validateProperty(options: PropertyValidatorOptions, prop
     }
 
     const transitionMatch = propertyKey.match(TRANSITION_KEY_RE);
-    if (propertyType === 'paint' && transitionMatch && layerSpec[transitionMatch[1]] && layerSpec[transitionMatch[1]].transition) {
+    if (propertyType === 'paint' && transitionMatch && layerSpec[transitionMatch[1]!] && layerSpec[transitionMatch[1]!]!.transition) {
         return validate({
             key,
             value,
@@ -85,7 +85,7 @@ export default function validateProperty(options: PropertyValidatorOptions, prop
         return [new ValidationWarning(key, value, `unknown property "${propertyKey}"`)];
     }
 
-    let tokenMatch: RegExpExecArray | undefined;
+    let tokenMatch: RegExpExecArray | null | undefined;
     if (isString(value) && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = TOKEN_PATTERN_RE.exec(value))) {
         const example = `\`{ "type": "identity", "property": ${tokenMatch ? JSON.stringify(tokenMatch[1]) : '"_"'} }\``;
         return [new ValidationError(

package/validate/validate_rain.ts

@@ -32,7 +32,7 @@ export default function validateRain(options: RainValidatorOptions): ValidationE
     for (const key in rain) {
         const transitionMatch = key.match(TRANSITION_KEY_RE);
 
-        if (transitionMatch && rainSpec[transitionMatch[1]] && rainSpec[transitionMatch[1]].transition) {
+        if (transitionMatch && rainSpec[transitionMatch[1]!] && rainSpec[transitionMatch[1]!]!.transition) {
             errors = errors.concat(validate({
                 key,
                 value: rain[key],

package/validate/validate_snow.ts

@@ -32,7 +32,7 @@ export default function validateSnow(options: SnowValidatorOptions): ValidationE
     for (const key in snow) {
         const transitionMatch = key.match(TRANSITION_KEY_RE);
 
-        if (transitionMatch && snowSpec[transitionMatch[1]] && snowSpec[transitionMatch[1]].transition) {
+        if (transitionMatch && snowSpec[transitionMatch[1]!] && snowSpec[transitionMatch[1]!]!.transition) {
             errors = errors.concat(validate({
                 key,
                 value: snow[key],

package/validate/validate_style.ts

@@ -4,6 +4,7 @@ import validateGlyphsURL from './validate_glyphs_url';
 
 import type ValidationError from '../error/validation_error';
 import type {StyleReference} from '../reference/latest';
+import type {StyleSpecification} from '../types';
 
 type StyleValidatorOptions = {
     key?: string;
@@ -20,7 +21,7 @@ export default function validateStyle(style: unknown, styleSpec: StyleReference
             '*': {type: '*'},
         },
         styleSpec,
-        style,
+        style: style as Partial<StyleSpecification>,
         objectElementValidators: {
             glyphs: validateGlyphsURL
         }

package/validate/validate_terrain.ts

@@ -36,7 +36,7 @@ export default function validateTerrain(options: TerrainValidatorOptions): Valid
         const useThemeMatch = key.match(USE_THEME_KEY_RE);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        if (useThemeMatch && terrainSpec[useThemeMatch[1]]) {
+        if (useThemeMatch && terrainSpec[useThemeMatch[1]!]) {
             errors = errors.concat(validate({
                 key,
                 value: terrain[key],
@@ -45,7 +45,7 @@ export default function validateTerrain(options: TerrainValidatorOptions): Valid
                 styleSpec
             }));
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        } else if (transitionMatch && terrainSpec[transitionMatch[1]] && terrainSpec[transitionMatch[1]].transition) {
+        } else if (transitionMatch && terrainSpec[transitionMatch[1]!] && terrainSpec[transitionMatch[1]!].transition) {
             errors = errors.concat(validate({
                 key,
                 value: terrain[key],

package/validate_mapbox_api_supported.ts

@@ -33,13 +33,13 @@ function isValid(value: string | null | undefined, regex: RegExp): boolean {
 
 function getSourceCount(source: SourceSpecification): number {
     if ('url' in source) {
-        return source.url.split(',').length;
+        return source.url!.split(',').length;
     } else {
         return 0;
     }
 }
 
-function getAllowedKeyErrors(obj: object, keys: string[], path?: string | null): Array<ValidationError> {
+function getAllowedKeyErrors(obj: Record<string, unknown>, keys: string[], path?: string | null): Array<ValidationError> {
     const allowed = new Set(keys);
     const errors: ValidationError[] = [];
     Object.keys(obj).forEach(k => {
@@ -87,21 +87,20 @@ function getSourcesErrors(sources: SourcesSpecification): {
     errors: Array<ValidationError>;
     sourcesCount: number;
 } {
-    const errors = [];
+    const errors: ValidationError[] = [];
     let sourcesCount = 0;
 
     Object.keys(sources).forEach((s: string, i: number) => {
-        const sourceErrors = getSourceErrors(sources[s], i);
+        const sourceErrors = getSourceErrors(sources[s]!, i);
 
         // If source has errors, skip counting
         if (!sourceErrors.length) {
-            sourcesCount = sourcesCount + getSourceCount(sources[s]);
+            sourcesCount = sourcesCount + getSourceCount(sources[s]!);
         }
 
         errors.push(...sourceErrors);
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     return {errors, sourcesCount};
 }
 

package/validate_style.min.ts

@@ -23,7 +23,8 @@ export type ValidationError = {
 };
 
 export type ValidationErrors = ReadonlyArray<ValidationError>;
-export type Validator<T extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> = (...args: Parameters<T>) => ValidationErrors;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Validator<T extends (...args: any[]) => unknown = (...args: unknown[]) => unknown> = (...args: Parameters<T>) => ValidationErrors;
 
 /**
  * Validate a Mapbox GL style against the style specification. This entrypoint,

package/visit.ts

@@ -8,17 +8,18 @@ import type {
     PropertyValueSpecification
 } from './types';
 
-function getPropertyReference(propertyName: string): StylePropertySpecification {
+type ReferenceSection = Record<string, StylePropertySpecification>;
+type ReferenceWithSections = typeof Reference & Record<string, ReferenceSection>;
+
+function getPropertyReference(propertyName: string): StylePropertySpecification | null {
     for (let i = 0; i < Reference.layout.length; i++) {
-        for (const key in Reference[Reference.layout[i]]) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (key === propertyName) return Reference[Reference.layout[i]][key] as StylePropertySpecification;
+        for (const key in (Reference as ReferenceWithSections)[Reference.layout[i]!]) {
+            if (key === propertyName) return (Reference as ReferenceWithSections)[Reference.layout[i]!]![key]!;
         }
     }
     for (let i = 0; i < Reference.paint.length; i++) {
-        for (const key in Reference[Reference.paint[i]]) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (key === propertyName) return Reference[Reference.paint[i]][key] as StylePropertySpecification;
+        for (const key in (Reference as ReferenceWithSections)[Reference.paint[i]!]) {
+            if (key === propertyName) return (Reference as ReferenceWithSections)[Reference.paint[i]!]![key]!;
         }
     }
 
@@ -27,7 +28,7 @@ function getPropertyReference(propertyName: string): StylePropertySpecification
 
 export function eachSource(style: StyleSpecification, callback: (_: SourceSpecification) => void) {
     for (const k in style.sources) {
-        callback(style.sources[k]);
+        callback(style.sources[k]!);
     }
 }
 
@@ -59,14 +60,14 @@ export function eachProperty(
 ) {
     function inner(layer: LayerSpecification, propertyType: 'paint' | 'layout') {
         if (layer.type === 'slot' || layer.type === 'clip') return;
-        const properties = layer[propertyType];
+        const properties: Record<string, PropertyValueSpecification<unknown>> | undefined = layer[propertyType];
         if (!properties) return;
         Object.keys(properties).forEach((key) => {
             callback({
                 path: [layer.id, propertyType, key],
                 key,
                 value: properties[key],
-                reference: getPropertyReference(key),
+                reference: getPropertyReference(key)!,
                 set(x) {
                     properties[key] = x;
                 }