@mapbox/mapbox-gl-style-spec 13.24.0-alpha.2 → 13.24.0-alpha.3

package/expression/definitions/coalesce.js

@@ -54,19 +54,21 @@ class Coalesce implements Expression {
     evaluate(ctx: EvaluationContext) {
         let result = null;
         let argCount = 0;
-        let requestedImageName;
+        let firstImage;
         for (const arg of this.args) {
             argCount++;
             result = arg.evaluate(ctx);
             // we need to keep track of the first requested image in a coalesce statement
-            // if coalesce can't find a valid image, we return the first image name so styleimagemissing can fire
+            // if coalesce can't find a valid image, we return the first image so styleimagemissing can fire
             if (result && result instanceof ResolvedImage && !result.available) {
-                if (!requestedImageName) {
-                    requestedImageName = result.name;
+                // set to first image
+                if (!firstImage) {
+                    firstImage = result;
                 }
                 result = null;
+                // if we reach the end, return the first image
                 if (argCount === this.args.length) {
-                    result = requestedImageName;
+                    return firstImage;
                 }
             }
 

package/expression/evaluation_context.js

@@ -51,7 +51,7 @@ class EvaluationContext {
     }
 
     properties() {
-        return this.feature && this.feature.properties || {};
+        return (this.feature && this.feature.properties) || {};
     }
 
     distanceFromCenter() {

package/expression/index.js

@@ -286,11 +286,11 @@ export class StylePropertyFunction<T> {
         extend(this, createFunction(this._parameters, this._specification));
     }
 
-    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}) {
-        return ((new StylePropertyFunction(serialized._parameters, serialized._specification)): StylePropertyFunction<T>);
+    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}): StylePropertyFunction<T> {
+        return new StylePropertyFunction(serialized._parameters, serialized._specification);
     }
 
-    static serialize(input: StylePropertyFunction<T>) {
+    static serialize(input: StylePropertyFunction<T>): {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification} {
         return {
             _parameters: input._parameters,
             _specification: input._specification

package/feature_filter/convert.js

@@ -94,7 +94,7 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
         const children = (filter: any).slice(1).map(f => _convertFilter(f, expectedTypes));
         return children.length > 1 ? ['all'].concat(children) : [].concat(...children);
     } else if (op === 'none') {
-        return ['!', _convertFilter(['any'].concat(filter.slice(1)), {})];
+        return ['!', _convertFilter(['any'].concat((filter: any).slice(1)), {})];
     } else if (op === 'in') {
         converted = convertInOp((filter[1]: any), filter.slice(2));
     } else if (op === '!in') {

package/flow-typed/gl-matrix.js

@@ -0,0 +1,102 @@
+// @flow
+type VecType = Array<number> | Float32Array | Float64Array;
+
+declare module "gl-matrix" {
+    declare type Vec2 = VecType;
+    declare type Vec3 = VecType;
+    declare type Vec4 = VecType;
+    declare type Quat = VecType;
+    declare type Mat2 = VecType;
+    declare type Mat3 = VecType;
+    declare type Mat4 = VecType;
+
+    declare var vec2: {
+        exactEquals(Vec2, Vec2): boolean
+    };
+
+    declare var vec3: {
+        create(): Float32Array,
+        fromValues(number, number, number): Float32Array,
+        length(Vec3): number,
+        len(Vec3): number,
+        squaredLength(Vec3): number,
+        dot(Vec3, Vec3): number,
+        equals(Vec3, Vec3): boolean,
+        exactEquals(Vec3, Vec3): boolean,
+
+        clone<T: Vec3>(T): T,
+        normalize<T: Vec3>(T, Vec3): T,
+        add<T: Vec3>(T, Vec3, Vec3): T,
+        sub<T: Vec3>(T, Vec3, Vec3): T,
+        subtract<T: Vec3>(T, Vec3, Vec3): T,
+        cross<T: Vec3>(T, Vec3, Vec3): T,
+        negate<T: Vec3>(T, Vec3): T,
+        scale<T: Vec3>(T, Vec3, number): T,
+        scaleAndAdd<T: Vec3>(T, Vec3, Vec3, number): T,
+        multiply<T: Vec3>(T, Vec3, Vec3): T,
+        mul<T: Vec3>(T, Vec3, Vec3): T,
+        div<T: Vec3>(T, Vec3, Vec3): T,
+        min<T: Vec3>(T, Vec3, Vec3): T,
+        max<T: Vec3>(T, Vec3, Vec3): T,
+        transformQuat<T: Vec3>(T, Vec3, Quat): T,
+        transformMat3<T: Vec3>(T, Vec3, Mat3): T,
+        transformMat4<T: Vec3>(T, Vec3, Mat4): T
+    };
+
+    declare var vec4: {
+        scale<T: Vec4>(T, Vec4, number): T,
+        mul<T: Vec4>(T, Vec4, Vec4): T,
+        transformMat4<T: Vec4>(T, Vec4, Mat4): T
+    };
+
+    declare var mat2: {
+        create(): Float32Array,
+        rotate<T: Mat2>(T, Mat2, number): T,
+        invert<T: Mat2>(T, Mat2): T,
+        scale<T: Mat2>(T, Mat2, Vec2): T
+    };
+
+    declare var mat3: {
+        create(): Float32Array,
+
+        fromMat4<T: Mat3>(T, Mat4): T,
+        fromRotation<T: Mat3>(T, number): T,
+        mul<T: Mat3>(T, Mat3, Mat3): T,
+        multiply<T: Mat3>(T, Mat3, Mat3): T,
+        adjoint<T: Mat3>(T, Mat3): T,
+        transpose<T: Mat3>(T, Mat3): T
+    };
+
+    declare var mat4: {
+        create(): Float32Array,
+
+        fromScaling<T: Mat4>(T, Vec3): T,
+        fromQuat<T: Mat4>(T, Quat): T,
+        ortho<T: Mat4>(T, number, number, number, number, number, number): T,
+        perspective<T: Mat4>(T, number, number, number, number): T,
+        identity<T: Mat4>(T): T,
+        scale<T: Mat4>(T, Mat4, Vec3): T,
+        mul<T: Mat4>(T, Mat4, Mat4): T,
+        multiply<T: Mat4>(T, Mat4, Mat4): T,
+        rotateX<T: Mat4>(T, Mat4, number): T,
+        rotateY<T: Mat4>(T, Mat4, number): T,
+        rotateZ<T: Mat4>(T, Mat4, number): T,
+        translate<T: Mat4>(T, Mat4, Vec3): T,
+        invert<T: Mat4>(T, Mat4): T,
+        copy<T: Mat4>(T, Mat4): T,
+        clone<T: Mat4>(T): T
+    };
+
+    declare var quat: {
+        create(): Float32Array,
+        length(Quat): number,
+        exactEquals(Quat, Quat): boolean,
+
+        normalize<T: Quat>(T, Quat): T,
+        conjugate<T: Quat>(T, Quat): T,
+        identity<T: Quat>(T): T,
+        rotateX<T: Quat>(T, Quat, number): T,
+        rotateY<T: Quat>(T, Quat, number): T,
+        rotateZ<T: Quat>(T, Quat, number): T
+    }
+}

package/flow-typed/grid-index.js

@@ -0,0 +1,13 @@
+// @flow strict
+declare module 'grid-index' {
+    declare class GridIndex {
+        constructor(extent: number, n: number, padding: number): GridIndex;
+        constructor(data: ArrayBuffer): GridIndex;
+
+        insert(key: number, x1: number, y1: number, x2: number, y2: number): void;
+        query(x1: number, y1: number, x2: number, y2: number, intersectionText?: (number, number, number, number) => boolean): Array<number>;
+        toArrayBuffer(): ArrayBuffer;
+    }
+
+    declare export default Class<GridIndex>;
+}

package/flow-typed/pbf.js

@@ -1,3 +1,4 @@
+// @flow
 declare module "pbf" {
     declare type ReadFunction<T> = (tag: number, result: T, pbf: Pbf) => void;
 
@@ -21,5 +22,5 @@ declare module "pbf" {
         readBytes(): Uint8Array;
     }
 
-    declare module.exports: typeof Pbf
+    declare export default Class<Pbf>;
 }

package/flow-typed/point-geometry.js

@@ -1,5 +1,6 @@
+// @flow strict
 declare module "@mapbox/point-geometry" {
-    declare type PointLike = Point | [number, number];
+    declare export type PointLike = Point | [number, number];
 
     declare class Point {
         x: number;
@@ -40,5 +41,6 @@ declare module "@mapbox/point-geometry" {
         _round(): Point;
         static convert(a: PointLike): Point;
     }
-    declare module.exports: typeof Point;
+
+    declare export default Class<Point>;
 }

package/flow-typed/potpack.js

@@ -1,3 +1,4 @@
+// @flow
 declare module "potpack" {
     declare type Bin = {
         x: number,

package/flow-typed/tiny-sdf.js

@@ -0,0 +1,31 @@
+
+declare module '@mapbox/tiny-sdf' {
+    declare type TinySDFOptions = {
+        fontSize?: number;
+        buffer?: number;
+        radius?: number;
+        cutoff?: number;
+        fontFamily?: string;
+        fontWeight?: string;
+        fontStyle?: string;
+    };
+
+    declare type TinySDFGlyph = {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+        glyphWidth: number;
+        glyphHeight: number;
+        glyphTop: number;
+        glyphLeft: number;
+        glyphAdvance: number;
+    };
+
+    declare class TinySDF {
+        fontWeight: string;
+        constructor(options: TinySDFOptions): TinySDF;
+        draw(char: string): TinySDFGlyph;
+    }
+
+    declare export default Class<TinySDF>;
+}

package/flow-typed/vector-tile.js

@@ -1,3 +1,4 @@
+// @flow
 import type Pbf from 'pbf';
 import type Point from '@mapbox/point-geometry';
 import type { GeoJSONFeature } from '@mapbox/geojson-types';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
   "description": "a specification for mapbox gl styles",
-  "version": "13.24.0-alpha.2",
+  "version": "13.24.0-alpha.3",
   "author": "Mapbox",
   "keywords": [
     "mapbox",

package/style-spec.js

@@ -57,6 +57,12 @@ export type StylePropertySpecification = {
     length?: number,
     transition: boolean,
     default?: Array<string>
+} | {
+    type: 'resolvedImage',
+    'property-type': ExpressionType,
+    expression?: ExpressionSpecification,
+    transition: boolean,
+    default?: string
 };
 
 import v8 from './reference/v8.json';