maplibre-gl 2.2.0-pre.2 → 2.2.0

package/src/style-spec/expression/definitions/match.ts

@@ -116,47 +116,6 @@ class Match implements Expression {
     outputDefined(): boolean {
         return this.outputs.every(out => out.outputDefined()) && this.otherwise.outputDefined();
     }
-
-    serialize(): Array<unknown> {
-        const serialized = ['match', this.input.serialize()];
-
-        // Sort so serialization has an arbitrary defined order, even though
-        // branch order doesn't affect evaluation
-        const sortedLabels = Object.keys(this.cases).sort();
-
-        // Group branches by unique match expression to support condensed
-        // serializations of the form [case1, case2, ...] -> matchExpression
-        const groupedByOutput: Array<[number, Array<number | string>]> = [];
-        const outputLookup: {
-            [index: number]: number;
-        } = {}; // lookup index into groupedByOutput for a given output expression
-        for (const label of sortedLabels) {
-            const outputIndex = outputLookup[this.cases[label]];
-            if (outputIndex === undefined) {
-                // First time seeing this output, add it to the end of the grouped list
-                outputLookup[this.cases[label]] = groupedByOutput.length;
-                groupedByOutput.push([this.cases[label], [label]]);
-            } else {
-                // We've seen this expression before, add the label to that output's group
-                groupedByOutput[outputIndex][1].push(label);
-            }
-        }
-
-        const coerceLabel = (label) => this.inputType.kind === 'number' ? Number(label) : label;
-
-        for (const [outputIndex, labels] of groupedByOutput) {
-            if (labels.length === 1) {
-                // Only a single label matches this output expression
-                serialized.push(coerceLabel(labels[0]));
-            } else {
-                // Array of literal labels pointing to this output expression
-                serialized.push(labels.map(coerceLabel));
-            }
-            serialized.push(this.outputs[outputIndex].serialize());
-        }
-        serialized.push(this.otherwise.serialize());
-        return serialized;
-    }
 }
 
 export default Match;

package/src/style-spec/expression/definitions/number_format.ts

@@ -112,21 +112,4 @@ export default class NumberFormat implements Expression {
     outputDefined() {
         return false;
     }
-
-    serialize() {
-        const options = {};
-        if (this.locale) {
-            options['locale'] = this.locale.serialize();
-        }
-        if (this.currency) {
-            options['currency'] = this.currency.serialize();
-        }
-        if (this.minFractionDigits) {
-            options['min-fraction-digits'] = this.minFractionDigits.serialize();
-        }
-        if (this.maxFractionDigits) {
-            options['max-fraction-digits'] = this.maxFractionDigits.serialize();
-        }
-        return ['number-format', this.number.serialize(), options];
-    }
 }

package/src/style-spec/expression/definitions/slice.ts

@@ -79,14 +79,6 @@ class Slice implements Expression {
     outputDefined() {
         return false;
     }
-
-    serialize() {
-        if (this.endIndex != null && this.endIndex !== undefined) {
-            const endIndex = this.endIndex.serialize();
-            return ['slice', this.input.serialize(), this.beginIndex.serialize(), endIndex];
-        }
-        return ['slice', this.input.serialize(), this.beginIndex.serialize()];
-    }
 }
 
 export default Slice;

package/src/style-spec/expression/definitions/step.ts

@@ -102,17 +102,6 @@ class Step implements Expression {
     outputDefined(): boolean {
         return this.outputs.every(out => out.outputDefined());
     }
-
-    serialize() {
-        const serialized = ['step', this.input.serialize()];
-        for (let i = 0; i < this.labels.length; i++) {
-            if (i > 0) {
-                serialized.push(this.labels[i]);
-            }
-            serialized.push(this.outputs[i].serialize());
-        }
-        return serialized;
-    }
 }
 
 export default Step;

package/src/style-spec/expression/definitions/var.ts

@@ -35,10 +35,6 @@ class Var implements Expression {
     outputDefined() {
         return false;
     }
-
-    serialize() {
-        return ['var', this.name];
-    }
 }
 
 export default Var;

package/src/style-spec/expression/definitions/within.ts

@@ -329,11 +329,6 @@ class Within implements Expression {
     outputDefined(): boolean {
         return true;
     }
-
-    serialize(): Array<unknown> {
-        return ['within', this.geojson];
-    }
-
 }
 
 export default Within;

package/src/style-spec/expression/expression.test.ts

@@ -40,7 +40,7 @@ describe('createPropertyExpression', () => {
 
 describe('evaluate expression', () => {
     test('warns and falls back to default for invalid enum values', () => {
-        const {value} = createPropertyExpression([ 'get', 'x' ], {
+        const {value} = createPropertyExpression(['get', 'x'], {
             type: 'enum',
             values: {a: {}, b: {}, c: {}},
             default: 'a',

package/src/style-spec/expression/expression.ts

@@ -2,8 +2,9 @@ import type {Type} from './types';
 import type ParsingContext from './parsing_context';
 import type EvaluationContext from './evaluation_context';
 
-type SerializedExpression = Array<unknown> | string | number | boolean | null;
-
+/**
+ * Expression
+ */
 export interface Expression {
     readonly type: Type;
     evaluate(ctx: EvaluationContext): any;
@@ -13,7 +14,6 @@ export interface Expression {
      * false if the complete set of outputs is statically undecidable, otherwise true.
      */
     outputDefined(): boolean;
-    serialize(): SerializedExpression;
 }
 
 export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression;

package/src/style-spec/expression/index.ts

@@ -379,8 +379,10 @@ export function normalizePropertyExpression<T>(
 
     } else {
         let constant: any = value;
-        if (typeof value === 'string' && specification.type === 'color') {
+        if (specification.type === 'color' && typeof value === 'string') {
             constant = Color.parse(value);
+        } else if (specification.type === 'padding' && (typeof value === 'number' || Array.isArray(value))) {
+            constant = Padding.parse(value as (number | number[]));
         }
         return {
             kind: 'constant',
@@ -430,7 +432,8 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
     return result;
 }
 
-import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types';
+import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, PaddingType, ResolvedImageType, array} from './types';
+import Padding from '../util/padding';
 
 function getExpectedType(spec: StylePropertySpecification): Type {
     const types = {
@@ -440,6 +443,7 @@ function getExpectedType(spec: StylePropertySpecification): Type {
         enum: StringType,
         boolean: BooleanType,
         formatted: FormattedType,
+        padding: PaddingType,
         resolvedImage: ResolvedImageType
     };
 
@@ -458,6 +462,8 @@ function getDefaultValue(spec: StylePropertySpecification): Value {
         return new Color(0, 0, 0, 0);
     } else if (spec.type === 'color') {
         return Color.parse(spec.default) || null;
+    } else if (spec.type === 'padding') {
+        return Padding.parse(spec.default) || null;
     } else if (spec.default === undefined) {
         return null;
     } else {

package/src/style-spec/expression/parsing_context.ts

@@ -120,6 +120,8 @@ class ParsingContext {
                         parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
                     } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
                         parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
+                    } else if (expected.kind === 'padding' && (actual.kind === 'value' || actual.kind === 'number' || actual.kind === 'array')) {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
                     } else if (this.checkSubtype(expected, actual)) {
                         return null;
                     }

package/src/style-spec/expression/types/formatted.ts

@@ -46,27 +46,4 @@ export default class Formatted {
         if (this.sections.length === 0) return '';
         return this.sections.map(section => section.text).join('');
     }
-
-    serialize(): Array<unknown> {
-        const serialized: Array<unknown> = ['format'];
-        for (const section of this.sections) {
-            if (section.image) {
-                serialized.push(['image', section.image.name]);
-                continue;
-            }
-            serialized.push(section.text);
-            const options: {[key: string]: unknown} = {};
-            if (section.fontStack) {
-                options['text-font'] = ['literal', section.fontStack.split(',')];
-            }
-            if (section.scale) {
-                options['font-scale'] = section.scale;
-            }
-            if (section.textColor) {
-                options['text-color'] = (['rgba'] as Array<unknown>).concat(section.textColor.toArray());
-            }
-            serialized.push(options);
-        }
-        return serialized;
-    }
 }

package/src/style-spec/expression/types/resolved_image.ts

@@ -20,8 +20,4 @@ export default class ResolvedImage {
         if (!name) return null; // treat empty values as no image
         return new ResolvedImage({name, available: false});
     }
-
-    serialize(): Array<string> {
-        return ['image', this.name];
-    }
 }

package/src/style-spec/expression/types.ts

@@ -28,6 +28,9 @@ export type CollatorTypeT = {
 export type FormattedTypeT = {
     kind: 'formatted';
 };
+export type PaddingTypeT = {
+    kind: 'padding';
+};
 export type ResolvedImageTypeT = {
     kind: 'resolvedImage';
 };
@@ -35,7 +38,7 @@ export type ResolvedImageTypeT = {
 export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
 
 export type Type = NullTypeT | NumberTypeT | StringTypeT | BooleanTypeT | ColorTypeT | ObjectTypeT | ValueTypeT | // eslint-disable-line no-use-before-define
-ArrayType | ErrorTypeT | CollatorTypeT | FormattedTypeT | ResolvedImageTypeT;
+ArrayType | ErrorTypeT | CollatorTypeT | FormattedTypeT | PaddingTypeT | ResolvedImageTypeT;
 
 export type ArrayType = {
     kind: 'array';
@@ -55,6 +58,7 @@ export const ValueType = {kind: 'value'} as ValueTypeT;
 export const ErrorType = {kind: 'error'} as ErrorTypeT;
 export const CollatorType = {kind: 'collator'} as CollatorTypeT;
 export const FormattedType = {kind: 'formatted'} as FormattedTypeT;
+export const PaddingType = {kind: 'padding'} as PaddingTypeT;
 export const ResolvedImageType = {kind: 'resolvedImage'} as ResolvedImageTypeT;
 
 export function array(itemType: Type, N?: number | null): ArrayType {
@@ -85,6 +89,7 @@ const valueMemberTypes = [
     FormattedType,
     ObjectType,
     array(ValueType),
+    PaddingType,
     ResolvedImageType
 ];
 

package/src/style-spec/expression/values.ts

@@ -3,8 +3,9 @@ import assert from 'assert';
 import Color from '../util/color';
 import Collator from './types/collator';
 import Formatted from './types/formatted';
+import Padding from '../util/padding';
 import ResolvedImage from './types/resolved_image';
-import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array} from './types';
+import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array, PaddingType} from './types';
 
 import type {Type} from './types';
 
@@ -27,7 +28,7 @@ export function validateRGBA(r: unknown, g: unknown, b: unknown, a?: unknown): s
     return null;
 }
 
-export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | ReadonlyArray<Value> | {
+export type Value = null | string | boolean | number | Color | Collator | Formatted | Padding | ResolvedImage | ReadonlyArray<Value> | {
     readonly [x: string]: Value;
 };
 
@@ -46,6 +47,8 @@ export function isValue(mixed: unknown): boolean {
         return true;
     } else if (mixed instanceof Formatted) {
         return true;
+    } else if (mixed instanceof Padding) {
+        return true;
     } else if (mixed instanceof ResolvedImage) {
         return true;
     } else if (Array.isArray(mixed)) {
@@ -82,6 +85,8 @@ export function typeOf(value: Value): Type {
         return CollatorType;
     } else if (value instanceof Formatted) {
         return FormattedType;
+    } else if (value instanceof Padding) {
+        return PaddingType;
     } else if (value instanceof ResolvedImage) {
         return ResolvedImageType;
     } else if (Array.isArray(value)) {
@@ -113,11 +118,11 @@ export function toString(value: Value) {
         return '';
     } else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value);
-    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+    } else if (value instanceof Color || value instanceof Formatted || value instanceof Padding || value instanceof ResolvedImage) {
         return value.toString();
     } else {
         return JSON.stringify(value);
     }
 }
 
-export {Color, Collator};
+export {Color, Collator, Padding};

package/src/style-spec/feature_filter/convert.ts

@@ -1,17 +1,8 @@
 import {isExpressionFilter} from './index';
 
-import type {FilterSpecification} from '../types.g';
+import type {ExpressionFilterSpecification, ExpressionInputType, ExpressionSpecification, FilterSpecification, LegacyFilterSpecification} from '../types.g';
 
-type ExpectedTypes = {[_: string]: 'string' | 'number' | 'boolean'};
-
-/**
- * Convert the given legacy filter to (the JSON representation of) an
- * equivalent expression
- * @private
- */
-export default function convertFilter(filter: FilterSpecification): unknown {
-    return _convertFilter(filter, {});
-}
+type ExpectedTypes = {[_: string]: ExpressionInputType};
 
 /*
  * Convert the given filter to an expression, storing the expected types for
@@ -61,51 +52,58 @@ export default function convertFilter(filter: FilterSpecification): unknown {
  * false (legacy filter semantics) are equivalent: they cause the filter to
  * produce a `false` result.
  */
-function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes): unknown {
-    if (isExpressionFilter(filter)) { return filter; }
-
+export default function convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes = {}): ExpressionFilterSpecification {
+    if (isExpressionFilter(filter)) return filter;
     if (!filter) return true;
-    const op = filter[0];
-    if (filter.length <= 1) return (op !== 'any');
-
-    let converted;
-
-    if (
-        op === '==' ||
-        op === '!=' ||
-        op === '<' ||
-        op === '>' ||
-        op === '<=' ||
-        op === '>='
-    ) {
-        const [, property, value] = filter;
-        converted = convertComparisonOp(property as string, value, op, expectedTypes);
-    } else if (op === 'any') {
-        const children = (filter).slice(1).map((f: FilterSpecification) => {
-            const types = {};
-            const child = _convertFilter(f, types);
-            const typechecks = runtimeTypeChecks(types);
-            return typechecks === true ? child : ['case', typechecks, child, false];
-        });
-        return ['any'].concat(children as string[]);
-    } else if (op === 'all') {
-        const children = (filter).slice(1).map(f => _convertFilter(f as FilterSpecification, expectedTypes));
-        return children.length > 1 ? ['all'].concat(children as string[]) : [].concat(...children);
-    } else if (op === 'none') {
-        return ['!', _convertFilter(['any'].concat(filter.slice(1) as string[]) as string[], {})];
-    } else if (op === 'in') {
-        converted = convertInOp(filter[1] as string, filter.slice(2));
-    } else if (op === '!in') {
-        converted = convertInOp(filter[1] as string, filter.slice(2), true);
-    } else if (op === 'has') {
-        converted = convertHasOp(filter[1] as string);
-    } else if (op === '!has') {
-        converted = ['!', convertHasOp(filter[1] as string)];
-    } else {
-        converted = true;
-    }
 
-    return converted;
+    const legacyFilter = filter as LegacyFilterSpecification;
+    const legacyOp = legacyFilter[0];
+    if (filter.length <= 1) return (legacyOp !== 'any');
+
+    switch (legacyOp) {
+        case '==':
+        case '!=':
+        case '<':
+        case '>':
+        case '<=':
+        case '>=': {
+            const [, property, value] = filter;
+            return convertComparisonOp(property as string, value, legacyOp, expectedTypes);
+        }
+        case 'any': {
+            const [, ...conditions] = legacyFilter;
+            const children = conditions.map((f: LegacyFilterSpecification) => {
+                const types = {};
+                const child = convertFilter(f, types);
+                const typechecks = runtimeTypeChecks(types);
+                return typechecks === true ? child : ['case', typechecks, child, false] as ExpressionSpecification;
+            });
+            return ['any', ...children];
+        }
+        case 'all': {
+            const [, ...conditions] = legacyFilter;
+            const children = conditions.map(f => convertFilter(f, expectedTypes));
+            return children.length > 1 ? ['all', ...children] : children[0];
+        }
+        case 'none': {
+            const [, ...conditions] = legacyFilter;
+            return ['!', convertFilter(['any', ...conditions], {})];
+        }
+        case 'in': {
+            const [, property, ...values] = legacyFilter;
+            return convertInOp(property, values);
+        }
+        case '!in': {
+            const [, property, ...values] = legacyFilter;
+            return convertInOp(property, values, true);
+        }
+        case 'has':
+            return convertHasOp(legacyFilter[1]);
+        case '!has':
+            return ['!', convertHasOp(legacyFilter[1])];
+        default:
+            return true;
+    }
 }
 
 // Given a set of feature properties and an expected type for each one,
@@ -116,7 +114,7 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
 //   ['==', ['typeof', ['get', 'name'], 'string']],
 //   ['==', ['typeof', ['get', 'population'], 'number]]
 // ]
-function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
+function runtimeTypeChecks(expectedTypes: ExpectedTypes): ExpressionFilterSpecification {
     const conditions = [];
     for (const property in expectedTypes) {
         const get = property === '$id' ? ['id'] : ['get', property];
@@ -124,13 +122,13 @@ function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
     }
     if (conditions.length === 0) return true;
     if (conditions.length === 1) return conditions[0];
-    return ['all'].concat(conditions);
+    return ['all', ...conditions];
 }
 
-function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null) {
+function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null): ExpressionFilterSpecification {
     let get;
     if (property === '$type') {
-        return [op, ['geometry-type'], value];
+        return [op, ['geometry-type'], value] as ExpressionFilterSpecification;
     } else if (property === '$id') {
         get = ['id'];
     } else {
@@ -156,13 +154,13 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
         ];
     }
 
-    return [op, get, value];
+    return [op, get, value] as ExpressionFilterSpecification;
 }
 
-function convertInOp(property: string, values: Array<any>, negate = false) {
+function convertInOp(property: string, values: Array<any>, negate = false): ExpressionFilterSpecification {
     if (values.length === 0) return negate;
 
-    let get;
+    let get: ExpressionSpecification;
     if (property === '$type') {
         get = ['geometry-type'];
     } else if (property === '$id') {
@@ -190,12 +188,14 @@ function convertInOp(property: string, values: Array<any>, negate = false) {
         return ['match', get, uniqueValues, !negate, negate];
     }
 
-    return [ negate ? 'all' : 'any' as any].concat(
-        values.map(v => [negate ? '!=' : '==', get, v])
-    );
+    if (negate) {
+        return ['all', ...values.map(v => ['!=', get, v] as ExpressionSpecification)];
+    } else {
+        return ['any', ...values.map(v => ['==', get, v] as ExpressionSpecification)];
+    }
 }
 
-function convertHasOp(property: string) {
+function convertHasOp(property: string): ExpressionFilterSpecification {
     if (property === '$type') {
         return true;
     } else if (property === '$id') {

package/src/style-spec/feature_filter/feature_filter.test.ts

@@ -5,10 +5,39 @@ import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../../geo/mercator_coordinate';
 import EXTENT from '../../data/extent';
 import {CanonicalTileID} from '../../source/tile_id';
-import {FilterSpecification} from '../types.g';
+import {ExpressionFilterSpecification, FilterSpecification} from '../types.g';
 import {Feature} from '../expression';
 
 describe('filter', () => {
+    test('exprssions transpilation test', () => {
+        function compileTimeCheck(_: ExpressionFilterSpecification) {
+            expect(true).toBeTruthy();
+        }
+        compileTimeCheck(['any']);
+        compileTimeCheck(['at', 2, ['array', 1, 2, 3]]);
+        compileTimeCheck(['case', ['has', 'color'], ['get', 'color'], 'white']);
+        compileTimeCheck(['case', ['all', ['has', 'point_count'], ['<', ['get', 'point_count'], 3]], ['get', 'cluster_routes'], '']);
+        compileTimeCheck(['interpolate', ['linear'], ['get', 'point_count'], 2, 18.0, 10, 24.0]);
+        compileTimeCheck(['case', ['has', 'point_count'], ['interpolate', ['linear'], ['get', 'point_count'], 2, 18.0, 10, 24.0], 12.0]);
+        compileTimeCheck([
+            'case',
+            ['has', 'point_count'], ['interpolate', ['linear'], ['get', 'point_count'], 2, '#ccc', 10, '#444'],
+            ['has', 'priorityValue'], ['interpolate', ['linear'], ['get', 'priorityValue'], 0, '#ff9', 1, '#f66'],
+            '#fcaf3e'
+        ]);
+        compileTimeCheck([
+            'case',
+            ['==', ['get', 'CAPITAL'], 1], 'city-capital',
+            ['>=', ['get', 'POPULATION'], 1000000], 'city-1M',
+            ['>=', ['get', 'POPULATION'], 500000], 'city-500k',
+            ['>=', ['get', 'POPULATION'], 100000], 'city-100k',
+            'city'
+        ]);
+        compileTimeCheck(['match', ['get', 'TYPE'], ['TARGETPOINT:HOSPITAL'], true, false]);
+        compileTimeCheck(['match', ['get', 'TYPE'], ['ADIZ', 'AMA', 'AWY', 'CLASS', 'NO-FIR', 'OCA', 'OTA', 'P', 'RAS', 'RCA', 'UTA', 'UTA-P'], true, false]);
+        compileTimeCheck(['==', ['get', 'MILITARYAIRPORT'], 1]);
+    });
+
     test('expression, zoom', () => {
         const f = createFilter(['>=', ['number', ['get', 'x']], ['zoom']]).filter;
         expect(f({zoom: 1}, {properties: {x: 0}} as any as Feature)).toBe(false);
@@ -52,6 +81,18 @@ describe('filter', () => {
         expect(createFilter(['any', false, false]).filter(undefined, undefined)).toBe(false);
     });
 
+    test('expression, literal', () => {
+        expect(createFilter(['literal', true]).filter(undefined, undefined)).toBe(true);
+        expect(createFilter(['literal', false]).filter(undefined, undefined)).toBe(false);
+    });
+
+    test('expression, match', () => {
+        const match = createFilter(['match', ['get', 'x'], ['a', 'b', 'c'], true, false]).filter;
+        expect(match(undefined, {properties: {x: 'a'}} as any as Feature)).toBe(true);
+        expect(match(undefined, {properties: {x: 'c'}} as any as Feature)).toBe(true);
+        expect(match(undefined, {properties: {x: 'd'}} as any as Feature)).toBe(false);
+    });
+
     test('expression, type error', () => {
         expect(() => {
             createFilter(['==', ['number', ['get', 'x']], ['string', ['get', 'y']]]);
@@ -77,7 +118,7 @@ describe('filter', () => {
         };
         const withinFilter =  createFilter(['within', {'type': 'Polygon', 'coordinates': [[[0, 0], [5, 0], [5, 5], [0, 5], [0, 0]]]}]);
         expect(withinFilter.needGeometry).toBe(true);
-        const canonical = {z: 3, x: 3, y:3} as CanonicalTileID;
+        const canonical = {z: 3, x: 3, y: 3} as CanonicalTileID;
         expect(
             withinFilter.filter({zoom: 3}, {type: 1, geometry: [[getPointFromLngLat(2, 2, canonical)]]} as Feature, canonical)
         ).toBe(true);
@@ -179,14 +220,14 @@ describe('convert legacy filters to expressions', () => {
                 ['LineString', 'Point', 'Polygon'],
                 true,
                 false
-            ] as FilterSpecification,
+            ],
             [
                 'match',
                 ['get', 'type'],
                 ['island'],
                 true,
                 false
-            ] as FilterSpecification
+            ]
         ];
 
         const converted = convertFilter(filter);

package/src/style-spec/feature_filter/index.ts

@@ -2,6 +2,7 @@ import {createExpression} from '../expression';
 import type {GlobalProperties, Feature} from '../expression';
 import type {CanonicalTileID} from '../../source/tile_id';
 import {StylePropertySpecification} from '../style-spec';
+import {ExpressionFilterSpecification} from '../types.g';
 
 type FilterExpression = (
     globalProperties: GlobalProperties,
@@ -17,7 +18,7 @@ export type FeatureFilter = {
 export default createFilter;
 export {isExpressionFilter};
 
-function isExpressionFilter(filter: any) {
+function isExpressionFilter(filter: any): filter is ExpressionFilterSpecification {
     if (filter === true || filter === false) {
         return true;
     }