@mapbox/mapbox-gl-style-spec 13.28.0 → 14.0.0-beta.2

package/expression/index.js

@@ -15,7 +15,12 @@ import definitions from './definitions/index.js';
 import * as isConstant from './is_constant.js';
 import RuntimeError from './runtime_error.js';
 import {success, error} from '../util/result.js';
-import {supportsPropertyExpression, supportsZoomExpression, supportsInterpolation} from '../util/properties.js';
+import {
+    supportsPropertyExpression,
+    supportsZoomExpression,
+    supportsLightExpression,
+    supportsInterpolation
+} from '../util/properties.js';
 
 import type {Type, EvaluationKind} from './types.js';
 import type {Value} from './values.js';
@@ -29,25 +34,27 @@ import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../source/tile_id.js';
 import type {FeatureDistanceData} from '../feature_filter/index.js';
 
-export type Feature = {
-    +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon',
-    +id?: number | null,
-    +properties: {[_: string]: any},
-    +patterns?: {[_: string]: string},
-    +geometry?: Array<Array<Point>>
-};
+export interface Feature {
+    +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
+    +id?: number | null;
+    +properties: {[_: string]: any};
+    +patterns?: {[_: string]: string};
+    +geometry?: Array<Array<Point>>;
+}
 
 export type FeatureState = {[_: string]: any};
 
-export type GlobalProperties = $ReadOnly<{
+export interface GlobalProperties {
     zoom: number,
     pitch?: number,
     heatmapDensity?: number,
     lineProgress?: number,
+    rasterValue?: number,
     skyRadialProgress?: number,
-    isSupportedScript?: (_: string) => boolean,
-    accumulated?: Value
-}>;
+    +isSupportedScript?: (_: string) => boolean,
+    accumulated?: Value,
+    brightness?: number
+}
 
 export class StyleExpression {
     expression: Expression;
@@ -57,10 +64,10 @@ export class StyleExpression {
     _warningHistory: {[key: string]: boolean};
     _enumValues: ?{[_: string]: any};
 
-    constructor(expression: Expression, propertySpec: ?StylePropertySpecification) {
+    constructor(expression: Expression, propertySpec: ?StylePropertySpecification, options?: ?Map<string, Expression>) {
         this.expression = expression;
         this._warningHistory = {};
-        this._evaluator = new EvaluationContext();
+        this._evaluator = new EvaluationContext(options);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
     }
@@ -124,8 +131,8 @@ export function isExpression(expression: mixed): boolean {
  *
  * @private
  */
-export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification): Result<StyleExpression, Array<ParsingError>> {
-    const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
+export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification, options?: ?Map<string, Expression>): Result<StyleExpression, Array<ParsingError>> {
+    const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined, undefined, undefined, options);
 
     // For string-valued properties, coerce to string at the top level rather than asserting.
     const parsed = parser.parse(expression, undefined, undefined, undefined,
@@ -136,18 +143,22 @@ export function createExpression(expression: mixed, propertySpec: ?StyleProperty
         return error(parser.errors);
     }
 
-    return success(new StyleExpression(parsed, propertySpec));
+    return success(new StyleExpression(parsed, propertySpec, options));
 }
 
 export class ZoomConstantExpression<Kind: EvaluationKind> {
     kind: Kind;
     isStateDependent: boolean;
+    isConfigDependent: boolean;
     _styleExpression: StyleExpression;
+    isLightConstant: ?boolean;
 
-    constructor(kind: Kind, expression: StyleExpression) {
+    constructor(kind: Kind, expression: StyleExpression, isLightConstant: ?boolean) {
         this.kind = kind;
         this._styleExpression = expression;
+        this.isLightConstant = isLightConstant;
         this.isStateDependent = kind !== ('constant': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.isConfigDependent = !isConstant.isConfigConstant(expression.expression);
     }
 
     evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
@@ -163,15 +174,19 @@ export class ZoomDependentExpression<Kind: EvaluationKind> {
     kind: Kind;
     zoomStops: Array<number>;
     isStateDependent: boolean;
+    isLightConstant: ?boolean;
+    isConfigDependent: boolean;
 
     _styleExpression: StyleExpression;
     interpolationType: ?InterpolationType;
 
-    constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType) {
+    constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType, isLightConstant: ?boolean) {
         this.kind = kind;
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
         this.isStateDependent = kind !== ('camera': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.isLightConstant = isLightConstant;
+        this.isConfigDependent = !isConstant.isConfigConstant(expression.expression);
         this.interpolationType = interpolationType;
     }
 
@@ -192,33 +207,40 @@ export class ZoomDependentExpression<Kind: EvaluationKind> {
     }
 }
 
-export type ConstantExpression = {
+export type ConstantExpression = interface {
     kind: 'constant',
+    isConfigDependent: boolean,
     +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
 }
 
-export type SourceExpression = {
+export type SourceExpression = interface {
     kind: 'source',
     isStateDependent: boolean,
+    isLightConstant: ?boolean;
+    isConfigDependent: boolean,
     +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
 };
 
-export type CameraExpression = {
+export type CameraExpression = interface {
     kind: 'camera',
+    isStateDependent: boolean,
+    isConfigDependent: boolean,
     +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
     +interpolationFactor: (input: number, lower: number, upper: number) => number,
     zoomStops: Array<number>,
     interpolationType: ?InterpolationType
 };
 
-export type CompositeExpression = {
-    kind: 'composite',
-    isStateDependent: boolean,
-    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
-    +interpolationFactor: (input: number, lower: number, upper: number) => number,
-    zoomStops: Array<number>,
-    interpolationType: ?InterpolationType
-};
+export interface CompositeExpression {
+    kind: 'composite';
+    isStateDependent: boolean;
+    isLightConstant: ?boolean;
+    isConfigDependent: boolean;
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any;
+    +interpolationFactor: (input: number, lower: number, upper: number) => number;
+    zoomStops: Array<number>;
+    interpolationType: ?InterpolationType;
+}
 
 export type StylePropertyExpression =
     | ConstantExpression
@@ -226,8 +248,8 @@ export type StylePropertyExpression =
     | CameraExpression
     | CompositeExpression;
 
-export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification): Result<StylePropertyExpression, Array<ParsingError>> {
-    expression = createExpression(expression, propertySpec);
+export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification, options?: ?Map<string, Expression>): Result<StylePropertyExpression, Array<ParsingError>> {
+    expression = createExpression(expression, propertySpec, options);
     if (expression.result === 'error') {
         return expression;
     }
@@ -244,9 +266,15 @@ export function createPropertyExpression(expression: mixed, propertySpec: StyleP
         return error([new ParsingError('', 'zoom expressions not supported')]);
     }
 
+    const isLightConstant = isConstant.isGlobalPropertyConstant(parsed, ['measure-light']);
+    if (!isLightConstant && !supportsLightExpression(propertySpec)) {
+        return error([new ParsingError('', 'measure-light expression not supported')]);
+    }
+
+    const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
     const zoomCurve = findZoomCurve(parsed);
-    if (!zoomCurve && !isZoomConstant) {
-        return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+    if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
+        return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression, or in the properties of atmosphere.')]);
     } else if (zoomCurve instanceof ParsingError) {
         return error([zoomCurve]);
     } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
@@ -255,15 +283,19 @@ export function createPropertyExpression(expression: mixed, propertySpec: StyleP
 
     if (!zoomCurve) {
         return success(isFeatureConstant ?
-            (new ZoomConstantExpression('constant', expression.value): ConstantExpression) :
-            (new ZoomConstantExpression('source', expression.value): SourceExpression));
+            // $FlowFixMe[method-unbinding]
+            (new ZoomConstantExpression('constant', expression.value, isLightConstant): ConstantExpression) :
+            // $FlowFixMe[method-unbinding]
+            (new ZoomConstantExpression('source', expression.value, isLightConstant): SourceExpression));
     }
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
     return success(isFeatureConstant ?
-        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType): CameraExpression) :
-        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType): CompositeExpression));
+        // $FlowFixMe[method-unbinding]
+        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant): CameraExpression) :
+        // $FlowFixMe[method-unbinding]
+        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant): CompositeExpression));
 }
 
 import {isFunction, createFunction} from '../function/index.js';
@@ -298,12 +330,12 @@ export class StylePropertyFunction<T> {
     }
 }
 
-export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification): StylePropertyExpression {
+export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification, options?: ?Map<string, Expression>): StylePropertyExpression {
     if (isFunction(value)) {
         return (new StylePropertyFunction(value, specification): any);
 
-    } else if (isExpression(value)) {
-        const expression = createPropertyExpression(value, specification);
+    } else if (isExpression(value) || (Array.isArray(value) && value.length > 0)) {
+        const expression = createPropertyExpression(value, specification, options);
         if (expression.result === 'error') {
             // this should have been caught in validation
             throw new Error(expression.value.map(err => `${err.key}: ${err.message}`).join(', '));
@@ -317,6 +349,7 @@ export function normalizePropertyExpression<T>(value: PropertyValueSpecification
         }
         return {
             kind: 'constant',
+            isConfigDependent: false,
             evaluate: () => constant
         };
     }
@@ -353,8 +386,6 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
         const childResult = findZoomCurve(child);
         if (childResult instanceof ParsingError) {
             result = childResult;
-        } else if (!result && childResult) {
-            result = new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
         } else if (result && childResult && result !== childResult) {
             result = new ParsingError('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
         }

package/expression/is_constant.js

@@ -2,6 +2,7 @@
 
 import CompoundExpression from './compound_expression.js';
 import Within from './definitions/within.js';
+import Distance from './definitions/distance.js';
 import type {Expression} from './expression.js';
 
 function isFeatureConstant(e: Expression): boolean {
@@ -27,6 +28,10 @@ function isFeatureConstant(e: Expression): boolean {
         return false;
     }
 
+    if (e instanceof Distance) {
+        return false;
+    }
+
     let result = true;
     e.eachChild(arg => {
         if (result && !isFeatureConstant(arg)) { result = false; }
@@ -47,6 +52,19 @@ function isStateConstant(e: Expression): boolean {
     return result;
 }
 
+function isConfigConstant(e: Expression): boolean {
+    if (e instanceof CompoundExpression) {
+        if (e.name === 'config') {
+            return false;
+        }
+    }
+    let result = true;
+    e.eachChild(arg => {
+        if (result && !isConfigConstant(arg)) { result = false; }
+    });
+    return result;
+}
+
 function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boolean {
     if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) { return false; }
     let result = true;
@@ -56,4 +74,4 @@ function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boo
     return result;
 }
 
-export {isFeatureConstant, isGlobalPropertyConstant, isStateConstant};
+export {isFeatureConstant, isGlobalPropertyConstant, isStateConstant, isConfigConstant};

package/expression/parsing_context.js

@@ -10,6 +10,7 @@ import EvaluationContext from './evaluation_context.js';
 import CompoundExpression from './compound_expression.js';
 import CollatorExpression from './definitions/collator.js';
 import Within from './definitions/within.js';
+import Distance from './definitions/distance.js';
 import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant.js';
 import Var from './definitions/var.js';
 
@@ -26,6 +27,7 @@ class ParsingContext {
     key: string;
     scope: Scope;
     errors: Array<ParsingError>;
+    options: ?Map<string, Expression>;
 
     // The expected type of this expression. Provided only to allow Expression
     // implementations to infer argument types: Expression#parse() need not
@@ -38,7 +40,8 @@ class ParsingContext {
         path: Array<number> = [],
         expectedType: ?Type,
         scope: Scope = new Scope(),
-        errors: Array<ParsingError> = []
+        errors: Array<ParsingError> = [],
+        options?: ?Map<string, Expression>
     ) {
         this.registry = registry;
         this.path = path;
@@ -46,6 +49,7 @@ class ParsingContext {
         this.scope = scope;
         this.errors = errors;
         this.expectedType = expectedType;
+        this.options = options;
     }
 
     /**
@@ -62,7 +66,7 @@ class ParsingContext {
         bindings?: Array<[string, Expression]>,
         options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'} = {}
     ): ?Expression {
-        if (index) {
+        if (index || expectedType) {
             return this.concat(index, expectedType, bindings)._parse(expr, options);
         }
         return this._parse(expr, options);
@@ -73,7 +77,7 @@ class ParsingContext {
             expr = ['literal', expr];
         }
 
-        function annotate(parsed, type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
+        function annotate(parsed: Expression, type: Type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
             if (typeAnnotation === 'assert') {
                 return new Assertion(type, [parsed]);
             } else if (typeAnnotation === 'coerce') {
@@ -88,13 +92,7 @@ class ParsingContext {
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
             }
 
-            const op = expr[0];
-            if (typeof op !== 'string') {
-                this.error(`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`, 0);
-                return null;
-            }
-
-            const Expr = this.registry[op];
+            const Expr = typeof expr[0] === 'string' ? this.registry[expr[0]] : undefined;
             if (Expr) {
                 let parsed = Expr.parse(expr, this);
                 if (!parsed) return null;
@@ -125,7 +123,7 @@ class ParsingContext {
                 // parsed/compiled result. Expressions that expect an image should
                 // not be resolved here so we can later get the available images.
                 if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
-                    const ec = new EvaluationContext();
+                    const ec = new EvaluationContext(this.options);
                     try {
                         parsed = new Literal(parsed.type, parsed.evaluate(ec));
                     } catch (e) {
@@ -137,7 +135,8 @@ class ParsingContext {
                 return parsed;
             }
 
-            return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+            // Try to parse as array
+            return Coercion.parse(['to-array', expr], this);
         } else if (typeof expr === 'undefined') {
             return this.error(`'undefined' value invalid. Use null instead.`);
         } else if (typeof expr === 'object') {
@@ -155,7 +154,7 @@ class ParsingContext {
      * parsing, is copied by reference rather than cloned.
      * @private
      */
-    concat(index: number, expectedType?: ?Type, bindings?: Array<[string, Expression]>): ParsingContext {
+    concat(index: ?number, expectedType?: ?Type, bindings?: Array<[string, Expression]>): ParsingContext {
         const path = typeof index === 'number' ? this.path.concat(index) : this.path;
         const scope = bindings ? this.scope.concat(bindings) : this.scope;
         return new ParsingContext(
@@ -163,7 +162,8 @@ class ParsingContext {
             path,
             expectedType || null,
             scope,
-            this.errors
+            this.errors,
+            this.options
         );
     }
 
@@ -197,12 +197,16 @@ function isConstant(expression: Expression) {
         return isConstant(expression.boundExpression);
     } else if (expression instanceof CompoundExpression && expression.name === 'error') {
         return false;
+    } else if (expression instanceof CompoundExpression && expression.name === 'config') {
+        return false;
     } else if (expression instanceof CollatorExpression) {
         // Although the results of a Collator expression with fixed arguments
         // generally shouldn't change between executions, we can't serialize them
         // as constant expressions because results change based on environment.
         return false;
-    } else if (expression instanceof Within) {
+    }  else if (expression instanceof Within) {
+        return false;
+    } else if (expression instanceof Distance) {
         return false;
     }
 
@@ -229,5 +233,5 @@ function isConstant(expression: Expression) {
     }
 
     return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center']);
+        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light']);
 }

package/expression/types/formatted.js

@@ -33,7 +33,7 @@ export default class Formatted {
     isEmpty(): boolean {
         if (this.sections.length === 0) return true;
         return !this.sections.some(section => section.text.length !== 0 ||
-                                             (section.image && section.image.name.length !== 0));
+                                             (section.image && section.image.namePrimary.length !== 0));
     }
 
     static factory(text: Formatted | string): Formatted {
@@ -53,7 +53,7 @@ export default class Formatted {
         const serialized: Array<mixed> = ["format"];
         for (const section of this.sections) {
             if (section.image) {
-                serialized.push(["image", section.image.name]);
+                serialized.push(["image", section.image.namePrimary]);
                 continue;
             }
             serialized.push(section.text);

package/expression/types/resolved_image.js

@@ -1,29 +1,40 @@
 // @flow
 
 export type ResolvedImageOptions = {
-    name: string,
+    namePrimary: string,
+    nameSecondary: ?string,
     available: boolean
 };
 
 export default class ResolvedImage {
-    name: string;
+    namePrimary: string;
+    nameSecondary: ?string;
     available: boolean;
 
     constructor(options: ResolvedImageOptions) {
-        this.name = options.name;
+        this.namePrimary = options.namePrimary;
+        if (options.nameSecondary) {
+            this.nameSecondary = options.nameSecondary;
+        }
         this.available = options.available;
     }
 
     toString(): string {
-        return this.name;
+        if (this.nameSecondary) {
+            return `[${this.namePrimary},${this.nameSecondary}]`;
+        }
+        return this.namePrimary;
     }
 
-    static fromString(name: string): ResolvedImage | null {
-        if (!name) return null; // treat empty values as no image
-        return new ResolvedImage({name, available: false});
+    static fromString(namePrimary: string, nameSecondary: ?string): ResolvedImage | null {
+        if (!namePrimary) return null; // treat empty values as no image
+        return new ResolvedImage({namePrimary, nameSecondary, available: false});
     }
 
     serialize(): Array<string> {
-        return ["image", this.name];
+        if (this.nameSecondary) {
+            return ["image", this.namePrimary, this.nameSecondary];
+        }
+        return ["image", this.namePrimary];
     }
 }

package/expression/types.js

@@ -26,7 +26,8 @@ export type Type =
     ErrorTypeT |
     CollatorTypeT |
     FormattedTypeT |
-    ResolvedImageTypeT
+    ResolvedImageTypeT |
+    ArrayType;
 
 export type ArrayType = {
     kind: 'array',

package/expression/values.js

@@ -29,6 +29,31 @@ export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string |
     return null;
 }
 
+export function validateHSLA(h: mixed, s: mixed, l: mixed, a?: mixed): string | null {
+    if (!(
+        typeof h === 'number' && h >= 0 && h <= 360
+    )) {
+        const value = typeof a === 'number' ? [h, s, l, a] : [h, s, l];
+        return `Invalid hsla value [${value.join(', ')}]: 'h' must be between 0 and 360.`;
+    }
+
+    if (!(
+        typeof s === 'number' && s >= 0 && s <= 100 &&
+        typeof l === 'number' && l >= 0 && l <= 100
+    )) {
+        const value = typeof a === 'number' ? [h, s, l, a] : [h, s, l];
+        return `Invalid hsla value [${value.join(', ')}]: 's', and 'l' must be between 0 and 100.`;
+    }
+
+    if (!(
+        typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1)
+    )) {
+        return `Invalid hsla value [${[h, s, l, a].join(', ')}]: 'a' must be between 0 and 1.`;
+    }
+
+    return null;
+}
+
 export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | $ReadOnlyArray<Value> | { +[string]: Value }
 
 export function isValue(mixed: mixed): boolean {

package/feature_filter/convert.js

@@ -161,7 +161,7 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
     return [op, get, value];
 }
 
-function convertInOp(property: string, values: Array<any>, negate = false) {
+function convertInOp(property: string, values: Array<any>, negate: boolean = false) {
     if (values.length === 0) return negate;
 
     let get;

package/feature_filter/index.js

@@ -73,6 +73,7 @@ function createFilter(filter: any, layerType?: string = 'fill'): FeatureFilter {
     }
 
     if (!isExpressionFilter(filter)) {
+        // $FlowFixMe[incompatible-call]
         filter = convertFilter(filter);
     }
     const filterExp = ((filter: any): string[] | string | boolean);
@@ -253,13 +254,13 @@ function collapsedExpression(expression: any): any {
 }
 
 // Comparison function to sort numbers and strings
-function compare(a, b) {
+function compare(a: number, b: number) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
 
-function geometryNeeded(filter) {
+function geometryNeeded(filter: Array<any> | boolean) {
     if (!Array.isArray(filter)) return false;
-    if (filter[0] === 'within') return true;
+    if (filter[0] === 'within' || filter[0] === 'distance') return true;
     for (let index = 1; index < filter.length; index++) {
         if (geometryNeeded(filter[index])) return true;
     }
@@ -284,7 +285,6 @@ function convertFilter(filter: ?Array<any>): mixed {
         op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
         op === 'has' ? convertHasOp(filter[1]) :
         op === '!has' ? convertNegation(convertHasOp(filter[1])) :
-        op === 'within' ? filter :
         true;
     return converted;
 }

package/flow-typed/cheap-ruler.js

@@ -0,0 +1,25 @@
+// @flow strict
+
+declare module 'cheap-ruler' {
+    import type { GeoJSONPosition} from '@mapbox/geojson-types';
+    declare export default class CheapRuler {
+        kx: number;
+        ky: number;
+        constructor(lat: number, units: string): CheapRuler;
+        distance(a: GeoJSONPosition, b: GeoJSONPosition): number;
+        bearing(a: GeoJSONPosition, b: GeoJSONPosition): number;
+        destination(p: GeoJSONPosition, dist: number , bearing: number): GeoJSONPosition;
+        offset(p: GeoJSONPosition, dx: number, dy: number): GeoJSONPosition;
+        lineDistance(points: Array<GeoJSONPosition>): number;
+        area(polygon: Array<Array<GeoJSONPosition>>): number;
+        along(line: Array<GeoJSONPosition>, dist: number): GeoJSONPosition;
+        pointToSegmentDistance(p: GeoJSONPosition, a: GeoJSONPosition, b: GeoJSONPosition): number;
+        pointOnLine(line: Array<GeoJSONPosition>, p: GeoJSONPosition): Object;
+        lineSlice(start: GeoJSONPosition, stop: GeoJSONPosition, line: Array<GeoJSONPosition>): Array<GeoJSONPosition>;
+        lineSliceAlong(start: GeoJSONPosition, stop: GeoJSONPosition, line: Array<GeoJSONPosition>): Array<GeoJSONPosition>;
+        bufferPoint(p: GeoJSONPosition, buffer: number): GeoJSONPosition;
+        bufferBBox(bbox: GeoJSONPosition, buffer: number): GeoJSONPosition;
+        insideBBox(p: GeoJSONPosition, bbox: GeoJSONPosition): boolean;
+
+    }
+}

package/flow-typed/geojson.js

@@ -1,9 +1,10 @@
 // @flow strict
 
-type GeoJSONPosition = [number, number] | [number, number, number];
 type Geometry<T, C> = { type: T, coordinates: C }
 
 declare module "@mapbox/geojson-types" {
+    declare export type GeoJSONPosition = [number, number] | [number, number, number];
+
     declare export type GeoJSONPoint = Geometry<'Point', GeoJSONPosition>;
     declare export type GeoJSONMultiPoint = Geometry<'MultiPoint', Array<GeoJSONPosition>>;
 
@@ -27,12 +28,12 @@ declare module "@mapbox/geojson-types" {
         geometries: Array<GeoJSONGeometry>
     };
 
-    declare export type GeoJSONFeature = {
-        type: 'Feature',
-        geometry: ?GeoJSONGeometry,
-        properties: ?{},
-        id?: number | string
-    };
+    declare export interface GeoJSONFeature {
+        type: 'Feature';
+        geometry: ?GeoJSONGeometry;
+        properties: ?{};
+        id?: number | string;
+    }
 
     declare export type GeoJSONFeatureCollection = {
         type: 'FeatureCollection',