@mapbox/mapbox-gl-style-spec 13.28.0 → 14.0.0-beta.2

package/util/properties.js

@@ -1,13 +1,21 @@
 // @flow
 
-import type {StylePropertySpecification} from '../style-spec.js';
+import type {ExpressionSpecification, StylePropertySpecification} from '../style-spec.js';
+
+function expressionHasParameter(expression: ?ExpressionSpecification, parameter: string): boolean {
+    return !!expression && !!expression.parameters && expression.parameters.indexOf(parameter) > -1;
+}
 
 export function supportsPropertyExpression(spec: StylePropertySpecification): boolean {
     return spec['property-type'] === 'data-driven';
 }
 
+export function supportsLightExpression(spec: StylePropertySpecification): boolean {
+    return expressionHasParameter(spec.expression, 'measure-light');
+}
+
 export function supportsZoomExpression(spec: StylePropertySpecification): boolean {
-    return !!spec.expression && spec.expression.parameters.indexOf('zoom') > -1;
+    return expressionHasParameter(spec.expression, 'zoom');
 }
 
 export function supportsInterpolation(spec: StylePropertySpecification): boolean {

package/util/random.js

@@ -0,0 +1,12 @@
+// @flow
+
+// Seeded pseudo random generator function
+export function mulberry32(a: number): () => number {
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}

package/validate/validate.js

@@ -1,10 +1,12 @@
 // @flow
 
 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.js';
 import validateFunction from './validate_function.js';
 import validateExpression from './validate_expression.js';
 import validateObject from './validate_object.js';
@@ -16,7 +18,9 @@ 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';
@@ -26,7 +30,7 @@ import validateProjection from './validate_projection.js';
 
 import type {StyleReference} from '../reference/latest.js';
 import type {StyleSpecification} from '../types.js';
-import type ValidationError from '../error/validation_error.js';
+import getType from '../util/get_type.js';
 
 const VALIDATORS = {
     '*'() {
@@ -42,13 +46,16 @@ const VALIDATORS = {
     'layer': validateLayer,
     'object': validateObject,
     'source': validateSource,
+    'model': validateModel,
     'light': validateLight,
+    'light-3d': validateLights,
     'terrain': validateTerrain,
     'fog': validateFog,
     'string': validateString,
     'formatted': validateFormatted,
     'resolvedImage': validateImage,
-    'projection': validateProjection
+    'projection': validateProjection,
+    'import': validateImport
 };
 
 // Main recursive validation function. Tracks:
@@ -68,20 +75,23 @@ export type ValidationOptions = {
     styleSpec: StyleReference;
 }
 
-export default function validate(options: ValidationOptions): Array<ValidationError> {
+export default function validate(options: ValidationOptions, arrayAsExpression: boolean = false): Array<ValidationError> {
     const value = options.value;
     const valueSpec = options.valueSpec;
     const styleSpec = options.styleSpec;
 
     if (valueSpec.expression && isFunction(unbundle(value))) {
         return validateFunction(options);
-
     } else if (valueSpec.expression && isExpression(deepUnbundle(value))) {
         return validateExpression(options);
-
     } else if (valueSpec.type && VALIDATORS[valueSpec.type]) {
-        return VALIDATORS[valueSpec.type](options);
-
+        const valid = VALIDATORS[valueSpec.type](options);
+        if (arrayAsExpression === true && valid.length > 0 && getType(options.value) === "array") {
+            // Try to validate as an expression
+            return validateExpression(options);
+        } else {
+            return valid;
+        }
     } else {
         const valid = validateObject(extend({}, options, {
             valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec

package/validate/validate_array.js

@@ -56,7 +56,7 @@ export default function validateArray(options: Options): Array<ValidationError>
             style,
             styleSpec,
             key: `${key}[${i}]`
-        }));
+        }, true));
     }
     return errors;
 }

package/validate/validate_filter.js

@@ -11,7 +11,7 @@ import {isExpressionFilter} from '../feature_filter/index.js';
 import type {ValidationOptions} from './validate.js';
 
 type Options = ValidationOptions & {
-    layerType: string;
+    layerType?: string;
 }
 
 export default function validateFilter(options: Options): Array<ValidationError> {
@@ -28,7 +28,7 @@ export default function validateFilter(options: Options): Array<ValidationError>
     }
 }
 
-function validateNonExpressionFilter(options) {
+function validateNonExpressionFilter(options: Options) {
     const value = options.value;
     const key = options.key;
 
@@ -96,12 +96,12 @@ function validateNonExpressionFilter(options) {
     case 'all':
     case 'none':
         for (let i = 1; i < value.length; i++) {
-            errors = errors.concat(validateNonExpressionFilter({
+            errors = errors.concat(validateNonExpressionFilter(({
                 key: `${key}[${i}]`,
                 value: value[i],
                 style: options.style,
                 styleSpec: options.styleSpec
-            }));
+            }: any)));
         }
         break;
 
@@ -114,14 +114,6 @@ function validateNonExpressionFilter(options) {
             errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
         }
         break;
-    case 'within':
-        type = getType(value[1]);
-        if (value.length !== 2) {
-            errors.push(new ValidationError(key, value, `filter array for "${value[0]}" operator must have 2 elements`));
-        } else if (type !== 'object') {
-            errors.push(new ValidationError(`${key}[1]`, value[1], `object expected, ${type} found`));
-        }
-        break;
     }
     return errors;
 }

package/validate/validate_function.js

@@ -21,7 +21,7 @@ export default function validateFunction(options: ValidationOptions): any {
     const functionType = unbundle(options.value.type);
     let stopKeyType;
     let stopDomainValues: {[string | number]: boolean} = {};
-    let previousStopDomainValue;
+    let previousStopDomainValue: ?mixed;
     let previousStopDomainZoom;
 
     const isZoomFunction = functionType !== 'categorical' && options.value.property === undefined;
@@ -161,7 +161,7 @@ export default function validateFunction(options: ValidationOptions): any {
         }));
     }
 
-    function validateStopDomainValue(options: ValidationOptions, stop) {
+    function validateStopDomainValue(options: ValidationOptions, stop: any) {
         const type = getType(options.value);
         const value = unbundle(options.value);
 

package/validate/validate_import.js

@@ -0,0 +1,31 @@
+// @flow
+
+import extend from '../util/extend.js';
+import validateStyle from './validate_style.js';
+import validateObject from './validate_object.js';
+import ValidationError from '../error/validation_error.js';
+
+import type {ValidationOptions} from './validate.js';
+
+export default function validateImport(options: ValidationOptions): ValidationError[] {
+    const {value, styleSpec} = options;
+    const {data, ...importSpec} = value;
+
+    // Preserve __line__ from the value
+    Object.defineProperty(importSpec, '__line__', {
+        value: value.__line__,
+        enumerable: false
+    });
+
+    let errors = validateObject(extend({}, options, {
+        value: importSpec,
+        valueSpec: styleSpec.import
+    }));
+
+    if (data) {
+        const key = `${options.key}.data`;
+        errors = errors.concat(validateStyle(data, styleSpec, {key}));
+    }
+
+    return errors;
+}

package/validate/validate_layer.js

@@ -58,12 +58,13 @@ export default function validateLayer(options: Options): Array<ValidationError>
         if (!parent) {
             if (typeof ref === 'string')
                 errors.push(new ValidationError(key, layer.ref, `ref layer "${ref}" not found`));
+        // $FlowFixMe[prop-missing] - ref is not defined on the LayerSpecification subtypes
         } else if (parent.ref) {
             errors.push(new ValidationError(key, layer.ref, 'ref cannot reference another ref layer'));
         } else {
             type = unbundle(parent.type);
         }
-    } else if (!(type === 'background' || type === 'sky')) {
+    } else if (!(type === 'background' || type === 'sky' || type === 'slot')) {
         if (!layer.source) {
             errors.push(new ValidationError(key, layer, 'missing required property "source"'));
         } else {
@@ -137,7 +138,7 @@ export default function validateLayer(options: Options): Array<ValidationError>
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
                         '*'(options) {
-                            return validatePaintProperty(extend({layerType: type}, options));
+                            return validatePaintProperty(extend({layerType: type, layer}, options));
                         }
                     }
                 });

package/validate/validate_lights.js

@@ -0,0 +1,84 @@
+// @flow
+
+import ValidationError from '../error/validation_error.js';
+import getType from '../util/get_type.js';
+import validate from './validate.js';
+
+import type {ValidationOptions} from './validate.js';
+
+export default function validateLights(options: ValidationOptions): Array<ValidationError> {
+    const light = options.value;
+    let errors = [];
+
+    if (!light) {
+        return errors;
+    }
+
+    const type = getType(light);
+    if (type !== 'object') {
+        errors = errors.concat([new ValidationError('light-3d', light, `object expected, ${type} found`)]);
+        return errors;
+    }
+
+    const styleSpec = options.styleSpec;
+    const lightSpec = styleSpec['light-3d'];
+    const style = options.style;
+
+    for (const key of ['type', 'id']) {
+        if (!(key in light)) {
+            errors = errors.concat([new ValidationError('light-3d', light, `missing property ${key} on light`)]);
+            return errors;
+        }
+    }
+
+    const lightType = `properties_light_${light['type']}`;
+    if (!(lightType in styleSpec)) {
+        errors = errors.concat([new ValidationError('light-3d', light, `Invalid light type ${light['type']}`)]);
+        return errors;
+    }
+
+    const lightPropertySpec = styleSpec[lightType];
+
+    for (const key in light) {
+        if (key === 'properties') {
+            const properties = light[key];
+            const propertiesType = getType(properties);
+            if (propertiesType !== 'object') {
+                errors = errors.concat([new ValidationError('properties', properties, `object expected, ${propertiesType} found`)]);
+                return errors;
+            }
+            for (const propertyKey in properties) {
+                errors = errors.concat(validate({
+                    key: propertyKey,
+                    value: properties[propertyKey],
+                    valueSpec: lightPropertySpec[propertyKey],
+                    style,
+                    styleSpec
+                }));
+            }
+        } else {
+            const transitionMatch = key.match(/^(.*)-transition$/);
+            if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
+                errors = errors.concat(validate({
+                    key,
+                    value: light[key],
+                    valueSpec: styleSpec.transition,
+                    style,
+                    styleSpec
+                }));
+            } else if (lightSpec[key]) {
+                errors = errors.concat(validate({
+                    key,
+                    value: light[key],
+                    valueSpec: lightSpec[key],
+                    style,
+                    styleSpec
+                }));
+            } else {
+                errors = errors.concat([new ValidationError(key, light[key], `unknown property "${key}"`)]);
+            }
+        }
+    }
+
+    return errors;
+}

package/validate/validate_model.js

@@ -0,0 +1,38 @@
+// @flow
+
+import ValidationError from '../error/validation_error.js';
+import getType from '../util/get_type.js';
+
+import type {ValidationOptions} from './validate.js';
+
+// Allow any URL, use dummy base, if it's a relative URL
+function isValidUrl(str: string): boolean {
+    const isRelative = str.indexOf('://') === -1;
+    try {
+        new URL(str, isRelative ? 'http://example.com' : undefined);
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+export default function validateModel(options: ValidationOptions): Array<ValidationError> {
+    const url = options.value;
+    let errors = [];
+
+    if (!url) {
+        return errors;
+    }
+
+    const type = getType(url);
+    if (type !== 'string') {
+        errors = errors.concat([new ValidationError(options.key, url, `string expected, "${type}" found`)]);
+        return errors;
+    }
+
+    if (!isValidUrl(url)) {
+        errors = errors.concat([new ValidationError(options.key, url, `invalid url "${url}"`)]);
+    }
+
+    return errors;
+}

package/validate/validate_property.js

@@ -5,18 +5,22 @@ import ValidationError from '../error/validation_error.js';
 import getType from '../util/get_type.js';
 import {isFunction} from '../function/index.js';
 import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint.js';
-import {supportsPropertyExpression} from '../util/properties.js';
+import {supportsLightExpression, supportsPropertyExpression, supportsZoomExpression} from '../util/properties.js';
+import {isGlobalPropertyConstant} from '../expression/is_constant.js';
 
 import type {ValidationOptions} from './validate.js';
+import {createPropertyExpression} from '../expression/index.js';
 
 export type PropertyValidationOptions = ValidationOptions & {
     objectKey: string;
     layerType: string;
+    layer: Object;
 }
 
 export default function validateProperty(options: PropertyValidationOptions, propertyType: string): Array<ValidationError> {
     const key = options.key;
     const style = options.style;
+    const layer = options.layer;
     const styleSpec = options.styleSpec;
     const value = options.value;
     const propertyKey = options.objectKey;
@@ -40,23 +44,33 @@ export default function validateProperty(options: PropertyValidationOptions, pro
         return [new ValidationError(key, value, `unknown property "${propertyKey}"`)];
     }
 
-    let tokenMatch;
+    let tokenMatch: ?RegExp$matchResult;
     if (getType(value) === 'string' && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
+        const example = `\`{ "type": "identity", "property": ${tokenMatch ? JSON.stringify(tokenMatch[1]) : '"_"'} }\``;
         return [new ValidationError(
             key, value,
             `"${propertyKey}" does not support interpolation syntax\n` +
-                `Use an identity property function instead: \`{ "type": "identity", "property": ${JSON.stringify(tokenMatch[1])} }\`.`)];
+                `Use an identity property function instead: ${example}.`)];
     }
 
     const errors = [];
 
     if (options.layerType === 'symbol') {
-        if (propertyKey === 'text-field' && style && !style.glyphs) {
+        if (propertyKey === 'text-field' && style && !style.glyphs && !style.imports) {
             errors.push(new ValidationError(key, value, 'use of "text-field" requires a style "glyphs" property'));
         }
         if (propertyKey === 'text-font' && isFunction(deepUnbundle(value)) && unbundle(value.type) === 'identity') {
             errors.push(new ValidationError(key, value, '"text-font" does not support identity functions'));
         }
+    } else if (options.layerType === 'model' && propertyType === 'paint' && layer && layer.layout && layer.layout.hasOwnProperty('model-id')) {
+        if (supportsPropertyExpression(valueSpec) && (supportsLightExpression(valueSpec) || supportsZoomExpression(valueSpec))) {
+            // Performance related style spec limitation: zoom and light expressions are not allowed for e.g. trees.
+            const expression = createPropertyExpression(deepUnbundle(value), valueSpec);
+            const expressionObj = (expression.value: any).expression || (expression.value: any)._styleExpression.expression;
+            if (expressionObj && (!isGlobalPropertyConstant(expressionObj, ['zoom']) || !isGlobalPropertyConstant(expressionObj, ['measure-light']))) {
+                errors.push(new ValidationError(key, value, `${propertyKey} does not support zoom or measure-light expressions when the model layer source is vector tile or GeoJSON.`));
+            }
+        }
     }
 
     return errors.concat(validate({

package/validate/validate_source.js

@@ -8,6 +8,7 @@ import validateExpression from './validate_expression.js';
 import validateString from './validate_string.js';
 import getType from '../util/get_type.js';
 
+import type {StyleReference} from '../reference/latest.js';
 import type {ValidationOptions} from './validate.js';
 
 const objectElementValidators = {
@@ -101,7 +102,7 @@ export default function validateSource(options: ValidationOptions): Array<Valida
     }
 }
 
-function getSourceTypeValues(styleSpec) {
+function getSourceTypeValues(styleSpec: StyleReference) {
     return styleSpec.source.reduce((memo, source) => {
         const sourceType = styleSpec[source];
         if (sourceType.type.type === 'enum') {
@@ -111,7 +112,7 @@ function getSourceTypeValues(styleSpec) {
     }, []);
 }
 
-function validatePromoteId({key, value}) {
+function validatePromoteId({key, value}: $Shape<ValidationOptions>) {
     if (getType(value) === 'string') {
         return validateString({key, value});
     } else {

package/validate/validate_style.js

@@ -0,0 +1,29 @@
+// @flow
+import validate from './validate.js';
+import latestStyleSpec from '../reference/latest.js';
+import validateGlyphsURL from './validate_glyphs_url.js';
+
+import ValidationError from '../error/validation_error.js';
+
+import type {ValidationOptions} from './validate.js';
+import type {StyleSpecification} from '../types.js';
+
+type StyleValidationOptions = {
+    key?: ValidationOptions["key"]
+}
+
+export default function validateStyle(style: StyleSpecification, styleSpec: Object = latestStyleSpec, options: StyleValidationOptions = {}): ValidationError[] {
+    const errors = validate({
+        key: options.key || '',
+        value: style,
+        valueSpec: styleSpec.$root,
+        styleSpec,
+        style,
+        objectElementValidators: {
+            glyphs: validateGlyphsURL,
+            '*': () => []
+        }
+    });
+
+    return errors;
+}

package/validate_mapbox_api_supported.js

@@ -36,7 +36,7 @@ function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<
     return errors;
 }
 
-const acceptedSourceTypes = new Set(["vector", "raster", "raster-dem"]);
+const acceptedSourceTypes = new Set(["vector", "raster", "raster-dem", "model", "batched-model"]);
 function getSourceErrors(source: Object, i: number): Array<ValidationError> {
     const errors = [];
 
@@ -68,26 +68,58 @@ function getSourceErrors(source: Object, i: number): Array<ValidationError> {
     return errors;
 }
 
-function getSourcesErrors(sources: Object): Array<ValidationError> {
+function getMaxSourcesErrors(sourcesCount: number): Array<ValidationError> {
     const errors = [];
-    let count = 0;
+    if (sourcesCount > MAX_SOURCES_IN_STYLE) {
+        errors.push(new ValidationError('sources', null, `Styles must contain ${MAX_SOURCES_IN_STYLE} or fewer sources`));
+    }
+    return errors;
+}
+
+function getSourcesErrors(sources: Object): {errors: Array<ValidationError>, sourcesCount: number} {
+    const errors = [];
+    let sourcesCount = 0;
 
     Object.keys(sources).forEach((s: string, i: number) => {
         const sourceErrors = getSourceErrors(sources[s], i);
 
         // If source has errors, skip counting
         if (!sourceErrors.length) {
-            count = count + getSourceCount(sources[s]);
+            sourcesCount = sourcesCount + getSourceCount(sources[s]);
         }
 
         errors.push(...sourceErrors);
     });
 
-    if (count > MAX_SOURCES_IN_STYLE) {
-        errors.push(new ValidationError('sources', null, `Styles must contain ${MAX_SOURCES_IN_STYLE} or fewer sources`));
-    }
+    return {errors, sourcesCount};
+}
 
-    return errors;
+function getImportErrors(imports: Array<Object> = []): {errors: Array<ValidationError>, sourcesCount: number} {
+    let errors: Array<ValidationError> = [];
+
+    let sourcesCount = 0;
+    const validateImports = (imports: Array<Object> = []) => {
+        for (const importSpec of imports) {
+            const style = importSpec.data;
+            if (!style) continue;
+
+            if (style.imports) {
+                validateImports(style.imports);
+            }
+
+            errors = errors.concat(getRootErrors(style, Object.keys(v8.$root)));
+
+            if (style.sources) {
+                const sourcesErrors = getSourcesErrors(style.sources);
+                sourcesCount += sourcesErrors.sourcesCount;
+                errors = errors.concat(sourcesErrors.errors);
+            }
+        }
+    };
+
+    validateImports(imports);
+
+    return {errors, sourcesCount};
 }
 
 function getRootErrors(style: Object, specKeys: Array<any>): Array<ValidationError> {
@@ -109,7 +141,9 @@ function getRootErrors(style: Object, specKeys: Array<any>): Array<ValidationErr
         'created',
         'modified',
         'visibility',
-        'protected'
+        'protected',
+        'models',
+        'lights'
     ];
 
     const allowedKeyErrors = getAllowedKeyErrors(style, [...specKeys, ...optionalRootProperties]);
@@ -178,10 +212,20 @@ export default function validateMapboxApiSupported(style: Object, styleSpec: Obj
     let errors = validateStyle(s, styleSpec)
         .concat(getRootErrors(s, Object.keys(v8.$root)));
 
+    let sourcesCount = 0;
     if (s.sources) {
-        errors = errors.concat(getSourcesErrors(s.sources));
+        const sourcesErrors = getSourcesErrors(s.sources);
+        sourcesCount += sourcesErrors.sourcesCount;
+        errors = errors.concat(sourcesErrors.errors);
+    }
+
+    if (s.imports) {
+        const importsErrors = getImportErrors(s.imports);
+        sourcesCount += importsErrors.sourcesCount;
+        errors = errors.concat(importsErrors.errors);
     }
 
+    errors = errors.concat(getMaxSourcesErrors(sourcesCount));
+
     return errors;
 }
-

package/validate_style.js

@@ -36,9 +36,13 @@ export default function validateStyle(style: StyleSpecification | string | Buffe
 
 export {
     validateSource as source,
+    validateModel as model,
     validateLight as light,
     validateLayer as layer,
     validateFilter as filter,
+    validateLights as lights,
+    validateTerrain as terrain,
+    validateFog as fog,
     validatePaintProperty as paintProperty,
     validateLayoutProperty as layoutProperty
 } from './validate_style.min.js';