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

package/util/{color.js → color.ts}

@@ -1,6 +1,6 @@
-// @flow
-
 import {parseCSSColor} from 'csscolorparser';
+import {number as lerp} from './interpolate';
+import type {LUT} from '../types/lut';
 
 /**
  * An RGBA color value. Create instances from color strings using the static
@@ -73,10 +73,96 @@ class Color {
      * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
      */
     toString(): string {
-        const [r, g, b, a] = this.toArray();
+        const [r, g, b, a] = this.a === 0 ? [0, 0, 0, 0] : [
+            this.r * 255 / this.a,
+            this.g * 255 / this.a,
+            this.b * 255 / this.a,
+            this.a
+        ];
         return `rgba(${Math.round(r)},${Math.round(g)},${Math.round(b)},${a})`;
     }
 
+    toRenderColor(lut: LUT | null): RenderColor {
+        const {r, g, b, a} = this;
+        return new RenderColor(lut, r, g, b, a);
+    }
+}
+
+/**
+ * Renderable color created from a Color and an optional LUT value
+ */
+export class RenderColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+
+    constructor(lut: LUT | null, r: number, g: number, b: number, a: number) {
+        if (!lut) {
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            this.a = a;
+        } else {
+            const N = lut.image.height;
+            const N2 = N * N;
+            // Normalize to cube dimensions.
+            r = a === 0 ? 0 : (r / a) * (N - 1);
+            g = a === 0 ? 0 : (g / a) * (N - 1);
+            b = a === 0 ? 0 : (b / a) * (N - 1);
+
+            // Determine boundary values for the cube the color is in.
+            const r0 = Math.floor(r);
+            const g0 = Math.floor(g);
+            const b0 = Math.floor(b);
+            const r1 = Math.ceil(r);
+            const g1 = Math.ceil(g);
+            const b1 = Math.ceil(b);
+
+            // Determine weights within the cube.
+            const rw = r - r0;
+            const gw = g - g0;
+            const bw = b - b0;
+
+            const data = lut.image.data;
+            const i0 = (r0 + g0 * N2 + b0 * N) * 4;
+            const i1 = (r0 + g0 * N2 + b1 * N) * 4;
+            const i2 = (r0 + g1 * N2 + b0 * N) * 4;
+            const i3 = (r0 + g1 * N2 + b1 * N) * 4;
+            const i4 = (r1 + g0 * N2 + b0 * N) * 4;
+            const i5 = (r1 + g0 * N2 + b1 * N) * 4;
+            const i6 = (r1 + g1 * N2 + b0 * N) * 4;
+            const i7 = (r1 + g1 * N2 + b1 * N) * 4;
+            if (i0 < 0 || i7 >= data.length) {
+                throw new Error("out of range");
+            }
+
+            // Trilinear interpolation.
+            this.r = lerp(
+                lerp(
+                    lerp(data[i0], data[i1], bw),
+                    lerp(data[i2], data[i3], bw), gw),
+                lerp(
+                    lerp(data[i4], data[i5], bw),
+                    lerp(data[i6], data[i7], bw), gw), rw) / 255 * a;
+            this.g = lerp(
+                lerp(
+                    lerp(data[i0 + 1], data[i1 + 1], bw),
+                    lerp(data[i2 + 1], data[i3 + 1], bw), gw),
+                lerp(
+                    lerp(data[i4 + 1], data[i5 + 1], bw),
+                    lerp(data[i6 + 1], data[i7 + 1], bw), gw), rw) / 255 * a;
+            this.b = lerp(
+                lerp(
+                    lerp(data[i0 + 2], data[i1 + 2], bw),
+                    lerp(data[i2 + 2], data[i3 + 2], bw), gw),
+                lerp(
+                    lerp(data[i4 + 2], data[i5 + 2], bw),
+                    lerp(data[i6 + 2], data[i7 + 2], bw), gw), rw) / 255 * a;
+            this.a = a;
+        }
+    }
+
     /**
      * Returns an RGBA array of values representing the color, unpremultiplied by A.
      *

package/util/{color_spaces.js → color_spaces.ts}

@@ -1,21 +1,19 @@
-// @flow
+import Color from './color';
 
-import Color from './color.js';
-
-import {number as interpolateNumber} from './interpolate.js';
+import {number as interpolateNumber} from './interpolate';
 
 type LABColor = {
-    l: number,
-    a: number,
-    b: number,
-    alpha: number
+    l: number;
+    a: number;
+    b: number;
+    alpha: number;
 };
 
 type HCLColor = {
-    h: number,
-    c: number,
-    l: number,
-    alpha: number
+    h: number;
+    c: number;
+    l: number;
+    alpha: number;
 };
 
 // Constants
@@ -130,10 +128,10 @@ export const lab = {
     forward: rgbToLab,
     reverse: labToRgb,
     interpolate: interpolateLab
-};
+} as const;
 
 export const hcl = {
     forward: rgbToHcl,
     reverse: hclToRgb,
     interpolate: interpolateHcl
-};
+} as const;

package/util/{deep_equal.js → deep_equal.ts}

@@ -1,11 +1,9 @@
-// @flow
-
 /**
  * Deeply compares two object literals.
  *
  * @private
  */
-function deepEqual(a: ?mixed, b: ?mixed): boolean {
+function deepEqual(a?: unknown | null, b?: unknown | null): boolean {
     if (Array.isArray(a)) {
         if (!Array.isArray(b) || a.length !== b.length) return false;
         for (let i = 0; i < a.length; i++) {

package/util/{extend.js → extend.ts}

@@ -1,6 +1,4 @@
-// @flow
-
-export default function (output: any, ...inputs: Array<any>): any {
+export default function(output: any, ...inputs: Array<any>): any {
     for (const input of inputs) {
         for (const k in input) {
             output[k] = input[k];

package/util/{geometry_util.js → geometry_util.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type Point from '@mapbox/point-geometry';
 import quickselect from 'quickselect';
 
@@ -22,7 +21,11 @@ function calculateSignedArea(ring: Array<Point>): number {
     return sum;
 }
 
-function compareAreas(a: {area: number}, b: {area: number}) {
+function compareAreas(a: {
+    area: number;
+}, b: {
+    area: number;
+}) {
     return b.area - a.area;
 }
 
@@ -40,7 +43,7 @@ export function classifyRings(rings: Array<Array<Point>>, maxRings: number): Arr
         const area = calculateSignedArea(rings[i]);
         if (area === 0) continue;
 
-        (rings[i]: any).area = Math.abs(area);
+        (rings[i] as any).area = Math.abs(area);
 
         if (ccw === undefined) ccw = area < 0;
 
@@ -49,7 +52,7 @@ export function classifyRings(rings: Array<Array<Point>>, maxRings: number): Arr
             polygon = [rings[i]];
 
         } else {
-            (polygon: any).push(rings[i]);
+            (polygon).push(rings[i]);
         }
     }
     if (polygon) polygons.push(polygon);
@@ -67,7 +70,7 @@ export function classifyRings(rings: Array<Array<Point>>, maxRings: number): Arr
     return polygons;
 }
 
-export function updateBBox(bbox: BBox, coord: GeoJSONPosition) {
+export function updateBBox(bbox: BBox, coord: GeoJSON.Position) {
     bbox[0] = Math.min(bbox[0], coord[0]);
     bbox[1] = Math.min(bbox[1], coord[1]);
     bbox[2] = Math.max(bbox[2], coord[0]);
@@ -82,7 +85,7 @@ export function boxWithinBox(bbox1: BBox, bbox2: BBox): boolean {
     return true;
 }
 
-function onBoundary(p: GeoJSONPosition, p1: GeoJSONPosition, p2: GeoJSONPosition) {
+function onBoundary(p: GeoJSON.Position, p1: GeoJSON.Position, p2: GeoJSON.Position) {
     const x1 = p[0] - p1[0];
     const y1 = p[1] - p1[1];
     const x2 = p[0] - p2[0];
@@ -90,12 +93,16 @@ function onBoundary(p: GeoJSONPosition, p1: GeoJSONPosition, p2: GeoJSONPosition
     return (x1 * y2 - x2 * y1 === 0) && (x1 * x2 <= 0) && (y1 * y2 <= 0);
 }
 
-function rayIntersect(p: GeoJSONPosition, p1: GeoJSONPosition, p2: GeoJSONPosition) {
+function rayIntersect(p: GeoJSON.Position, p1: GeoJSON.Position, p2: GeoJSON.Position) {
     return ((p1[1] > p[1]) !== (p2[1] > p[1])) && (p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0]);
 }
 
 // ray casting algorithm for detecting if point is in polygon
-export function pointWithinPolygon(point: GeoJSONPosition, rings: Array<Array<GeoJSONPosition>>, trueOnBoundary: boolean = false): boolean {
+export function pointWithinPolygon(
+    point: GeoJSON.Position,
+    rings: Array<Array<GeoJSON.Position>>,
+    trueOnBoundary: boolean = false,
+): boolean {
     let inside = false;
     for (let i = 0, len = rings.length; i < len; i++) {
         const ring = rings[i];
@@ -109,12 +116,12 @@ export function pointWithinPolygon(point: GeoJSONPosition, rings: Array<Array<Ge
     return inside;
 }
 
-function perp(v1: GeoJSONPosition, v2: GeoJSONPosition) {
+function perp(v1: GeoJSON.Position, v2: GeoJSON.Position) {
     return v1[0] * v2[1] - v1[1] * v2[0];
 }
 
 // check if p1 and p2 are in different sides of line segment q1->q2
-function twoSided(p1: GeoJSONPosition, p2: GeoJSONPosition, q1: GeoJSONPosition, q2: GeoJSONPosition) {
+function twoSided(p1: GeoJSON.Position, p2: GeoJSON.Position, q1: GeoJSON.Position, q2: GeoJSON.Position) {
     // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
     const x1 = p1[0] - q1[0];
     const y1 = p1[1] - q1[1];
@@ -128,7 +135,12 @@ function twoSided(p1: GeoJSONPosition, p2: GeoJSONPosition, q1: GeoJSONPosition,
     return false;
 }
 // a, b are end points for line segment1, c and d are end points for line segment2
-export function segmentIntersectSegment(a: GeoJSONPosition, b: GeoJSONPosition, c: GeoJSONPosition, d: GeoJSONPosition): boolean {
+export function segmentIntersectSegment(
+    a: GeoJSON.Position,
+    b: GeoJSON.Position,
+    c: GeoJSON.Position,
+    d: GeoJSON.Position,
+): boolean {
     // check if two segments are parallel or not
     // precondition is end point a, b is inside polygon, if line a->b is
     // parallel to polygon edge c->d, then a->b won't intersect with c->d

package/util/{get_type.js → get_type.ts}

@@ -1,6 +1,4 @@
-// @flow
-
-export default function getType(val: mixed): string {
+export default function getType(val: unknown): string {
     if (val instanceof Number) {
         return 'number';
     } else if (val instanceof String) {

package/util/{interpolate.js → interpolate.ts}

@@ -1,6 +1,4 @@
-// @flow
-
-import Color from './color.js';
+import Color from './color';
 
 export function number(a: number, b: number, t: number): number {
     return (a * (1 - t)) + (b * t);

package/util/{properties.js → properties.ts}

@@ -1,10 +1,11 @@
-// @flow
-
-import type {ExpressionSpecification, StylePropertySpecification} from '../style-spec.js';
+import type {ExpressionSpecification, StylePropertySpecification} from '../style-spec';
 
 type ExpressionParameter = ExpressionSpecification['parameters'][number];
 
-function expressionHasParameter(expression: ?ExpressionSpecification, parameter: ExpressionParameter): boolean {
+function expressionHasParameter(
+    expression: ExpressionSpecification | null | undefined,
+    parameter: ExpressionParameter,
+): boolean {
     return !!expression && !!expression.parameters && expression.parameters.indexOf(parameter) > -1;
 }
 

package/util/{random.js → random.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 // Seeded pseudo random generator function
 export function mulberry32(a: number): () => number {
     return function () {

package/util/{ref_properties.js → ref_properties.ts}

@@ -1,2 +1 @@
-// @flow
 export default ['type', 'source', 'source-layer', 'minzoom', 'maxzoom', 'filter', 'layout'];

package/util/{result.js → result.ts}

@@ -1,14 +1,16 @@
-// @flow
-
 /**
  * A type used for returning and propagating errors. The first element of the union
  * represents success and contains a value, and the second represents an error and
  * contains an error value.
  * @private
  */
-export type Result<T, E> =
-    | {| result: 'success', value: T |}
-    | {| result: 'error', value: E |};
+export type Result<T, E> = {
+    result: 'success';
+    value: T;
+} | {
+    result: 'error';
+    value: E;
+};
 
 export function success<T, E>(value: T): Result<T, E> {
     return {result: 'success', value};

package/util/{unbundle_jsonlint.js → unbundle_jsonlint.ts}

@@ -1,7 +1,5 @@
-// @flow
-
 // Turn jsonlint-lines-primitives objects into primitive objects
-export function unbundle(value: mixed): mixed {
+export function unbundle(value: unknown): unknown {
     if (value instanceof Number || value instanceof String || value instanceof Boolean) {
         return value.valueOf();
     } else {
@@ -9,11 +7,13 @@ export function unbundle(value: mixed): mixed {
     }
 }
 
-export function deepUnbundle(value: mixed): mixed {
+export function deepUnbundle(value: unknown): unknown {
     if (Array.isArray(value)) {
         return value.map(deepUnbundle);
     } else if (value instanceof Object && !(value instanceof Number || value instanceof String || value instanceof Boolean)) {
-        const unbundledValue: { [key: string]: mixed } = {};
+        const unbundledValue: {
+            [key: string]: unknown;
+        } = {};
         for (const key in value) {
             unbundledValue[key] = deepUnbundle(value[key]);
         }

package/validate/{validate.js → validate.ts}

@@ -1,36 +1,34 @@
-// @flow
+import extend from '../util/extend';
+import ValidationError from '../error/validation_error';
+import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
+import {isExpression} from '../expression/index';
+import {isFunction} from '../function/index';
 
-import extend from '../util/extend.js';
-import ValidationError from '../error/validation_error.js';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint.js';
-import {isExpression} from '../expression/index.js';
-import {isFunction} from '../function/index.js';
+import validateImport from './validate_import';
+import validateFunction from './validate_function';
+import validateExpression from './validate_expression';
+import validateObject from './validate_object';
+import validateArray from './validate_array';
+import validateBoolean from './validate_boolean';
+import validateNumber from './validate_number';
+import validateColor from './validate_color';
+import validateEnum from './validate_enum';
+import validateFilter from './validate_filter';
+import validateLayer from './validate_layer';
+import validateSource from './validate_source';
+import validateModel from './validate_model';
+import validateLight from './validate_light';
+import validateLights from './validate_lights';
+import validateTerrain from './validate_terrain';
+import validateFog from './validate_fog';
+import validateString from './validate_string';
+import validateFormatted from './validate_formatted';
+import validateImage from './validate_image';
+import validateProjection from './validate_projection';
 
-import validateImport from './validate_import.js';
-import validateFunction from './validate_function.js';
-import validateExpression from './validate_expression.js';
-import validateObject from './validate_object.js';
-import validateArray from './validate_array.js';
-import validateBoolean from './validate_boolean.js';
-import validateNumber from './validate_number.js';
-import validateColor from './validate_color.js';
-import validateEnum from './validate_enum.js';
-import validateFilter from './validate_filter.js';
-import validateLayer from './validate_layer.js';
-import validateSource from './validate_source.js';
-import validateModel from './validate_model.js';
-import validateLight from './validate_light.js';
-import validateLights from './validate_lights.js';
-import validateTerrain from './validate_terrain.js';
-import validateFog from './validate_fog.js';
-import validateString from './validate_string.js';
-import validateFormatted from './validate_formatted.js';
-import validateImage from './validate_image.js';
-import validateProjection from './validate_projection.js';
-
-import type {StyleReference} from '../reference/latest.js';
-import type {StyleSpecification} from '../types.js';
-import getType from '../util/get_type.js';
+import type {StyleReference} from '../reference/latest';
+import type {StyleSpecification} from '../types';
+import getType from '../util/get_type';
 
 const VALIDATORS = {
     '*'() {
@@ -69,11 +67,11 @@ const VALIDATORS = {
 // - styleSpec: current full spec being evaluated.
 export type ValidationOptions = {
     key: string;
-    value: Object;
-    valueSpec: Object;
-    style: $Shape<StyleSpecification>;
+    value: any;
+    valueSpec?: any;
+    style: Partial<StyleSpecification>;
     styleSpec: StyleReference;
-}
+};
 
 export default function validate(options: ValidationOptions, arrayAsExpression: boolean = false): Array<ValidationError> {
     const value = options.value;

package/validate/{validate_array.js → validate_array.ts}

@@ -1,13 +1,11 @@
-// @flow
+import getType from '../util/get_type';
+import validate from './validate';
+import ValidationError from '../error/validation_error';
 
-import getType from '../util/get_type.js';
-import validate from './validate.js';
-import ValidationError from '../error/validation_error.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 type Options = ValidationOptions & {
-    arrayElementValidator: Function;
+    arrayElementValidator: any;
 };
 
 export default function validateArray(options: Options): Array<ValidationError> {

package/validate/{validate_boolean.js → validate_boolean.ts}

@@ -1,9 +1,7 @@
-// @flow
+import getType from '../util/get_type';
+import ValidationError from '../error/validation_error';
 
-import getType from '../util/get_type.js';
-import ValidationError from '../error/validation_error.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateBoolean(options: ValidationOptions): Array<ValidationError> {
     const value = options.value;

package/validate/{validate_color.js → validate_color.ts}

@@ -1,10 +1,8 @@
-// @flow
-
-import ValidationError from '../error/validation_error.js';
-import getType from '../util/get_type.js';
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
 import {parseCSSColor} from 'csscolorparser';
 
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateColor(options: ValidationOptions): Array<ValidationError> {
     const key = options.key;

package/validate/{validate_enum.js → validate_enum.ts}

@@ -1,9 +1,7 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import {unbundle} from '../util/unbundle_jsonlint';
 
-import ValidationError from '../error/validation_error.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateEnum(options: ValidationOptions): Array<ValidationError> {
     const key = options.key;
@@ -16,6 +14,7 @@ export default function validateEnum(options: ValidationOptions): Array<Validati
             errors.push(new ValidationError(key, value, `expected one of [${valueSpec.values.join(', ')}], ${JSON.stringify(value)} found`));
         }
     } else { // >=v8
+        // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'string'.
         if (Object.keys(valueSpec.values).indexOf(unbundle(value)) === -1) {
             errors.push(new ValidationError(key, value, `expected one of [${Object.keys(valueSpec.values).join(', ')}], ${JSON.stringify(value)} found`));
         }

package/validate/{validate_expression.js → validate_expression.ts}

@@ -1,13 +1,11 @@
-// @flow
+import ValidationError from '../error/validation_error';
 
-import ValidationError from '../error/validation_error.js';
+import {createExpression, createPropertyExpression} from '../expression/index';
+import {deepUnbundle} from '../util/unbundle_jsonlint';
+import {isStateConstant, isGlobalPropertyConstant, isFeatureConstant} from '../expression/is_constant';
+import CompoundExpression from '../expression/compound_expression';
 
-import {createExpression, createPropertyExpression} from '../expression/index.js';
-import {deepUnbundle} from '../util/unbundle_jsonlint.js';
-import {isStateConstant, isGlobalPropertyConstant, isFeatureConstant} from '../expression/is_constant.js';
-import CompoundExpression from '../expression/compound_expression.js';
-
-import type {Expression} from '../expression/expression.js';
+import type {Expression} from '../expression/expression';
 
 export default function validateExpression(options: any): Array<ValidationError> {
     const expression = (options.expressionContext === 'property' ? createPropertyExpression : createExpression)(deepUnbundle(options.value), options.valueSpec);
@@ -17,7 +15,7 @@ export default function validateExpression(options: any): Array<ValidationError>
         });
     }
 
-    const expressionObj = (expression.value: any).expression || (expression.value: any)._styleExpression.expression;
+    const expressionObj = (expression.value as any).expression || (expression.value as any)._styleExpression.expression;
 
     if (options.expressionContext === 'property' && (options.propertyKey === 'text-font') &&
         !expressionObj.outputDefined()) {

package/validate/{validate_filter.js → validate_filter.ts}

@@ -1,18 +1,20 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import validateExpression from './validate_expression';
+import validateEnum from './validate_enum';
+import getType from '../util/get_type';
+import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
+import extend from '../util/extend';
+import {isExpressionFilter} from '../feature_filter/index';
 
-import ValidationError from '../error/validation_error.js';
-import validateExpression from './validate_expression.js';
-import validateEnum from './validate_enum.js';
-import getType from '../util/get_type.js';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint.js';
-import extend from '../util/extend.js';
-import {isExpressionFilter} from '../feature_filter/index.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 type Options = ValidationOptions & {
     layerType?: string;
-}
+    object?: {
+        type?: string,
+        id?: string
+    }
+};
 
 export default function validateFilter(options: Options): Array<ValidationError> {
     if (isExpressionFilter(deepUnbundle(options.value))) {
@@ -57,12 +59,14 @@ function validateNonExpressionFilter(options: Options) {
     case '<':
     case '<=':
     case '>':
+    // @ts-expect-error - falls through
     case '>=':
         if (value.length >= 2 && unbundle(value[1]) === '$type') {
             errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${value[0]}"`));
         }
         /* falls through */
     case '==':
+    // @ts-expect-error - falls through
     case '!=':
         if (value.length !== 3) {
             errors.push(new ValidationError(key, value, `filter array for operator "${value[0]}" must have 3 elements`));
@@ -101,7 +105,7 @@ function validateNonExpressionFilter(options: Options) {
                 value: value[i],
                 style: options.style,
                 styleSpec: options.styleSpec
-            }: any)));
+            } as any)));
         }
         break;
 

package/validate/{validate_fog.js → validate_fog.ts}

@@ -1,10 +1,8 @@
-// @flow
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import validate from './validate';
+import getType from '../util/get_type';
 
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import validate from './validate.js';
-import getType from '../util/get_type.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateFog(options: ValidationOptions): Array<ValidationError> {
     const fog = options.value;

package/validate/validate_formatted.ts

@@ -0,0 +1,13 @@
+import validateExpression from './validate_expression';
+import validateString from './validate_string';
+
+import type {ValidationOptions} from './validate';
+import type ValidationError from '../error/validation_error';
+
+export default function validateFormatted(options: ValidationOptions): Array<ValidationError> {
+    if (validateString(options).length === 0) {
+        return [];
+    }
+
+    return validateExpression(options);
+}