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

package/expression/compound_expression.ts

@@ -38,8 +38,8 @@ class CompoundExpression implements Expression {
 
     evaluate(ctx: EvaluationContext): Value {
         if (!this._evaluate) { // restore evaluate function after transfer between threads
-            const definition = CompoundExpression.definitions[this.name];
-            this._evaluate = Array.isArray(definition) ? definition[2] : definition.overloads[this._overloadIndex][1];
+            const definition = CompoundExpression.definitions[this.name]!;
+            this._evaluate = Array.isArray(definition) ? definition[2] : definition.overloads[this._overloadIndex]![1];
         }
         return this._evaluate(ctx, this.args);
     }
@@ -73,7 +73,7 @@ class CompoundExpression implements Expression {
 
         const overloadParams = [];
 
-        let signatureContext: ParsingContext = null;
+        let signatureContext: ParsingContext | null = null;
 
         let overloadIndex = -1;
 
@@ -125,8 +125,8 @@ class CompoundExpression implements Expression {
             }
 
             for (let i = 0; i < parsedArgs.length; i++) {
-                const expected = Array.isArray(params) ? params[i] : params.type;
-                const arg = parsedArgs[i];
+                const expected = Array.isArray(params) ? params[i]! : params.type;
+                const arg = parsedArgs[i]!;
                 signatureContext.checkSubtype(expected, arg.type, i + 1);
             }
 
@@ -138,7 +138,7 @@ class CompoundExpression implements Expression {
         assert(!signatureContext || signatureContext.errors.length > 0);
 
         if (overloadParams.length === 1) {
-            context.errors.push(...signatureContext.errors);
+            context.errors.push(...signatureContext!.errors);
         } else {
             const expected = overloadParams.length ? overloadParams : availableOverloads.map(([params]) => params);
             const signatures = expected.map(stringifySignature).join(' | ');

package/expression/definitions/assertion.ts

@@ -17,7 +17,7 @@ import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 import type {Type} from '../types';
 
-const types = {
+const types: Record<string, Type> = {
     string: StringType,
     number: NumberType,
     boolean: BooleanType,
@@ -33,7 +33,7 @@ class Assertion implements Expression {
         this.args = args;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | void {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | void {
         if (args.length < 2)
             return context.error(`Expected at least one argument.`);
 
@@ -47,8 +47,7 @@ class Assertion implements Expression {
                 const type = args[1];
                 if (typeof type !== 'string' || !(type in types) || type === 'object')
                     return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                itemType = types[type];
+                itemType = types[type]!;
                 i++;
             } else {
                 itemType = ValueType;
@@ -63,25 +62,23 @@ class Assertion implements Expression {
                 ) {
                     return context.error('The length argument to "array" must be a positive integer literal', 2);
                 }
-                N = (args[2] as number);
+                N = args[2];
                 i++;
             }
 
             type = array(itemType, N);
         } else {
             assert(types[name], name);
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            type = types[name];
+            type = types[name]!;
         }
 
-        const parsed = [];
+        const parsed: Expression[] = [];
         for (; i < args.length; i++) {
             const input = context.parse(args[i], i, ValueType);
             if (!input) return null;
             parsed.push(input);
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Assertion(type, parsed);
     }
 
@@ -89,14 +86,14 @@ class Assertion implements Expression {
     evaluate(ctx: EvaluationContext): any {
         for (let i = 0; i < this.args.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const value = this.args[i].evaluate(ctx);
+            const value = this.args[i]!.evaluate(ctx);
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const error = checkSubtype(this.type, typeOf(value));
             if (!error) {
                 return value;
             } else if (i === this.args.length - 1) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                throw new RuntimeError(`The expression ${JSON.stringify(this.args[i].serialize())} evaluated to ${toString(typeOf(value))} but was expected to be of type ${toString(this.type)}.`);
+                throw new RuntimeError(`The expression ${JSON.stringify(this.args[i]!.serialize())} evaluated to ${toString(typeOf(value))} but was expected to be of type ${toString(this.type)}.`);
             }
         }
 
@@ -123,7 +120,7 @@ class Assertion implements Expression {
                 serialized.push(itemType.kind);
                 const N = type.N;
                 if (typeof N === 'number' || this.args.length > 1) {
-                    serialized.push(N);
+                    serialized.push(N!);
                 }
             }
         }

package/expression/definitions/at.ts

@@ -47,7 +47,7 @@ class At implements Expression {
             throw new RuntimeError(`Array index must be an integer. Use at-interpolated for fractional indices`);
         }
 
-        return array[index];
+        return array[index]!;
     }
 
     eachChild(fn: (_: Expression) => void) {

package/expression/definitions/at_interpolated.ts

@@ -45,7 +45,7 @@ class AtInterpolated implements Expression {
         }
 
         if (index === Math.floor(index)) {
-            return array[index];
+            return array[index]!;
         }
 
         // Interpolation logic for non-integer indices

package/expression/definitions/case.ts

@@ -35,7 +35,7 @@ class Case implements Expression {
             outputType = context.expectedType;
         }
 
-        const branches = [];
+        const branches: Branches = [];
         for (let i = 1; i < args.length - 1; i += 2) {
             const test = context.parse(args[i], i, BooleanType);
             if (!test) return null;
@@ -52,7 +52,6 @@ class Case implements Expression {
         if (!otherwise) return null;
 
         assert(outputType);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Case(outputType, branches, otherwise);
     }
 

package/expression/definitions/coalesce.ts

@@ -21,7 +21,7 @@ class Coalesce implements Expression {
             context.error("Expectected at least one argument.");
             return null;
         }
-        let outputType: Type = null;
+        let outputType: Type | null = null;
         const expectedType = context.expectedType;
         if (expectedType && expectedType.kind !== 'value') {
             outputType = expectedType;

package/expression/definitions/coercion.ts

@@ -40,8 +40,8 @@ class Coercion implements Expression {
         if (args.length < 2)
             return context.error(`Expected at least one argument.`);
 
-        const name = args[0] as string;
-        const parsed = [];
+        const name = args[0] as 'to-array' | keyof typeof types;
+        const parsed: Expression[] = [];
         let type: Type | ArrayType = NullType;
         if (name === 'to-array') {
             if (!Array.isArray(args[1])) {
@@ -73,7 +73,7 @@ class Coercion implements Expression {
                     if (memberType !== type.itemType.kind) {
                         return context.error(`Expected ${type.itemType.kind} but found ${memberType}.`);
                     }
-                    parsedMember = context.registry['literal'].parse(['literal', member === undefined ? null : member], context);
+                    parsedMember = context.registry['literal']!.parse(['literal', member === undefined ? null : member], context);
                 }
                 if (!parsedMember) return null;
                 parsed.push(parsedMember);
@@ -84,7 +84,6 @@ class Coercion implements Expression {
             if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
                 return context.error(`Expected one argument.`);
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             type = types[name];
 
             for (let i = 1; i < args.length; i++) {
@@ -94,18 +93,17 @@ class Coercion implements Expression {
             }
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return new Coercion(type, parsed);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     evaluate(ctx: EvaluationContext): any {
         if (this.type.kind === 'boolean') {
-            return Boolean(this.args[0].evaluate(ctx));
+            return Boolean(this.args[0]!.evaluate(ctx));
         } else if (this.type.kind === 'color') {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let input: any;
-            let error: string | null;
+            let error!: string | null;
             for (const arg of this.args) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 input = arg.evaluate(ctx);
@@ -143,16 +141,16 @@ class Coercion implements Expression {
             // There is no explicit 'to-formatted' but this coercion can be implicitly
             // created by properties that expect the 'formatted' type.
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return Formatted.fromString(valueToString(this.args[0].evaluate(ctx)));
+            return Formatted.fromString(valueToString(this.args[0]!.evaluate(ctx)));
         } else if (this.type.kind === 'resolvedImage') {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return ResolvedImage.build(valueToString(this.args[0].evaluate(ctx)));
+            return ResolvedImage.build(valueToString(this.args[0]!.evaluate(ctx)));
         } else if (this.type.kind === 'array') {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return this.args.map(arg => { return arg.evaluate(ctx); });
         } else {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return valueToString(this.args[0].evaluate(ctx));
+            return valueToString(this.args[0]!.evaluate(ctx));
         }
     }
 
@@ -166,11 +164,11 @@ class Coercion implements Expression {
 
     serialize(): SerializedExpression {
         if (this.type.kind === 'formatted') {
-            return new FormatExpression([{content: this.args[0], scale: null, font: null, textColor: null}]).serialize();
+            return new FormatExpression([{content: this.args[0]!, scale: null, font: null, textColor: null}]).serialize();
         }
 
         if (this.type.kind === 'resolvedImage') {
-            return new ImageExpression(this.args[0]).serialize();
+            return new ImageExpression(this.args[0]!).serialize();
         }
 
         const serialized: Array<unknown> = this.type.kind === 'array' ? [] : [`to-${this.type.kind}`];

package/expression/definitions/collator.ts

@@ -25,25 +25,25 @@ export default class CollatorExpression implements Expression {
             return null;
         }
 
-        const options = args[1];
+        const options = args[1] as Record<string, unknown> | unknown[] | null;
         if (typeof options !== "object" || Array.isArray(options)) {
             context.error(`Collator options argument must be an object.`);
             return null;
         }
 
-        const caseSensitive = options['case-sensitive'] === undefined ?
+        const caseSensitive = options!['case-sensitive'] === undefined ?
             context.parse(false, 1, BooleanType) :
-            context.parseObjectValue(options['case-sensitive'], 1, 'case-sensitive', BooleanType);
+            context.parseObjectValue(options!['case-sensitive'], 1, 'case-sensitive', BooleanType);
         if (!caseSensitive) return null;
 
-        const diacriticSensitive = options['diacritic-sensitive'] === undefined ?
+        const diacriticSensitive = options!['diacritic-sensitive'] === undefined ?
             context.parse(false, 1, BooleanType) :
-            context.parseObjectValue(options['diacritic-sensitive'], 1, 'diacritic-sensitive', BooleanType);
+            context.parseObjectValue(options!['diacritic-sensitive'], 1, 'diacritic-sensitive', BooleanType);
         if (!diacriticSensitive) return null;
 
-        let locale: Expression = null;
-        if (options['locale']) {
-            locale = context.parseObjectValue(options['locale'], 1, 'locale', StringType) as Expression;
+        let locale: Expression | null = null;
+        if (options!['locale']) {
+            locale = context.parseObjectValue(options!['locale'], 1, 'locale', StringType) as Expression | null;
             if (!locale) return null;
         }
 

package/expression/definitions/comparison.ts

@@ -143,7 +143,6 @@ function makeComparison(
                 if (!collator) return null;
             }
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             return new Comparison(lhs, rhs, collator);
         }