@mapbox/mapbox-gl-style-spec 14.6.0 → 14.7.0

package/expression/compound_expression.ts

@@ -1,9 +1,8 @@
 import {toString} from './types';
-
 import ParsingContext from './parsing_context';
-import EvaluationContext from './evaluation_context';
 import assert from 'assert';
 
+import type EvaluationContext from './evaluation_context';
 import type {Expression, ExpressionRegistry} from './expression';
 import type {Type} from './types';
 import type {Value} from './values';

package/expression/definitions/assertion.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import {
     ObjectType,
     ValueType,
@@ -83,7 +82,7 @@ class Assertion implements Expression {
         return new Assertion(type, parsed);
     }
 
-    evaluate(ctx: EvaluationContext): any | null {
+    evaluate(ctx: EvaluationContext): any {
         for (let i = 0; i < this.args.length; i++) {
             const value = this.args[i].evaluate(ctx);
             const error = checkSubtype(this.type, typeOf(value));

package/expression/definitions/at.ts

@@ -1,5 +1,4 @@
 import {array, ValueType, NumberType} from '../types';
-
 import RuntimeError from '../runtime_error';
 
 import type {Expression, SerializedExpression} from '../expression';

package/expression/definitions/case.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import {BooleanType} from '../types';
 
 import type {Expression, SerializedExpression} from '../expression';

package/expression/definitions/coalesce.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import {checkSubtype, ValueType} from '../types';
 import ResolvedImage from '../types/resolved_image';
 
@@ -50,7 +49,7 @@ class Coalesce implements Expression {
             new Coalesce((outputType as any), parsedArgs);
     }
 
-    evaluate(ctx: EvaluationContext): any | null {
+    evaluate(ctx: EvaluationContext): any {
         let result = null;
         let argCount = 0;
         let firstImage;

package/expression/definitions/coercion.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 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';
@@ -7,12 +6,12 @@ import Formatted from '../types/formatted';
 import FormatExpression from '../definitions/format';
 import ImageExpression from '../definitions/image';
 import ResolvedImage from '../types/resolved_image';
+import getType from '../../util/get_type';
 
 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,

package/expression/definitions/collator.ts

@@ -29,17 +29,19 @@ export default class CollatorExpression implements Expression {
         // @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(
-            options['case-sensitive'] === undefined ? false : options['case-sensitive'], 1, BooleanType);
+        const caseSensitive = options['case-sensitive'] === undefined ?
+            context.parse(false, 1, BooleanType) :
+            context.parseObjectValue(options['case-sensitive'], 1, 'case-sensitive', BooleanType);
         if (!caseSensitive) return null;
 
-        const diacriticSensitive = context.parse(
-            options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'], 1, BooleanType);
+        const diacriticSensitive = options['diacritic-sensitive'] === undefined ?
+            context.parse(false, 1, BooleanType) :
+            context.parseObjectValue(options['diacritic-sensitive'], 1, 'diacritic-sensitive', BooleanType);
         if (!diacriticSensitive) return null;
 
         let locale = null;
         if (options['locale']) {
-            locale = context.parse(options['locale'], 1, StringType);
+            locale = context.parseObjectValue(options['locale'], 1, 'locale', StringType);
             if (!locale) return null;
         }
 

package/expression/definitions/distance.ts

@@ -2,10 +2,10 @@ import {isValue} from '../values';
 import {NumberType} from '../types';
 import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
 import CheapRuler from "cheap-ruler";
-import Point from "@mapbox/point-geometry";
 import TinyQueue from "tinyqueue";
 import EXTENT from '../../data/extent';
 
+import type Point from "@mapbox/point-geometry";
 import type ParsingContext from '../parsing_context';
 import type {BBox} from '../../util/geometry_util';
 import type {Type} from '../types';

package/expression/definitions/format.ts

@@ -55,19 +55,19 @@ export default class FormatExpression implements Expression {
 
                 let scale = null;
                 if (arg['font-scale']) {
-                    scale = context.parse(arg['font-scale'], 1, NumberType);
+                    scale = context.parseObjectValue(arg['font-scale'], i, 'font-scale', NumberType);
                     if (!scale) return null;
                 }
 
                 let font = null;
                 if (arg['text-font']) {
-                    font = context.parse(arg['text-font'], 1, array(StringType));
+                    font = context.parseObjectValue(arg['text-font'], i, 'text-font', array(StringType));
                     if (!font) return null;
                 }
 
                 let textColor = null;
                 if (arg['text-color']) {
-                    textColor = context.parse(arg['text-color'], 1, ColorType);
+                    textColor = context.parseObjectValue(arg['text-color'], i, 'text-color', ColorType);
                     if (!textColor) return null;
                 }
 
@@ -76,7 +76,7 @@ export default class FormatExpression implements Expression {
                 lastExpression.font = font;
                 lastExpression.textColor = textColor;
             } else {
-                const content = context.parse(args[i], 1, ValueType);
+                const content = context.parse(args[i], i, ValueType);
                 if (!content) return null;
 
                 const kind = content.type.kind;

package/expression/definitions/index.ts

@@ -10,7 +10,6 @@ import {
     array,
     toString as typeToString,
 } from '../types';
-
 import {typeOf, Color, validateRGBA, validateHSLA, toString as valueToString} from '../values';
 import CompoundExpression from '../compound_expression';
 import RuntimeError from '../runtime_error';

package/expression/definitions/interpolate.ts

@@ -1,11 +1,10 @@
 import UnitBezier from '@mapbox/unitbezier';
-
 import * as interpolate from '../../util/interpolate';
 import {toString, NumberType, ColorType} from '../types';
 import {findStopLessThanOrEqualTo} from '../stops';
 import {hcl, lab} from '../../util/color_spaces';
-import Color from '../../util/color';
 
+import type Color from '../../util/color';
 import type {Stops} from '../stops';
 import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';

package/expression/definitions/length.ts

@@ -1,5 +1,4 @@
 import {NumberType, toString} from '../types';
-
 import {typeOf} from '../values';
 import RuntimeError from '../runtime_error';
 
@@ -32,7 +31,7 @@ class Length implements Expression {
         return new Length(input);
     }
 
-    evaluate(ctx: EvaluationContext): any | number {
+    evaluate(ctx: EvaluationContext): number {
         const input = this.input.evaluate(ctx);
         if (typeof input === 'string') {
             return input.length;

package/expression/definitions/match.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import {typeOf} from '../values';
 import {ValueType} from '../types';
 

package/expression/definitions/number_format.ts

@@ -44,31 +44,31 @@ export default class NumberFormat implements Expression {
 
         let locale = null;
         if (options['locale']) {
-            locale = context.parse(options['locale'], 1, StringType);
+            locale = context.parseObjectValue(options['locale'], 2, 'locale', StringType);
             if (!locale) return null;
         }
 
         let currency = null;
         if (options['currency']) {
-            currency = context.parse(options['currency'], 1, StringType);
+            currency = context.parseObjectValue(options['currency'], 2, 'currency', StringType);
             if (!currency) return null;
         }
 
         let unit = null;
         if (options['unit']) {
-            unit = context.parse(options['unit'], 1, StringType);
+            unit = context.parseObjectValue(options['unit'], 2, 'unit', StringType);
             if (!unit) return null;
         }
 
         let minFractionDigits = null;
         if (options['min-fraction-digits']) {
-            minFractionDigits = context.parse(options['min-fraction-digits'], 1, NumberType);
+            minFractionDigits = context.parseObjectValue(options['min-fraction-digits'], 2, 'min-fraction-digits', NumberType);
             if (!minFractionDigits) return null;
         }
 
         let maxFractionDigits = null;
         if (options['max-fraction-digits']) {
-            maxFractionDigits = context.parse(options['max-fraction-digits'], 1, NumberType);
+            maxFractionDigits = context.parseObjectValue(options['max-fraction-digits'], 2, 'max-fraction-digits', NumberType);
             if (!maxFractionDigits) return null;
         }
 

package/expression/definitions/step.ts

@@ -1,5 +1,4 @@
 import {NumberType} from '../types';
-
 import {findStopLessThanOrEqualTo} from '../stops';
 
 import type {Stops} from '../stops';

package/expression/definitions/within.ts

@@ -1,13 +1,13 @@
 import {isValue} from '../values';
-import type {Type} from '../types';
 import {BooleanType} from '../types';
+import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
+
+import type {Type} from '../types';
 import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../types/tile_id';
-
-import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
 import type {BBox} from '../../util/geometry_util';
 
 type GeoJSONPolygons = GeoJSON.Polygon | GeoJSON.MultiPolygon;

package/expression/expression.ts

@@ -7,14 +7,14 @@ export type SerializedExpression = Array<unknown> | Array<string> | string | num
 export interface Expression {
     readonly type: Type;
     value?: any;
-    evaluate(ctx: EvaluationContext): any;
-    eachChild(fn: (arg1: Expression) => void): void;
+    evaluate: (ctx: EvaluationContext) => any;
+    eachChild: (fn: (arg1: Expression) => void) => void;
     /**
       * Statically analyze the expression, attempting to enumerate possible outputs. Returns
       * false if the complete set of outputs is statically undecidable, otherwise true.
       */
-    outputDefined(): boolean;
-    serialize(): SerializedExpression;
+    outputDefined: () => boolean;
+    serialize: () => SerializedExpression;
 }
 
 export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression | void;

package/expression/index.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import extend from '../util/extend';
 import ParsingError from './parsing_error';
 import ParsingContext from './parsing_context';
@@ -19,6 +18,9 @@ import {
     supportsLightExpression,
     supportsInterpolation
 } from '../util/properties';
+import {isFunction, createFunction} from '../function/index';
+import {Color} from './values';
+import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types';
 
 import type {Type, EvaluationKind} from './types';
 import type {Value} from './values';
@@ -34,7 +36,7 @@ import type {FeatureDistanceData} from '../feature_filter/index';
 import type {ConfigOptions} from '../types/config_options';
 
 export interface Feature {
-    readonly type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
+    readonly type: 0 | 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
     readonly id?: number | null;
     readonly properties: {
         [_: string]: any;
@@ -385,9 +387,6 @@ export function createPropertyExpression(
         (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant) as CompositeExpression));
 }
 
-import {isFunction, createFunction} from '../function/index';
-import {Color} from './values';
-
 // serialization wrapper for old-style stop functions normalized to the
 // expression interface
 export class StylePropertyFunction<T> {
@@ -494,8 +493,6 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
     return result;
 }
 
-import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types';
-
 function getExpectedType(spec: StylePropertySpecification): Type {
     const types = {
         color: ColorType,

package/expression/is_constant.ts

@@ -2,6 +2,7 @@ import CompoundExpression from './compound_expression';
 import Within from './definitions/within';
 import Distance from './definitions/distance';
 import Config from './definitions/config';
+
 import type {Expression} from './expression';
 
 function isFeatureConstant(e: Expression): boolean {

package/expression/parsing_context.ts

@@ -23,7 +23,7 @@ import type {ConfigOptions} from '../types/config_options';
  */
 class ParsingContext {
     registry: ExpressionRegistry;
-    path: Array<number>;
+    path: Array<number | string>;
     key: string;
     scope: Scope;
     errors: Array<ParsingError>;
@@ -38,7 +38,7 @@ class ParsingContext {
 
     constructor(
         registry: ExpressionRegistry,
-        path: Array<number> = [],
+        path: Array<number | string> = [],
         expectedType?: Type | null,
         scope: Scope = new Scope(),
         errors: Array<ParsingError> = [],
@@ -47,7 +47,7 @@ class ParsingContext {
     ) {
         this.registry = registry;
         this.path = path;
-        this.key = path.map(part => `[${part}]`).join('');
+        this.key = path.map(part => { if (typeof part === 'string') { return `['${part}']`; } return `[${part}]`; }).join('');
         this.scope = scope;
         this.errors = errors;
         this.expectedType = expectedType;
@@ -72,11 +72,32 @@ class ParsingContext {
         } = {},
     ): Expression | null | undefined {
         if (index || expectedType) {
-            return this.concat(index, expectedType, bindings)._parse(expr, options);
+            return this.concat(index, null, expectedType, bindings)._parse(expr, options);
         }
         return this._parse(expr, options);
     }
 
+    /**
+     * @param expr the JSON expression to parse
+     * @param index the optional argument index if parent object being is an argument of another expression
+     * @param key key of parent object being parsed
+     * @param options
+     * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+     * @private
+     */
+    parseObjectValue(
+        expr: unknown,
+        index: number,
+        key: string,
+        expectedType?: Type | null,
+        bindings?: Array<[string, Expression]>,
+        options: {
+            typeAnnotation?: 'assert' | 'coerce' | 'omit';
+        } = {},
+    ): Expression | null | undefined {
+        return this.concat(index, key, expectedType, bindings)._parse(expr, options);
+    }
+
     _parse(
         expr: unknown,
         options: {
@@ -170,10 +191,12 @@ class ParsingContext {
      */
     concat(
         index?: number | null,
+        key?: string | null,
         expectedType?: Type | null,
         bindings?: Array<[string, Expression]>,
     ): ParsingContext {
-        const path = typeof index === 'number' ? this.path.concat(index) : this.path;
+        let path = typeof index === 'number' ? this.path.concat(index) : this.path;
+        path = typeof key === 'string' ? path.concat(key) : path;
         const scope = bindings ? this.scope.concat(bindings) : this.scope;
         return new ParsingContext(
             this.registry,

package/expression/values.ts

@@ -1,5 +1,4 @@
 import assert from 'assert';
-
 import Color from '../util/color';
 import Collator from './types/collator';
 import Formatted from './types/formatted';
@@ -111,7 +110,7 @@ export function typeOf(value: Value): Type {
         return ResolvedImageType;
     } else if (Array.isArray(value)) {
         const length = value.length;
-        let itemType: Type | typeof undefined;
+        let itemType: Type;
 
         for (const item of value) {
             const t = typeOf(item);

package/feature_filter/index.ts

@@ -1,12 +1,13 @@
-import type Point from '@mapbox/point-geometry';
 import latest from '../reference/latest';
-
 import {deepUnbundle} from '../util/unbundle_jsonlint';
 import {createExpression} from '../expression/index';
 import {isFeatureConstant} from '../expression/is_constant';
+
+import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../types/tile_id';
 import type {GlobalProperties, Feature} from '../expression/index';
 import type {FilterSpecification, ExpressionSpecification} from '../types';
+import type {ConfigOptions} from '../types/config_options';
 
 export type FeatureDistanceData = {
     bearing: [number, number];
@@ -82,7 +83,7 @@ function isExpressionFilter(filter: unknown): boolean {
  * @param {string} layerType the type of the layer this filter will be applied to.
  * @returns {Function} filter-evaluating function
  */
-function createFilter(filter?: FilterSpecification, layerType: string = 'fill'): FeatureFilter {
+function createFilter(filter?: FilterSpecification, scope: string = "", options: ConfigOptions | null = null, layerType: string = 'fill'): FeatureFilter {
     if (filter === null || filter === undefined) {
         return {filter: () => true, needGeometry: false, needFeature: false};
     }
@@ -109,7 +110,7 @@ ${JSON.stringify(filterExp, null, 2)}
 
     // Compile the static component of the filter
     const filterSpec = latest[`filter_${layerType}`];
-    const compiledStaticFilter = createExpression(staticFilter, filterSpec);
+    const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
 
     let filterFunc = null;
     if (compiledStaticFilter.result === 'error') {
@@ -123,7 +124,7 @@ ${JSON.stringify(filterExp, null, 2)}
     let dynamicFilterFunc = null;
     let needFeature = null;
     if (staticFilter !== filterExp) {
-        const compiledDynamicFilter = createExpression(filterExp, filterSpec);
+        const compiledDynamicFilter = createExpression(filterExp, filterSpec, scope, options);
 
         if (compiledDynamicFilter.result === 'error') {
             throw new Error(compiledDynamicFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));

package/group_by_layout.ts

@@ -1,7 +1,7 @@
-import type {LayerSpecification} from './types';
-
 import refProperties from './util/ref_properties';
 
+import type {LayerSpecification} from './types';
+
 function stringify(obj: any) {
     if (typeof obj === 'number' || typeof obj === 'boolean' || typeof obj === 'string' || obj === undefined || obj === null)
         return JSON.stringify(obj);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.6.0",
+  "version": "14.7.0",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",