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

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

@@ -1,18 +1,16 @@
-// @flow
-
-import {isValue} from '../values.js';
-import type {Type} from '../types.js';
-import {BooleanType} from '../types.js';
-import type {Expression, SerializedExpression} from '../expression.js';
-import type ParsingContext from '../parsing_context.js';
-import type EvaluationContext from '../evaluation_context.js';
+import {isValue} from '../values';
+import type {Type} from '../types';
+import {BooleanType} 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 {GeoJSON, GeoJSONPosition, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
-import type {CanonicalTileID} from '../../../source/tile_id.js';
-import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util.js';
-import type {BBox} from '../../util/geometry_util.js';
+import type {CanonicalTileID} from '../../types/tile_id';
 
-type GeoJSONPolygons =| GeoJSONPolygon | GeoJSONMultiPolygon;
+import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
+import type {BBox} from '../../util/geometry_util';
+
+type GeoJSONPolygons = GeoJSON.Polygon | GeoJSON.MultiPolygon;
 
 const EXTENT = 8192;
 
@@ -24,21 +22,21 @@ function mercatorYfromLat(lat: number) {
     return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
 }
 
-function getTileCoordinates(p: GeoJSONPosition, canonical: CanonicalTileID) {
+function getTileCoordinates(p: GeoJSON.Position, canonical: CanonicalTileID) {
     const x = mercatorXfromLng(p[0]);
     const y = mercatorYfromLat(p[1]);
     const tilesAtZoom = Math.pow(2, canonical.z);
     return [Math.round(x * tilesAtZoom * EXTENT), Math.round(y * tilesAtZoom * EXTENT)];
 }
 
-function pointWithinPolygons(point: GeoJSONPosition, polygons: Array<Array<Array<GeoJSONPosition>>>) {
+function pointWithinPolygons(point: GeoJSON.Position, polygons: Array<Array<Array<GeoJSON.Position>>>) {
     for (let i = 0; i < polygons.length; i++) {
         if (pointWithinPolygon(point, polygons[i])) return true;
     }
     return false;
 }
 
-function lineIntersectPolygon(p1: GeoJSONPosition, p2: GeoJSONPosition, polygon: Array<Array<GeoJSONPosition>>) {
+function lineIntersectPolygon(p1: GeoJSON.Position, p2: GeoJSON.Position, polygon: Array<Array<GeoJSON.Position>>) {
     for (const ring of polygon) {
         // loop through every edge of the ring
         for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
@@ -52,7 +50,7 @@ function lineIntersectPolygon(p1: GeoJSONPosition, p2: GeoJSONPosition, polygon:
     return false;
 }
 
-function lineStringWithinPolygon(line: Array<GeoJSONPosition>, polygon: Array<Array<GeoJSONPosition>>) {
+function lineStringWithinPolygon(line: Array<GeoJSON.Position>, polygon: Array<Array<GeoJSON.Position>>) {
     // First, check if geometry points of line segments are all inside polygon
     for (let i = 0; i < line.length; ++i) {
         if (!pointWithinPolygon(line[i], polygon)) {
@@ -69,14 +67,14 @@ function lineStringWithinPolygon(line: Array<GeoJSONPosition>, polygon: Array<Ar
     return true;
 }
 
-function lineStringWithinPolygons(line: Array<GeoJSONPosition>, polygons: Array<Array<Array<GeoJSONPosition>>>) {
+function lineStringWithinPolygons(line: Array<GeoJSON.Position>, polygons: Array<Array<Array<GeoJSON.Position>>>) {
     for (let i = 0; i < polygons.length; i++) {
         if (lineStringWithinPolygon(line, polygons[i])) return true;
     }
     return false;
 }
 
-function getTilePolygon(coordinates: Array<Array<GeoJSONPosition>>, bbox: BBox, canonical: CanonicalTileID) {
+function getTilePolygon(coordinates: Array<Array<GeoJSON.Position>>, bbox: BBox, canonical: CanonicalTileID) {
     const polygon = [];
     for (let i = 0; i < coordinates.length; i++) {
         const ring = [];
@@ -90,7 +88,7 @@ function getTilePolygon(coordinates: Array<Array<GeoJSONPosition>>, bbox: BBox,
     return polygon;
 }
 
-function getTilePolygons(coordinates: Array<Array<Array<GeoJSONPosition>>>, bbox: BBox, canonical: CanonicalTileID) {
+function getTilePolygons(coordinates: Array<Array<Array<GeoJSON.Position>>>, bbox: BBox, canonical: CanonicalTileID) {
     const polygons = [];
     for (let i = 0; i < coordinates.length; i++) {
         const polygon = getTilePolygon(coordinates[i], bbox, canonical);
@@ -99,7 +97,7 @@ function getTilePolygons(coordinates: Array<Array<Array<GeoJSONPosition>>>, bbox
     return polygons;
 }
 
-function updatePoint(p: GeoJSONPosition, bbox: BBox, polyBBox: Array<number>, worldSize: number) {
+function updatePoint(p: GeoJSON.Position, bbox: BBox, polyBBox: Array<number>, worldSize: number) {
     if (p[0] < polyBBox[0] || p[0] > polyBBox[2]) {
         const halfWorldSize = worldSize * 0.5;
         let shift = (p[0] - polyBBox[0] > halfWorldSize) ? -worldSize : (polyBBox[0] - p[0] > halfWorldSize) ? worldSize : 0;
@@ -116,7 +114,7 @@ function resetBBox(bbox: BBox) {
     bbox[2] = bbox[3] = -Infinity;
 }
 
-function getTilePoints(geometry: ?Array<Array<Point>>, pointBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
+function getTilePoints(geometry: Array<Array<Point>> | null | undefined, pointBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
     const tilePoints = [];
@@ -131,15 +129,15 @@ function getTilePoints(geometry: ?Array<Array<Point>>, pointBBox: BBox, polyBBox
     return tilePoints;
 }
 
-function getTileLines(geometry: ?Array<Array<Point>>, lineBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
+function getTileLines(geometry: Array<Array<Point>> | null | undefined, lineBBox: BBox, polyBBox: Array<number>, canonical: CanonicalTileID) {
     const worldSize = Math.pow(2, canonical.z) * EXTENT;
     const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
-    const tileLines: Array<Array<GeoJSONPosition>> = [];
+    const tileLines: Array<Array<GeoJSON.Position>> = [];
     if (!geometry) return tileLines;
     for (const line of geometry) {
         const tileLine = [];
         for (const point of line) {
-            const p: GeoJSONPosition = [point.x + shifts[0], point.y + shifts[1]];
+            const p: GeoJSON.Position = [point.x + shifts[0], point.y + shifts[1]];
             updateBBox(lineBBox, p);
             tileLine.push(p);
         }
@@ -166,8 +164,11 @@ 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) {
@@ -175,8 +176,11 @@ 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) {
@@ -197,8 +201,11 @@ 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) {
@@ -206,8 +213,11 @@ 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) {
@@ -219,20 +229,21 @@ function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPol
 
 class Within implements Expression {
     type: Type;
-    geojson: GeoJSON
+    geojson: GeoJSON.GeoJSON;
     geometries: GeoJSONPolygons;
 
-    constructor(geojson: GeoJSON, geometries: GeoJSONPolygons) {
+    constructor(geojson: GeoJSON.GeoJSON, geometries: GeoJSONPolygons) {
         this.type = BooleanType;
         this.geojson = geojson;
         this.geometries = geometries;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Within {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Within | null | undefined {
         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]: Object);
+            const geojson = (args[1] as any);
             if (geojson.type === 'FeatureCollection') {
                 for (let i = 0; i < geojson.features.length; ++i) {
                     const type = geojson.features[i].geometry.type;
@@ -249,6 +260,7 @@ class Within implements Expression {
                 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/{evaluation_context.js → evaluation_context.ts}

@@ -1,32 +1,32 @@
-// @flow
-
-import {Color} from './values.js';
+import {Color} from './values';
 
 import type Point from '@mapbox/point-geometry';
-import type {FormattedSection} from './types/formatted.js';
-import type {GlobalProperties, Feature, FeatureState} from './index.js';
-import type {CanonicalTileID} from '../../source/tile_id.js';
-import type {FeatureDistanceData} from '../feature_filter/index.js';
-import type {ConfigOptions, ConfigOptionValue} from '../../style/properties.js';
+import type {FormattedSection} from './types/formatted';
+import type {GlobalProperties, Feature, FeatureState} from './index';
+import type {CanonicalTileID} from '../types/tile_id';
+import type {FeatureDistanceData} from '../feature_filter/index';
+import type {ConfigOptions, ConfigOptionValue} from '../types/config_options';
 
 const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
 
 class EvaluationContext {
     globals: GlobalProperties;
-    feature: ?Feature;
-    featureState: ?FeatureState;
-    formattedSection: ?FormattedSection;
-    availableImages: ?Array<string>;
+    feature: Feature | null | undefined;
+    featureState: FeatureState | null | undefined;
+    formattedSection: FormattedSection | null | undefined;
+    availableImages: Array<string> | null | undefined;
     canonical: null | CanonicalTileID;
-    featureTileCoord: ?Point;
-    featureDistanceData: ?FeatureDistanceData;
-    scope: ?string;
-    options: ?ConfigOptions;
+    featureTileCoord: Point | null | undefined;
+    featureDistanceData: FeatureDistanceData | null | undefined;
+    scope: string | null | undefined;
+    options: ConfigOptions | null | undefined;
 
-    _parseColorCache: {[_: string]: ?Color};
+    _parseColorCache: {
+        [_: string]: Color | null | undefined;
+    };
 
-    constructor(scope: ?string, options: ?ConfigOptions) {
-        this.globals = (null: any);
+    constructor(scope?: string | null, options?: ConfigOptions | null) {
+        this.globals = (null as any);
         this.feature = null;
         this.featureState = null;
         this.formattedSection = null;
@@ -47,7 +47,7 @@ class EvaluationContext {
         return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
     }
 
-    geometry(): ?Array<Array<Point>> {
+    geometry(): Array<Array<Point>> | null | undefined {
         return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
     }
 
@@ -55,7 +55,9 @@ class EvaluationContext {
         return this.canonical;
     }
 
-    properties(): {[string]: any} {
+    properties(): {
+        [key: string]: any;
+        } {
         return (this.feature && this.feature.properties) || {};
     }
 
@@ -86,15 +88,16 @@ class EvaluationContext {
         return 0;
     }
 
-    parseColor(input: string): ?Color {
+    parseColor(input: string): Color | null | undefined {
         let cached = this._parseColorCache[input];
         if (!cached) {
+            // @ts-expect-error - TS2322 - Type 'void | Color' is not assignable to type 'Color'. | TS2322 - Type 'void | Color' is not assignable to type 'Color'.
             cached = this._parseColorCache[input] = Color.parse(input);
         }
         return cached;
     }
 
-    getConfig(id: string): ?ConfigOptionValue {
+    getConfig(id: string): ConfigOptionValue | null | undefined {
         return this.options ? this.options.get(id) : null;
     }
 }

package/expression/expression.ts

@@ -0,0 +1,29 @@
+import type {Type} from './types';
+import type ParsingContext from './parsing_context';
+import type EvaluationContext from './evaluation_context';
+
+export type SerializedExpression = Array<unknown> | Array<string> | string | number | boolean | null;
+
+export interface Expression {
+    readonly type: Type;
+    value?: any;
+    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;
+}
+
+export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression | void;
+
+export type ExpressionRegistration = {
+    new(...args: any[]): Expression;
+    readonly parse: ExpressionParser;
+};
+
+export type ExpressionRegistry = {
+    [_: string]: ExpressionRegistration;
+};