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

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

@@ -1,30 +1,30 @@
-// @flow
+import {ResolvedImageType, StringType} from '../types';
+import ResolvedImage from '../types/resolved_image';
 
-import {ResolvedImageType, StringType} from '../types.js';
-import ResolvedImage from '../types/resolved_image.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 ImageExpression implements Expression {
     type: Type;
     inputPrimary: Expression;
-    inputSecondary: ?Expression;
+    inputSecondary: Expression | null | undefined;
 
-    constructor(inputPrimary: Expression, inputSecondary: ?Expression) {
+    constructor(inputPrimary: Expression, inputSecondary?: Expression | null) {
         this.type = ResolvedImageType;
         this.inputPrimary = inputPrimary;
         this.inputSecondary = inputSecondary;
     }
 
-    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 two or more arguments.`);
         }
 
         const namePrimary = context.parse(args[1], 1, StringType);
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
         if (!namePrimary) return context.error(`No image name provided.`);
 
         if (args.length === 2) {
@@ -32,6 +32,7 @@ export default class ImageExpression implements Expression {
         }
 
         const nameSecondary = context.parse(args[2], 1, StringType);
+        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
         if (!nameSecondary) return context.error(`Secondary image variant is not a string.`);
 
         return new ImageExpression(namePrimary, nameSecondary);
@@ -64,7 +65,6 @@ export default class ImageExpression implements Expression {
 
     serialize(): SerializedExpression {
         if (this.inputSecondary) {
-            // $FlowIgnore
             return ["image", this.inputPrimary.serialize(), this.inputSecondary.serialize()];
         }
         return ["image", this.inputPrimary.serialize()];

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

@@ -1,13 +1,20 @@
-// @flow
-
-import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isValidType, isValidNativeType} from '../types.js';
-import RuntimeError from '../runtime_error.js';
-import {typeOf} from '../values.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} from '../types.js';
+import {
+    BooleanType,
+    StringType,
+    ValueType,
+    NullType,
+    toString,
+    NumberType,
+    isValidType,
+    isValidNativeType,
+} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
+
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class In implements Expression {
     type: Type;
@@ -20,8 +27,9 @@ class In implements Expression {
         this.haystack = haystack;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?In {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): In | null | undefined {
         if (args.length !== 3) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'In'.
             return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
         }
 
@@ -32,6 +40,7 @@ class In implements Expression {
         if (!needle || !haystack) return null;
 
         if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'In'.
             return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
         }
 
@@ -39,8 +48,8 @@ class In implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): boolean {
-        const needle = (this.needle.evaluate(ctx): any);
-        const haystack = (this.haystack.evaluate(ctx): any);
+        const needle = (this.needle.evaluate(ctx));
+        const haystack = (this.haystack.evaluate(ctx));
 
         if (haystack == null) return false;
 

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

@@ -1,7 +1,4 @@
-// @flow
-
 import {
-    type Type,
     NumberType,
     StringType,
     BooleanType,
@@ -11,26 +8,26 @@ import {
     ErrorType,
     CollatorType,
     array,
-    toString as typeToString
-} from '../types.js';
+    toString as typeToString,
+} from '../types';
 
-import {typeOf, Color, validateRGBA, validateHSLA, toString as valueToString} from '../values.js';
-import CompoundExpression from '../compound_expression.js';
-import RuntimeError from '../runtime_error.js';
-import Let from './let.js';
-import Var from './var.js';
-import Literal from './literal.js';
-import Assertion from './assertion.js';
-import Coercion from './coercion.js';
-import At from './at.js';
-import In from './in.js';
-import IndexOf from './index_of.js';
-import Match from './match.js';
-import Case from './case.js';
-import Slice from './slice.js';
-import Step from './step.js';
-import Interpolate from './interpolate.js';
-import Coalesce from './coalesce.js';
+import {typeOf, Color, validateRGBA, validateHSLA, toString as valueToString} from '../values';
+import CompoundExpression from '../compound_expression';
+import RuntimeError from '../runtime_error';
+import Let from './let';
+import Var from './var';
+import Literal from './literal';
+import Assertion from './assertion';
+import Coercion from './coercion';
+import At from './at';
+import In from './in';
+import IndexOf from './index_of';
+import Match from './match';
+import Case from './case';
+import Slice from './slice';
+import Step from './step';
+import Interpolate from './interpolate';
+import Coalesce from './coalesce';
 import {
     Equals,
     NotEquals,
@@ -38,20 +35,21 @@ import {
     GreaterThan,
     LessThanOrEqual,
     GreaterThanOrEqual
-} from './comparison.js';
-import CollatorExpression from './collator.js';
-import NumberFormat from './number_format.js';
-import FormatExpression from './format.js';
-import ImageExpression from './image.js';
-import Length from './length.js';
-import Within from './within.js';
-import Config from './config.js';
-import Distance from './distance.js';
-import {mulberry32} from '../../util/random.js';
+} from './comparison';
+import CollatorExpression from './collator';
+import NumberFormat from './number_format';
+import FormatExpression from './format';
+import ImageExpression from './image';
+import Length from './length';
+import Within from './within';
+import Config from './config';
+import Distance from './distance';
+import {mulberry32} from '../../util/random';
 
-import type EvaluationContext from '../evaluation_context.js';
-import type {Varargs} from '../compound_expression.js';
-import type {Expression, ExpressionRegistry} from '../expression.js';
+import type {Type} from '../types';
+import type EvaluationContext from '../evaluation_context';
+import type {Varargs} from '../compound_expression';
+import type {Expression, ExpressionRegistry} from '../expression';
 
 const expressions: ExpressionRegistry = {
     // special forms
@@ -61,94 +59,83 @@ const expressions: ExpressionRegistry = {
     '<': LessThan,
     '>=': GreaterThanOrEqual,
     '<=': LessThanOrEqual,
-    // $FlowFixMe[method-unbinding]
     'array': Assertion,
-    // $FlowFixMe[method-unbinding]
     'at': At,
     'boolean': Assertion,
-    // $FlowFixMe[method-unbinding]
     'case': Case,
-    // $FlowFixMe[method-unbinding]
     'coalesce': Coalesce,
-    // $FlowFixMe[method-unbinding]
     'collator': CollatorExpression,
-    // $FlowFixMe[method-unbinding]
     'format': FormatExpression,
-    // $FlowFixMe[method-unbinding]
     'image': ImageExpression,
-    // $FlowFixMe[method-unbinding]
     'in': In,
-    // $FlowFixMe[method-unbinding]
     'index-of': IndexOf,
-    // $FlowFixMe[method-unbinding]
     'interpolate': Interpolate,
     'interpolate-hcl': Interpolate,
     'interpolate-lab': Interpolate,
-    // $FlowFixMe[method-unbinding]
     'length': Length,
-    // $FlowFixMe[method-unbinding]
     'let': Let,
-    // $FlowFixMe[method-unbinding]
     'literal': Literal,
-    // $FlowFixMe[method-unbinding]
     'match': Match,
     'number': Assertion,
-    // $FlowFixMe[method-unbinding]
     'number-format': NumberFormat,
     'object': Assertion,
-    // $FlowFixMe[method-unbinding]
     'slice': Slice,
-    // $FlowFixMe[method-unbinding]
     'step': Step,
     'string': Assertion,
-    // $FlowFixMe[method-unbinding]
     'to-boolean': Coercion,
     'to-color': Coercion,
     'to-number': Coercion,
     'to-string': Coercion,
-    // $FlowFixMe[method-unbinding]
     'var': Var,
-    // $FlowFixMe[method-unbinding]
     'within': Within,
-    // $FlowFixMe[method-unbinding]
     'distance': Distance,
-    // $FlowFixMe[method-unbinding]
     'config': Config
 };
 
-function rgba(ctx: EvaluationContext, [r, g, b, a]: Array<Expression>) {
+function rgba(ctx: EvaluationContext, [r, g, b, a]: Expression[]) {
     r = r.evaluate(ctx);
     g = g.evaluate(ctx);
     b = b.evaluate(ctx);
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateRGBA(r, g, b, alpha);
     if (error) throw new RuntimeError(error);
+    // @ts-expect-error
     return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
 }
 
-function hsla(ctx: EvaluationContext, [h, s, l, a]: Array<Expression>) {
+function hsla(ctx: EvaluationContext, [h, s, l, a]: Expression[]) {
     h = h.evaluate(ctx);
     s = s.evaluate(ctx);
     l = l.evaluate(ctx);
     const alpha = a ? a.evaluate(ctx) : 1;
     const error = validateHSLA(h, s, l, alpha);
     if (error) throw new RuntimeError(error);
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
     const colorFunction = `hsla(${h}, ${s}%, ${l}%, ${alpha})`;
     const color = Color.parse(colorFunction);
     if (!color) throw new RuntimeError(`Failed to parse HSLA color: ${colorFunction}`);
     return color;
 }
 
-function has(key: string, obj: {[string]: any}): boolean {
+function has(
+    key: string,
+    obj: {
+        [key: string]: any;
+    },
+): boolean {
     return key in obj;
 }
 
-function get(key: string, obj: {[string]: any}) {
+function get(key: string, obj: {
+    [key: string]: any;
+}) {
     const v = obj[key];
     return typeof v === 'undefined' ? null : v;
 }
 
-function binarySearch(v: any, a: {[number]: any}, i: number, j: number) {
+function binarySearch(v: any, a: {
+    [key: number]: any;
+}, i: number, j: number) {
     while (i <= j) {
         const m = (i + j) >> 1;
         if (a[m] === v)
@@ -193,7 +180,7 @@ CompoundExpression.register(expressions, {
         array(NumberType, 4),
         [ColorType],
         (ctx, [v]) => {
-            return v.evaluate(ctx).toArray();
+            return v.evaluate(ctx).toRenderColor(null).toArray();
         }
     ],
     'rgb': [
@@ -463,24 +450,24 @@ CompoundExpression.register(expressions, {
     'filter-==': [
         BooleanType,
         [StringType, ValueType],
-        (ctx, [k, v]) => ctx.properties()[(k: any).value] === (v: any).value
+        (ctx, [k, v]) => ctx.properties()[(k).value] === (v).value
     ],
     'filter-id-==': [
         BooleanType,
         [ValueType],
-        (ctx, [v]) => ctx.id() === (v: any).value
+        (ctx, [v]) => ctx.id() === (v).value
     ],
     'filter-type-==': [
         BooleanType,
         [StringType],
-        (ctx, [v]) => ctx.geometryType() === (v: any).value
+        (ctx, [v]) => ctx.geometryType() === (v).value
     ],
     'filter-<': [
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
-            const a = ctx.properties()[(k: any).value];
-            const b = (v: any).value;
+            const a = ctx.properties()[(k).value];
+            const b = (v).value;
             return typeof a === typeof b && a < b;
         }
     ],
@@ -489,7 +476,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
-            const b = (v: any).value;
+            const b = (v).value;
             return typeof a === typeof b && a < b;
         }
     ],
@@ -497,8 +484,8 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
-            const a = ctx.properties()[(k: any).value];
-            const b = (v: any).value;
+            const a = ctx.properties()[(k).value];
+            const b = (v).value;
             return typeof a === typeof b && a > b;
         }
     ],
@@ -507,7 +494,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
-            const b = (v: any).value;
+            const b = (v).value;
             return typeof a === typeof b && a > b;
         }
     ],
@@ -515,8 +502,8 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
-            const a = ctx.properties()[(k: any).value];
-            const b = (v: any).value;
+            const a = ctx.properties()[(k).value];
+            const b = (v).value;
             return typeof a === typeof b && a <= b;
         }
     ],
@@ -525,7 +512,7 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
-            const b = (v: any).value;
+            const b = (v).value;
             return typeof a === typeof b && a <= b;
         }
     ],
@@ -533,8 +520,8 @@ CompoundExpression.register(expressions, {
         BooleanType,
         [StringType, ValueType],
         (ctx, [k, v]) => {
-            const a = ctx.properties()[(k: any).value];
-            const b = (v: any).value;
+            const a = ctx.properties()[(k).value];
+            const b = (v).value;
             return typeof a === typeof b && a >= b;
         }
     ],
@@ -543,14 +530,14 @@ CompoundExpression.register(expressions, {
         [ValueType],
         (ctx, [v]) => {
             const a = ctx.id();
-            const b = (v: any).value;
+            const b = (v).value;
             return typeof a === typeof b && a >= b;
         }
     ],
     'filter-has': [
         BooleanType,
         [ValueType],
-        (ctx, [k]) => (k: any).value in ctx.properties()
+        (ctx, [k]) => (k).value in ctx.properties()
     ],
     'filter-has-id': [
         BooleanType,
@@ -560,24 +547,24 @@ CompoundExpression.register(expressions, {
     'filter-type-in': [
         BooleanType,
         [array(StringType)],
-        (ctx, [v]) => (v: any).value.indexOf(ctx.geometryType()) >= 0
+        (ctx, [v]) => (v).value.indexOf(ctx.geometryType()) >= 0
     ],
     'filter-id-in': [
         BooleanType,
         [array(ValueType)],
-        (ctx, [v]) => (v: any).value.indexOf(ctx.id()) >= 0
+        (ctx, [v]) => (v).value.indexOf(ctx.id()) >= 0
     ],
     'filter-in-small': [
         BooleanType,
         [StringType, array(ValueType)],
         // assumes v is an array literal
-        (ctx, [k, v]) => (v: any).value.indexOf(ctx.properties()[(k: any).value]) >= 0
+        (ctx, [k, v]) => (v).value.indexOf(ctx.properties()[(k).value]) >= 0
     ],
     'filter-in-large': [
         BooleanType,
         [StringType, array(ValueType)],
         // assumes v is a array literal with values sorted in ascending order and of a single type
-        (ctx, [k, v]) => binarySearch(ctx.properties()[(k: any).value], (v: any).value, 0, (v: any).value.length - 1)
+        (ctx, [k, v]) => binarySearch(ctx.properties()[(k).value], (v).value, 0, (v).value.length - 1)
     ],
     'all': {
         type: BooleanType,

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

@@ -1,19 +1,26 @@
-// @flow
-
-import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isValidType, isValidNativeType} from '../types.js';
-import RuntimeError from '../runtime_error.js';
-import {typeOf} from '../values.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} from '../types.js';
+import {
+    BooleanType,
+    StringType,
+    ValueType,
+    NullType,
+    toString,
+    NumberType,
+    isValidType,
+    isValidNativeType,
+} from '../types';
+import RuntimeError from '../runtime_error';
+import {typeOf} from '../values';
+
+import type {Expression, SerializedExpression} from '../expression';
+import type ParsingContext from '../parsing_context';
+import type EvaluationContext from '../evaluation_context';
+import type {Type} from '../types';
 
 class IndexOf implements Expression {
     type: Type;
     needle: Expression;
     haystack: Expression;
-    fromIndex: ?Expression;
+    fromIndex: Expression | null | undefined;
 
     constructor(needle: Expression, haystack: Expression, fromIndex?: Expression) {
         this.type = NumberType;
@@ -22,8 +29,9 @@ class IndexOf implements Expression {
         this.fromIndex = fromIndex;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?IndexOf {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): IndexOf | null | undefined {
         if (args.length <= 2 ||  args.length >= 5) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'IndexOf'.
             return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
         }
 
@@ -33,6 +41,7 @@ class IndexOf implements Expression {
 
         if (!needle || !haystack) return null;
         if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
+            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'IndexOf'.
             return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
         }
 
@@ -46,8 +55,8 @@ class IndexOf implements Expression {
     }
 
     evaluate(ctx: EvaluationContext): any {
-        const needle = (this.needle.evaluate(ctx): any);
-        const haystack = (this.haystack.evaluate(ctx): any);
+        const needle = (this.needle.evaluate(ctx));
+        const haystack = (this.haystack.evaluate(ctx));
 
         if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
             throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
@@ -58,7 +67,7 @@ class IndexOf implements Expression {
         }
 
         if (this.fromIndex) {
-            const fromIndex = (this.fromIndex.evaluate(ctx): number);
+            const fromIndex = (this.fromIndex.evaluate(ctx) as number);
             return haystack.indexOf(needle, fromIndex);
         }