@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/{empty.js → empty.ts}

@@ -1,5 +1,4 @@
-// @flow
-import type {StyleSpecification} from './types.js';
+import type {StyleSpecification} from './types';
 
 export default function emptyStyle(): StyleSpecification {
     return {

package/error/{parsing_error.js → parsing_error.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 // Note: Do not inherit from Error. It breaks when transpiling to ES5.
 
 export default class ParsingError {

package/error/{validation_error.js → validation_error.ts}

@@ -1,13 +1,13 @@
-// @flow
-
 // Note: Do not inherit from Error. It breaks when transpiling to ES5.
 
 export default class ValidationError {
     message: string;
-    identifier: ?string;
-    line: ?number;
+    identifier: string | null | undefined;
+    line: number | null | undefined;
 
-    constructor(key: ?string, value: ?{ __line__: number }, message: string, identifier: ?string) {
+    constructor(key: string | null | undefined, value: {
+        __line__: number;
+    } | null | undefined, message: string, identifier?: string | null) {
         this.message = (key ? `${key}: ` : '') + message;
         if (identifier) this.identifier = identifier;
 

package/expression/{compound_expression.js → compound_expression.ts}

@@ -1,20 +1,22 @@
-// @flow
+import {toString} from './types';
 
-import {toString} from './types.js';
-
-import ParsingContext from './parsing_context.js';
-import EvaluationContext from './evaluation_context.js';
+import ParsingContext from './parsing_context';
+import EvaluationContext from './evaluation_context';
 import assert from 'assert';
 
-import type {Expression, ExpressionRegistry} from './expression.js';
-import type {Type} from './types.js';
-import type {Value} from './values.js';
+import type {Expression, ExpressionRegistry} from './expression';
+import type {Type} from './types';
+import type {Value} from './values';
 
-export type Varargs = {| type: Type |};
+export type Varargs = {
+    type: Type;
+};
 type Signature = Array<Type> | Varargs;
-type Evaluate = (EvaluationContext, Array<Expression>) => Value;
-type Definition = [Type, Signature, Evaluate] |
-    {|type: Type, overloads: Array<[Signature, Evaluate]>|};
+type Evaluate = (arg1: EvaluationContext, arg2: Array<Expression>) => Value;
+type Definition = [Type, Signature, Evaluate] | {
+    type: Type;
+    overloads: Array<[Signature, Evaluate]>;
+};
 
 class CompoundExpression implements Expression {
     name: string;
@@ -23,7 +25,9 @@ class CompoundExpression implements Expression {
     args: Array<Expression>;
     _overloadIndex: number;
 
-    static definitions: {[_: string]: Definition };
+    static definitions: {
+        [_: string]: Definition;
+    };
 
     constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>, overloadIndex: number) {
         this.name = name;
@@ -49,14 +53,16 @@ class CompoundExpression implements Expression {
         return false;
     }
 
-    serialize(): Array<mixed> {
+    serialize(): Array<unknown> {
+        // @ts-expect-error - TS2769 - No overload matches this call.
         return [this.name].concat(this.args.map(arg => arg.serialize()));
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        const op: string = (args[0]: any);
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
+        const op: string = (args[0] as any);
         const definition = CompoundExpression.definitions[op];
         if (!definition) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
         }
 
@@ -70,7 +76,7 @@ class CompoundExpression implements Expression {
 
         const overloadParams = [];
 
-        let signatureContext: ParsingContext = (null: any);
+        let signatureContext: ParsingContext = (null as any);
 
         let overloadIndex = -1;
 
@@ -92,6 +98,7 @@ class CompoundExpression implements Expression {
                 const arg = args[i];
                 const expectedType = Array.isArray(params) ?
                     params[i - 1] :
+                // @ts-expect-error - TS2339 - Property 'type' does not exist on type 'Varargs | Evaluate'.
                     params.type;
 
                 const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
@@ -115,12 +122,14 @@ class CompoundExpression implements Expression {
             }
 
             for (let i = 0; i < parsedArgs.length; i++) {
+                // @ts-expect-error - TS2339 - Property 'type' does not exist on type 'Varargs | Evaluate'.
                 const expected = Array.isArray(params) ? params[i] : params.type;
                 const arg = parsedArgs[i];
                 signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
             }
 
             if (signatureContext.errors.length === 0) {
+                // @ts-expect-error - TS2345 - Argument of type 'Signature | Evaluate' is not assignable to parameter of type 'Evaluate'.
                 return new CompoundExpression(op, type, evaluate, parsedArgs, overloadIndex);
             }
         }
@@ -149,12 +158,13 @@ class CompoundExpression implements Expression {
 
     static register(
         registry: ExpressionRegistry,
-        definitions: {[_: string]: Definition }
+        definitions: {
+            [_: string]: Definition;
+        }
     ) {
         assert(!CompoundExpression.definitions);
         CompoundExpression.definitions = definitions;
         for (const name in definitions) {
-            // $FlowFixMe[method-unbinding]
             registry[name] = CompoundExpression;
         }
     }

package/expression/definitions/{assertion.js → assertion.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import assert from 'assert';
 
 import {
@@ -11,14 +9,14 @@ import {
     checkSubtype,
     toString,
     array
-} from '../types.js';
-import RuntimeError from '../runtime_error.js';
-import {typeOf} from '../values.js';
+} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
 
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 const types = {
     string: StringType,
@@ -36,19 +34,21 @@ class Assertion implements Expression {
         this.args = args;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
         if (args.length < 2)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected at least one argument.`);
 
         let i = 1;
         let type;
 
-        const name: string = (args[0]: any);
+        const name: string = (args[0] as any);
         if (name === 'array') {
             let itemType;
             if (args.length > 2) {
                 const type = args[1];
                 if (typeof type !== 'string' || !(type in types) || type === 'object')
+                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                     return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
                 itemType = types[type];
                 i++;
@@ -56,16 +56,17 @@ class Assertion implements Expression {
                 itemType = ValueType;
             }
 
-            let N: ?number;
+            let N: number | null | undefined;
             if (args.length > 3) {
                 if (args[2] !== null &&
                     (typeof args[2] !== 'number' ||
                         args[2] < 0 ||
                         args[2] !== Math.floor(args[2]))
                 ) {
+                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                     return context.error('The length argument to "array" must be a positive integer literal', 2);
                 }
-                N = ((args[2]: any): number);
+                N = (args[2] as number);
                 i++;
             }
 
@@ -119,10 +120,12 @@ class Assertion implements Expression {
                 serialized.push(itemType.kind);
                 const N = type.N;
                 if (typeof N === 'number' || this.args.length > 1) {
+                    // @ts-expect-error - TS2345 - Argument of type 'number' is not assignable to parameter of type '"string" | "number" | "boolean" | "object" | "error" | "color" | "value" | "null" | "collator" | "formatted" | "resolvedImage" | "array"'.
                     serialized.push(N);
                 }
             }
         }
+        // @ts-expect-error - TS2769 - No overload matches this call.
         return serialized.concat(this.args.map(arg => arg.serialize()));
     }
 }

package/expression/definitions/{at.js → at.ts}

@@ -1,14 +1,12 @@
-// @flow
+import {array, ValueType, NumberType} from '../types';
 
-import {array, ValueType, NumberType} from '../types.js';
+import RuntimeError from '../runtime_error';
 
-import RuntimeError from '../runtime_error.js';
-
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type, ArrayType} from '../types.js';
-import type {Value} from '../values.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type, ArrayType} from '../types';
+import type {Value} from '../values';
 
 class At implements Expression {
     type: Type;
@@ -21,8 +19,9 @@ class At implements Expression {
         this.input = input;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?At {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): At | null | undefined {
         if (args.length !== 3)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'At'.
             return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
 
         const index = context.parse(args[1], 1, NumberType);
@@ -30,13 +29,13 @@ class At implements Expression {
 
         if (!index || !input) return null;
 
-        const t: ArrayType = (input.type: any);
+        const t: ArrayType = (input.type as any);
         return new At(t.itemType, index, input);
     }
 
     evaluate(ctx: EvaluationContext): Value {
-        const index = ((this.index.evaluate(ctx): any): number);
-        const array = ((this.input.evaluate(ctx): any): Array<Value>);
+        const index = (this.index.evaluate(ctx) as number);
+        const array = (this.input.evaluate(ctx) as Array<Value>);
 
         if (index < 0) {
             throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);

package/expression/definitions/{case.js → case.ts}

@@ -1,13 +1,11 @@
-// @flow
-
 import assert from 'assert';
 
-import {BooleanType} from '../types.js';
+import {BooleanType} from '../types';
 
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 type Branches = Array<[Expression, Expression]>;
 
@@ -23,13 +21,15 @@ class Case implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Case {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Case | null | undefined {
         if (args.length < 4)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Case'.
             return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
         if (args.length % 2 !== 0)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Case'.
             return context.error(`Expected an odd number of arguments.`);
 
-        let outputType: ?Type;
+        let outputType: Type | null | undefined;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
@@ -51,7 +51,7 @@ class Case implements Expression {
         if (!otherwise) return null;
 
         assert(outputType);
-        return new Case((outputType: any), branches, otherwise);
+        return new Case((outputType as any), branches, otherwise);
     }
 
     evaluate(ctx: EvaluationContext): any {
@@ -72,11 +72,12 @@ class Case implements Expression {
     }
 
     outputDefined(): boolean {
-        return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
+        return this.branches.every(([_, out]: [any, any]) => out.outputDefined()) && this.otherwise.outputDefined();
     }
 
     serialize(): SerializedExpression {
         const serialized = ["case"];
+        // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;
     }

package/expression/definitions/{coalesce.js → coalesce.ts}

@@ -1,14 +1,12 @@
-// @flow
-
 import assert from 'assert';
 
-import {checkSubtype, ValueType} from '../types.js';
-import ResolvedImage from '../types/resolved_image.js';
+import {checkSubtype, ValueType} from '../types';
+import ResolvedImage from '../types/resolved_image';
 
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class Coalesce implements Expression {
     type: Type;
@@ -19,11 +17,12 @@ class Coalesce implements Expression {
         this.args = args;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Coalesce {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Coalesce | null | undefined {
         if (args.length < 2) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Coalesce'.
             return context.error("Expectected at least one argument.");
         }
-        let outputType: Type = (null: any);
+        let outputType: Type = (null as any);
         const expectedType = context.expectedType;
         if (expectedType && expectedType.kind !== 'value') {
             outputType = expectedType;
@@ -48,7 +47,7 @@ class Coalesce implements Expression {
 
         return needsAnnotation ?
             new Coalesce(ValueType, parsedArgs) :
-            new Coalesce((outputType: any), parsedArgs);
+            new Coalesce((outputType as any), parsedArgs);
     }
 
     evaluate(ctx: EvaluationContext): any | null {
@@ -87,6 +86,7 @@ class Coalesce implements Expression {
 
     serialize(): SerializedExpression {
         const serialized = ["coalesce"];
+        // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;
     }

package/expression/definitions/{coercion.js → coercion.ts}

@@ -1,20 +1,18 @@
-// @flow
-
 import assert from 'assert';
 
-import {BooleanType, ColorType, NumberType, StringType, ValueType, array, NullType} from '../types.js';
-import {Color, isValue, toString as valueToString, typeOf, validateRGBA} from '../values.js';
-import RuntimeError from '../runtime_error.js';
-import Formatted from '../types/formatted.js';
-import FormatExpression from '../definitions/format.js';
-import ImageExpression from '../definitions/image.js';
-import ResolvedImage from '../types/resolved_image.js';
+import {BooleanType, ColorType, NumberType, StringType, ValueType, array, NullType} from '../types';
+import {Color, isValue, toString as valueToString, typeOf, validateRGBA} from '../values';
+import RuntimeError from '../runtime_error';
+import Formatted from '../types/formatted';
+import FormatExpression from '../definitions/format';
+import ImageExpression from '../definitions/image';
+import ResolvedImage from '../types/resolved_image';
 
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type {Type, ArrayType} from '../types.js';
-import getType from '../../util/get_type.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type, ArrayType} from '../types';
+import getType from '../../util/get_type';
 
 const types = {
     'to-boolean': BooleanType,
@@ -39,11 +37,12 @@ class Coercion implements Expression {
         this.args = args;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
         if (args.length < 2)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected at least one argument.`);
 
-        const name: string = (args[0]: any);
+        const name: string = (args[0] as any);
         const parsed = [];
         let type: Type | ArrayType = NullType;
         if (name === 'to-array') {
@@ -55,16 +54,16 @@ class Coercion implements Expression {
                 if (context.expectedType.kind === 'array') {
                     type = array(context.expectedType.itemType, arrayLength);
                 } else {
+                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                     return context.error(`Expected ${context.expectedType.kind} but found array.`);
                 }
             } else if (arrayLength > 0 && isValue(args[1][0])) {
-                const value = (args[1][0]: any);
+                const value = (args[1][0]);
                 type = array(typeOf(value), arrayLength);
             } else {
                 return null;
             }
             for (let i = 0; i < arrayLength; i++) {
-                // $FlowIgnore
                 const member = args[1][i];
                 let parsedMember;
                 if (getType(member) === 'array') {
@@ -72,6 +71,7 @@ class Coercion implements Expression {
                 } else {
                     const memberType = getType(member);
                     if (memberType !== type.itemType.kind) {
+                        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                         return context.error(`Expected ${type.itemType.kind} but found ${memberType}.`);
                     }
                     parsedMember = context.registry['literal'].parse(['literal', member === undefined ? null : member], context);
@@ -83,6 +83,7 @@ class Coercion implements Expression {
             assert(types[name], name);
 
             if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return context.error(`Expected one argument.`);
 
             type = types[name];
@@ -118,7 +119,7 @@ class Coercion implements Expression {
                         error = validateRGBA(input[0], input[1], input[2], input[3]);
                     }
                     if (!error) {
-                        return new Color((input[0]: any) / 255, (input[1]: any) / 255, (input[2]: any) / 255, (input[3]: any));
+                        return new Color((input[0]) / 255, (input[1]) / 255, (input[2]) / 255, (input[3]));
                     }
                 }
             }
@@ -163,7 +164,7 @@ class Coercion implements Expression {
             return new ImageExpression(this.args[0]).serialize();
         }
 
-        const serialized: Array<mixed> = this.type.kind === 'array' ? [] : [`to-${this.type.kind}`];
+        const serialized: Array<unknown> = this.type.kind === 'array' ? [] : [`to-${this.type.kind}`];
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;
     }

package/expression/definitions/{collator.js → collator.ts}

@@ -1,12 +1,10 @@
-// @flow
+import {StringType, BooleanType, CollatorType} from '../types';
+import Collator from '../types/collator';
 
-import {StringType, BooleanType, CollatorType} from '../types.js';
-import Collator from '../types/collator.js';
-
-import type {Expression, SerializedExpression} from '../expression.js';
-import type EvaluationContext from '../evaluation_context.js';
-import type ParsingContext from '../parsing_context.js';
-import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression';
+import type EvaluationContext from '../evaluation_context';
+import type ParsingContext from '../parsing_context';
+import type {Type} from '../types';
 
 export default class CollatorExpression implements Expression {
     type: Type;
@@ -21,12 +19,14 @@ export default class CollatorExpression implements Expression {
         this.diacriticSensitive = diacriticSensitive;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | null | undefined {
         if (args.length !== 2)
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Expected one argument.`);
 
-        const options = (args[1]: any);
+        const options = (args[1] as any);
         if (typeof options !== "object" || Array.isArray(options))
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return context.error(`Collator options argument must be an object.`);
 
         const caseSensitive = context.parse(
@@ -67,7 +67,7 @@ export default class CollatorExpression implements Expression {
     }
 
     serialize(): SerializedExpression {
-        const options = {};
+        const options: Record<string, any> = {};
         options['case-sensitive'] = this.caseSensitive.serialize();
         options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
         if (this.locale) {