@mapbox/mapbox-gl-style-spec 14.7.1 → 14.8.0

package/expression/definitions/at.ts

@@ -40,15 +40,28 @@ class At implements Expression {
             throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);
         }
 
-        if (index >= array.length) {
+        if (index > array.length - 1) {
             throw new RuntimeError(`Array index out of bounds: ${index} > ${array.length - 1}.`);
         }
 
-        if (index !== Math.floor(index)) {
-            throw new RuntimeError(`Array index must be an integer, but found ${index} instead.`);
+        if (index === Math.floor(index)) {
+            return array[index];
         }
 
-        return array[index];
+        // Interpolation logic for non-integer indices
+        const lowerIndex = Math.floor(index);
+        const upperIndex = Math.ceil(index);
+
+        const lowerValue = array[lowerIndex];
+        const upperValue = array[upperIndex];
+
+        if (typeof lowerValue !== 'number' || typeof upperValue !== 'number') {
+            throw new RuntimeError(`Cannot interpolate between non-number values at index ${index}.`);
+        }
+
+        // Linear interpolation
+        const fraction = index - lowerIndex;
+        return lowerValue * (1 - fraction) + upperValue * fraction;
     }
 
     eachChild(fn: (_: Expression) => void) {

package/expression/definitions/distance.ts

@@ -80,20 +80,18 @@ function splitRange(range: IndexRange, isLine: boolean) {
 }
 
 function getBBox(pointSets: Array<GeoJSON.Position>, range: IndexRange) {
-    const bbox = [Infinity, Infinity, -Infinity, -Infinity];
+    const bbox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
     if (!isRangeSafe(range, pointSets.length)) return bbox;
     for (let i = range[0]; i <= range[1]; ++i) {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         updateBBox(bbox, pointSets[i]);
     }
     return bbox;
 }
 
 function getPolygonBBox(polygon: Array<Array<GeoJSON.Position>>) {
-    const bbox = [Infinity, Infinity, -Infinity, -Infinity];
+    const bbox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
     for (let i = 0; i < polygon.length; ++i) {
         for (let j = 0; j < polygon[i].length; ++j) {
-            // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
             updateBBox(bbox, polygon[i][j]);
         }
     }
@@ -263,11 +261,9 @@ function polygonIntersect(polygon1: Array<Array<GeoJSON.Position>>, polygon2: Ar
 function polygonToPolygonDistance(polygon1: Array<Array<GeoJSON.Position>>, polygon2: Array<Array<GeoJSON.Position>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
     const bbox1 = getPolygonBBox(polygon1);
     const bbox2 = getPolygonBBox(polygon2);
-    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     if (currentMiniDist !== Infinity && bboxToBBoxDistance(bbox1, bbox2, ruler) >= currentMiniDist) {
         return currentMiniDist;
     }
-    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     if (boxWithinBox(bbox1, bbox2)) {
         if (polygonIntersect(polygon1, polygon2)) return 0.0;
     } else if (polygonIntersect(polygon2, polygon1)) {
@@ -289,7 +285,6 @@ function polygonToPolygonDistance(polygon1: Array<Array<GeoJSON.Position>>, poly
 
 function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointSet1: Array<GeoJSON.Position>, pointSet2: Array<GeoJSON.Position>, r1: IndexRange | null, r2: IndexRange | null) {
     if (r1 === null || r2 === null) return;
-    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
     const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
     // Insert new pair to the queue if the bbox distance is less than miniDist, the pair with biggest distance will be at the top
     if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: r1, range2: r2});
@@ -330,12 +325,10 @@ function pointSetToPolygonDistance(pointSets: Array<GeoJSON.Position>, isLine: b
         } else {
             const newRanges = splitRange(range, isLine);
             if (newRanges[0] !== null) {
-                // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
                 const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[0]), polyBBox, ruler);
                 if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[0], range2: [0, 0]});
             }
             if (newRanges[1] !== null) {
-                // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
                 const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[1]), polyBBox, ruler);
                 if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[1], range2: [0, 0]});
             }
@@ -394,7 +387,6 @@ function pointSetToLinesDistance(pointSet: Array<GeoJSON.Position>, isLine: bool
     let dist = currentMiniDist;
     const bbox1 = getBBox(pointSet, [0, pointSet.length - 1]);
     for (const line of lines) {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (dist !== Infinity && bboxToBBoxDistance(bbox1, getBBox(line, [0, line.length - 1]), ruler) >= dist) continue;
         dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true /*isLine*/, ruler, dist));
         if (dist === 0.0) return dist;
@@ -406,7 +398,6 @@ function pointSetToPolygonsDistance(points: Array<GeoJSON.Position>, isLine: boo
     let dist = currentMiniDist;
     const bbox1 = getBBox(points, [0, points.length - 1]);
     for (const polygon of polygons) {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (dist !== Infinity && bboxToBBoxDistance(bbox1, getPolygonBBox(polygon), ruler) >= dist) continue;
         const tempDist = pointSetToPolygonDistance(points, isLine, polygon, ruler, dist);
         if (isNaN(tempDist)) return tempDist;

package/expression/definitions/within.ts

@@ -155,8 +155,8 @@ function getTileLines(geometry: Array<Array<Point>> | null | undefined, lineBBox
 }
 
 function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
-    const pointBBox = [Infinity, Infinity, -Infinity, -Infinity];
-    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const pointBBox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
 
     const canonical = ctx.canonicalID();
     if (!canonical) {
@@ -164,11 +164,8 @@ function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPo
     }
 
     if (polygonGeometry.type === 'Polygon') {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (!boxWithinBox(pointBBox, polyBBox)) return false;
 
         for (const point of tilePoints) {
@@ -176,11 +173,8 @@ function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPo
         }
     }
     if (polygonGeometry.type === 'MultiPolygon') {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (!boxWithinBox(pointBBox, polyBBox)) return false;
 
         for (const point of tilePoints) {
@@ -192,8 +186,8 @@ function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPo
 }
 
 function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
-    const lineBBox = [Infinity, Infinity, -Infinity, -Infinity];
-    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const lineBBox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
 
     const canonical = ctx.canonicalID();
     if (!canonical) {
@@ -201,11 +195,8 @@ function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPol
     }
 
     if (polygonGeometry.type === 'Polygon') {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (!boxWithinBox(lineBBox, polyBBox)) return false;
 
         for (const line of tileLines) {
@@ -213,11 +204,8 @@ function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPol
         }
     }
     if (polygonGeometry.type === 'MultiPolygon') {
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
-        // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'BBox'.
         if (!boxWithinBox(lineBBox, polyBBox)) return false;
 
         for (const line of tileLines) {
@@ -238,9 +226,8 @@ class Within implements Expression {
         this.geometries = geometries;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Within | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Within | void {
         if (args.length !== 2)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Within'.
             return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
         if (isValue(args[1])) {
             const geojson = (args[1] as any);
@@ -256,11 +243,10 @@ class Within implements Expression {
                 if (type === 'Polygon' || type === 'MultiPolygon') {
                     return new Within(geojson, geojson.geometry);
                 }
-            } else if (geojson.type  === 'Polygon' || geojson.type === 'MultiPolygon') {
+            } else if (geojson.type === 'Polygon' || geojson.type === 'MultiPolygon') {
                 return new Within(geojson, geojson);
             }
         }
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Within'.
         return context.error(`'within' expression requires valid geojson object that contains polygon geometry type.`);
     }
 

package/expression/index.ts

@@ -16,7 +16,8 @@ import {
     supportsPropertyExpression,
     supportsZoomExpression,
     supportsLightExpression,
-    supportsInterpolation
+    supportsInterpolation,
+    supportsLineProgressExpression
 } from '../util/properties';
 import {isFunction, createFunction} from '../function/index';
 import {Color} from './values';
@@ -71,6 +72,7 @@ export class StyleExpression {
     _defaultValue: Value;
     _warningHistory: {[key: string]: boolean};
     _enumValues?: {[_: string]: unknown};
+    configDependencies: Set<string>;
 
     constructor(expression: Expression, propertySpec?: StylePropertySpecification, scope?: string, options?: ConfigOptions) {
         this.expression = expression;
@@ -78,6 +80,7 @@ export class StyleExpression {
         this._evaluator = new EvaluationContext(scope, options);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
+        this.configDependencies = isConstant.getConfigDependencies(expression);
     }
 
     evaluateWithoutErrorHandling(
@@ -360,6 +363,11 @@ export function createPropertyExpression(
         return error([new ParsingError('', 'measure-light expression not supported')]);
     }
 
+    const isLineProgressConstant = isConstant.isGlobalPropertyConstant(parsed, ['line-progress']);
+    if (!isLineProgressConstant && !supportsLineProgressExpression(propertySpec)) {
+        return error([new ParsingError('', 'line-progress expression not supported')]);
+    }
+
     const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
@@ -371,7 +379,7 @@ export function createPropertyExpression(
     }
 
     if (!zoomCurve) {
-        return success(isFeatureConstant ?
+        return success((isFeatureConstant && isLineProgressConstant) ?
         // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
             (new ZoomConstantExpression('constant', expression.value, isLightConstant) as ConstantExpression) :
         // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
@@ -380,7 +388,7 @@ export function createPropertyExpression(
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
-    return success(isFeatureConstant ?
+    return success((isFeatureConstant && isLineProgressConstant) ?
     // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
         (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant) as CameraExpression) :
     // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.

package/expression/parsing_error.ts

@@ -1,6 +1,6 @@
 class ParsingError extends Error {
     key: string;
-    message: string;
+    override message: string;
     constructor(key: string, message: string) {
         super(message);
         this.message = message;

package/feature_filter/index.ts

@@ -2,6 +2,7 @@ import latest from '../reference/latest';
 import {deepUnbundle} from '../util/unbundle_jsonlint';
 import {createExpression} from '../expression/index';
 import {isFeatureConstant} from '../expression/is_constant';
+import assert from 'assert';
 
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../types/tile_id';
@@ -109,14 +110,18 @@ ${JSON.stringify(filterExp, null, 2)}
     }
 
     // Compile the static component of the filter
-    const filterSpec = latest[`filter_${layerType}`];
-    const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
-
     let filterFunc = null;
-    if (compiledStaticFilter.result === 'error') {
-        throw new Error(compiledStaticFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
-    } else {
-        filterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+    let filterSpec = null;
+    if (layerType !== 'background' && layerType !== 'sky' && layerType !== 'slot') {
+        filterSpec = latest[`filter_${layerType}`];
+        assert(filterSpec);
+        const compiledStaticFilter = createExpression(staticFilter, filterSpec, scope, options);
+
+        if (compiledStaticFilter.result === 'error') {
+            throw new Error(compiledStaticFilter.value.map(err => `${err.key}: ${err.message}`).join(', '));
+        } else {
+            filterFunc = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiledStaticFilter.value.evaluate(globalProperties, feature, {}, canonical);
+        }
     }
 
     // If the static component is not equal to the entire filter then we have a dynamic component

package/package.json

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