@mapbox/mapbox-gl-style-spec 13.24.0-alpha.1 → 13.24.0-alpha.6

package/empty.js

@@ -1,29 +1,10 @@
-import latest from './reference/latest.js';
-
-export default function emptyStyle() {
-    const style = {};
-
-    const version = latest['$version'];
-    for (const styleKey in latest['$root']) {
-        const spec = latest['$root'][styleKey];
-
-        if (spec.required) {
-            let value = null;
-            if (styleKey === 'version') {
-                value = version;
-            } else {
-                if (spec.type === 'array') {
-                    value = [];
-                } else {
-                    value = {};
-                }
-            }
-
-            if (value != null) {
-                style[styleKey] = value;
-            }
-        }
-    }
-
-    return style;
+// @flow
+import type {StyleSpecification} from './types.js';
+
+export default function emptyStyle(): StyleSpecification {
+    return {
+        version: 8,
+        layers: [],
+        sources: {}
+    };
 }

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/definitions/in.js

@@ -42,7 +42,7 @@ class In implements Expression {
         const needle = (this.needle.evaluate(ctx): any);
         const haystack = (this.haystack.evaluate(ctx): any);
 
-        if (!haystack) return false;
+        if (haystack == null) return false;
 
         if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
             throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);

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/feature_filter/index.js

@@ -9,7 +9,7 @@ import type {CanonicalTileID} from '../../source/tile_id.js';
 import type Point from '@mapbox/point-geometry';
 
 export type FeatureDistanceData = {bearing: [number, number], center: [number, number], scale: number};
-type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => boolean;
+export type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => boolean;
 export type FeatureFilter = {filter: FilterExpression, dynamicFilter?: FilterExpression, needGeometry: boolean, needFeature: boolean};
 
 export default createFilter;

package/flow-typed/gl-matrix.js

@@ -0,0 +1,103 @@
+// @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,
+        lerp<T: Vec3>(T, Vec3, Vec3, number): 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/group_by_layout.js

@@ -1,9 +1,11 @@
+// @flow
+
+import type {LayerSpecification} from './types.js';
 
 import refProperties from './util/ref_properties.js';
 
 function stringify(obj) {
-    const type = typeof obj;
-    if (type === 'number' || type === 'boolean' || type === 'string' || obj === undefined || obj === null)
+    if (typeof obj === 'number' || typeof obj === 'boolean' || typeof obj === 'string' || obj === undefined || obj === null)
         return JSON.stringify(obj);
 
     if (Array.isArray(obj)) {
@@ -14,11 +16,9 @@ function stringify(obj) {
         return `${str}]`;
     }
 
-    const keys = Object.keys(obj).sort();
-
     let str = '{';
-    for (let i = 0; i < keys.length; i++) {
-        str += `${JSON.stringify(keys[i])}:${stringify(obj[keys[i]])},`;
+    for (const key of Object.keys(obj).sort()) {
+        str += `${key}:${stringify((obj: any)[key])},`;
     }
     return `${str}}`;
 }
@@ -26,13 +26,11 @@ function stringify(obj) {
 function getKey(layer) {
     let key = '';
     for (const k of refProperties) {
-        key += `/${stringify(layer[k])}`;
+        key += `/${stringify((layer: any)[k])}`;
     }
     return key;
 }
 
-export default groupByLayout;
-
 /**
  * Given an array of layers, return an array of arrays of layers where all
  * layers in each group have identical layout-affecting properties. These
@@ -48,7 +46,7 @@ export default groupByLayout;
  * @param {Object} [cachedKeys] - an object to keep already calculated keys.
  * @returns {Array<Array<Layer>>}
  */
-function groupByLayout(layers, cachedKeys) {
+export default function groupByLayout(layers: Array<LayerSpecification>, cachedKeys: {[id: string]: string}): Array<Array<LayerSpecification>> {
     const groups = {};
 
     for (let i = 0; i < layers.length; i++) {

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.1",
+  "version": "13.24.0-alpha.6",
   "author": "Mapbox",
   "keywords": [
     "mapbox",
@@ -22,9 +22,11 @@
     }
   },
   "scripts": {
+    "pretest": "npm run build",
+    "test": "node ./test.js",
     "copy-flow-typed": "cp -R ../../flow-typed .",
     "build": "../../node_modules/.bin/rollup -c && ../../node_modules/.bin/rollup -c --environment esm",
-    "prepublishOnly": "git clean -fdx && yarn copy-flow-typed && yarn build",
+    "prepublishOnly": "npm run copy-flow-typed && npm run build",
     "postpublish": "rm -r flow-typed dist/index.cjs"
   },
   "repository": {
@@ -32,15 +34,15 @@
     "url": "git@github.com:mapbox/mapbox-gl-js.git"
   },
   "bin": {
-    "gl-style-migrate": "bin/gl-style-migrate",
-    "gl-style-validate": "bin/gl-style-validate",
-    "gl-style-format": "bin/gl-style-format",
-    "gl-style-composite": "bin/gl-style-composite"
+    "gl-style-migrate": "./bin/gl-style-migrate.js",
+    "gl-style-validate": "./bin/gl-style-validate.js",
+    "gl-style-format": "./bin/gl-style-format.js",
+    "gl-style-composite": "./bin/gl-style-composite.js"
   },
   "dependencies": {
     "@mapbox/jsonlint-lines-primitives": "~2.0.2",
-    "@mapbox/unitbezier": "^0.0.0",
     "@mapbox/point-geometry": "^0.1.0",
+    "@mapbox/unitbezier": "^0.0.0",
     "csscolorparser": "~1.0.2",
     "json-stringify-pretty-compact": "^2.0.0",
     "minimist": "^1.2.5",

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';
@@ -119,6 +125,3 @@ export {
     validateMapboxApiSupported,
     visit
 };
-
-validate.parsed = validate;
-validate.latest = validate;

package/test.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/* eslint-disable no-process-exit */
+
+import fs from 'fs';
+import {execSync} from 'child_process';
+import {createRequire} from 'module';
+
+const packageJson = JSON.parse(fs.readFileSync('./package.json'));
+
+process.on('unhandledRejection', error => {
+    // don't log `error` directly, because errors from child_process.execSync
+    // contain an (undocumented) `envPairs` with environment variable values
+    console.log(error.message || 'unhandledRejection');
+    process.exit(1);
+});
+
+const require = createRequire(import.meta.url);
+const stylePath = require.resolve('mapbox-gl-styles/styles/basic-v9.json');
+
+try {
+    for (const bin in packageJson.bin) {
+        const script = packageJson.bin[bin];
+        const command = [script, stylePath].join(' ');
+
+        console.log(command);
+        execSync(command).toString();
+    }
+} catch (error) {
+    console.log(error.message);
+    process.exit(1);
+}

package/util/color_spaces.js

@@ -79,7 +79,7 @@ function labToRgb(labColor: LABColor): Color {
     );
 }
 
-function interpolateLab(from: LABColor, to: LABColor, t: number) {
+function interpolateLab(from: LABColor, to: LABColor, t: number): LABColor {
     return {
         l: interpolateNumber(from.l, to.l, t),
         a: interpolateNumber(from.a, to.a, t),
@@ -117,7 +117,7 @@ function interpolateHue(a: number, b: number, t: number) {
     return a + t * (d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d);
 }
 
-function interpolateHcl(from: HCLColor, to: HCLColor, t: number) {
+function interpolateHcl(from: HCLColor, to: HCLColor, t: number): HCLColor {
     return {
         h: interpolateHue(from.h, to.h, t),
         c: interpolateNumber(from.c, to.c, t),

package/util/extend.js

@@ -1,6 +1,6 @@
 // @flow
 
-export default function (output: any, ...inputs: Array<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/interpolate.js

@@ -2,11 +2,11 @@
 
 import Color from './color.js';
 
-export function number(a: number, b: number, t: number) {
+export function number(a: number, b: number, t: number): number {
     return (a * (1 - t)) + (b * t);
 }
 
-export function color(from: Color, to: Color, t: number) {
+export function color(from: Color, to: Color, t: number): Color {
     return new Color(
         number(from.r, to.r, t),
         number(from.g, to.g, t),

package/util/ref_properties.js

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

package/util/unbundle_jsonlint.js

@@ -1,7 +1,7 @@
 // @flow
 
 // Turn jsonlint-lines-primitives objects into primitive objects
-export function unbundle(value: mixed) {
+export function unbundle(value: mixed): mixed {
     if (value instanceof Number || value instanceof String || value instanceof Boolean) {
         return value.valueOf();
     } else {

package/validate/validate.js

@@ -11,7 +11,6 @@ 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 validateConstants from './validate_constants.js';
 import validateEnum from './validate_enum.js';
 import validateFilter from './validate_filter.js';
 import validateLayer from './validate_layer.js';
@@ -32,7 +31,6 @@ const VALIDATORS = {
     'boolean': validateBoolean,
     'number': validateNumber,
     'color': validateColor,
-    'constants': validateConstants,
     'enum': validateEnum,
     'filter': validateFilter,
     'function': validateFunction,

package/validate_mapbox_api_supported.js

@@ -1,11 +1,13 @@
 // @flow
 
-import validateStyle from './validate_style.min.js';
+import {validateStyle} from './validate_style.min.js';
 import {v8} from './style-spec.js';
 import readStyle from './read_style.js';
 import ValidationError from './error/validation_error.js';
 import getType from './util/get_type.js';
 
+import type {ValidationErrors} from './validate_style.min.js';
+
 const SUPPORTED_SPEC_VERSION = 8;
 const MAX_SOURCES_IN_STYLE = 15;
 
@@ -22,7 +24,7 @@ function getSourceCount(source: Object): number {
     }
 }
 
-function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<?ValidationError> {
+function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<ValidationError> {
     const allowed = new Set(keys);
     const errors = [];
     Object.keys(obj).forEach(k => {
@@ -35,7 +37,7 @@ function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<
 }
 
 const acceptedSourceTypes = new Set(["vector", "raster", "raster-dem"]);
-function getSourceErrors(source: Object, i: number): Array<?ValidationError> {
+function getSourceErrors(source: Object, i: number): Array<ValidationError> {
     const errors = [];
 
     /*
@@ -66,7 +68,7 @@ function getSourceErrors(source: Object, i: number): Array<?ValidationError> {
     return errors;
 }
 
-function getSourcesErrors(sources: Object): Array<?ValidationError> {
+function getSourcesErrors(sources: Object): Array<ValidationError> {
     const errors = [];
     let count = 0;
 
@@ -88,7 +90,7 @@ function getSourcesErrors(sources: Object): Array<?ValidationError> {
     return errors;
 }
 
-function getRootErrors(style: Object, specKeys: Array<any>): Array<?ValidationError> {
+function getRootErrors(style: Object, specKeys: Array<any>): Array<ValidationError> {
     const errors = [];
 
     /*
@@ -165,7 +167,7 @@ function getRootErrors(style: Object, specKeys: Array<any>): Array<?ValidationEr
  *   var validateMapboxApiSupported = require('mapbox-gl-style-spec/lib/validate_style_mapbox_api_supported.js');
  *   var errors = validateMapboxApiSupported(style);
  */
-export default function validateMapboxApiSupported(style: Object): Array<?ValidationError> {
+export default function validateMapboxApiSupported(style: Object): ValidationErrors {
     let s = style;
     try {
         s = readStyle(s);

package/validate_style.js

@@ -1,8 +1,11 @@
-
-import validateStyleMin from './validate_style.min.js';
+// @flow
+import {validateStyle as validateStyleMin} from './validate_style.min.js';
 import {v8} from './style-spec.js';
 import readStyle from './read_style.js';
 
+import type {ValidationErrors} from './validate_style.min.js';
+import type {StyleSpecification} from './types.js';
+
 /**
  * Validate a Mapbox GL style against the style specification.
  *
@@ -19,7 +22,7 @@ import readStyle from './read_style.js';
  *   var errors = validate(style);
  */
 
-export default function validateStyle(style, styleSpec = v8) {
+export default function validateStyle(style: StyleSpecification | string | Buffer, styleSpec: Object = v8): ValidationErrors {
     let s = style;
 
     try {
@@ -31,9 +34,11 @@ export default function validateStyle(style, styleSpec = v8) {
     return validateStyleMin(s, styleSpec);
 }
 
-export const source = validateStyleMin.source;
-export const light = validateStyleMin.light;
-export const layer = validateStyleMin.layer;
-export const filter = validateStyleMin.filter;
-export const paintProperty = validateStyleMin.paintProperty;
-export const layoutProperty = validateStyleMin.layoutProperty;
+export {
+    validateSource as source,
+    validateLight as light,
+    validateLayer as layer,
+    validateFilter as filter,
+    validatePaintProperty as paintProperty,
+    validateLayoutProperty as layoutProperty
+} from './validate_style.min.js';