mapbox-gl 1.13.2

package/src/style-spec/validate/validate_property.js

@@ -0,0 +1,64 @@
+
+import validate from './validate';
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
+import {isFunction} from '../function';
+import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
+import {supportsPropertyExpression} from '../util/properties';
+
+export default function validateProperty(options, propertyType) {
+    const key = options.key;
+    const style = options.style;
+    const styleSpec = options.styleSpec;
+    const value = options.value;
+    const propertyKey = options.objectKey;
+    const layerSpec = styleSpec[`${propertyType}_${options.layerType}`];
+
+    if (!layerSpec) return [];
+
+    const transitionMatch = propertyKey.match(/^(.*)-transition$/);
+    if (propertyType === 'paint' && transitionMatch && layerSpec[transitionMatch[1]] && layerSpec[transitionMatch[1]].transition) {
+        return validate({
+            key,
+            value,
+            valueSpec: styleSpec.transition,
+            style,
+            styleSpec
+        });
+    }
+
+    const valueSpec = options.valueSpec || layerSpec[propertyKey];
+    if (!valueSpec) {
+        return [new ValidationError(key, value, `unknown property "${propertyKey}"`)];
+    }
+
+    let tokenMatch;
+    if (getType(value) === 'string' && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
+        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])} }\`.`)];
+    }
+
+    const errors = [];
+
+    if (options.layerType === 'symbol') {
+        if (propertyKey === 'text-field' && style && !style.glyphs) {
+            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'));
+        }
+    }
+
+    return errors.concat(validate({
+        key: options.key,
+        value,
+        valueSpec,
+        style,
+        styleSpec,
+        expressionContext: 'property',
+        propertyType,
+        propertyKey
+    }));
+}

package/src/style-spec/validate/validate_source.js

@@ -0,0 +1,111 @@
+
+import ValidationError from '../error/validation_error';
+import {unbundle} from '../util/unbundle_jsonlint';
+import validateObject from './validate_object';
+import validateEnum from './validate_enum';
+import validateExpression from './validate_expression';
+import validateString from './validate_string';
+import getType from '../util/get_type';
+
+const objectElementValidators = {
+    promoteId: validatePromoteId
+};
+
+export default function validateSource(options) {
+    const value = options.value;
+    const key = options.key;
+    const styleSpec = options.styleSpec;
+    const style = options.style;
+
+    if (!value.type) {
+        return [new ValidationError(key, value, '"type" is required')];
+    }
+
+    const type = unbundle(value.type);
+    let errors;
+
+    switch (type) {
+    case 'vector':
+    case 'raster':
+    case 'raster-dem':
+        errors = validateObject({
+            key,
+            value,
+            valueSpec: styleSpec[`source_${type.replace('-', '_')}`],
+            style: options.style,
+            styleSpec,
+            objectElementValidators
+        });
+        return errors;
+
+    case 'geojson':
+        errors = validateObject({
+            key,
+            value,
+            valueSpec: styleSpec.source_geojson,
+            style,
+            styleSpec,
+            objectElementValidators
+        });
+        if (value.cluster) {
+            for (const prop in value.clusterProperties) {
+                const [operator, mapExpr] = value.clusterProperties[prop];
+                const reduceExpr = typeof operator === 'string' ? [operator, ['accumulated'], ['get', prop]] : operator;
+
+                errors.push(...validateExpression({
+                    key: `${key}.${prop}.map`,
+                    value: mapExpr,
+                    expressionContext: 'cluster-map'
+                }));
+                errors.push(...validateExpression({
+                    key: `${key}.${prop}.reduce`,
+                    value: reduceExpr,
+                    expressionContext: 'cluster-reduce'
+                }));
+            }
+        }
+        return errors;
+
+    case 'video':
+        return validateObject({
+            key,
+            value,
+            valueSpec: styleSpec.source_video,
+            style,
+            styleSpec
+        });
+
+    case 'image':
+        return validateObject({
+            key,
+            value,
+            valueSpec: styleSpec.source_image,
+            style,
+            styleSpec
+        });
+
+    case 'canvas':
+        return [new ValidationError(key, null, `Please use runtime APIs to add canvas sources, rather than including them in stylesheets.`, 'source.canvas')];
+
+    default:
+        return validateEnum({
+            key: `${key}.type`,
+            value: value.type,
+            valueSpec: {values: ['vector', 'raster', 'raster-dem', 'geojson', 'video', 'image']},
+            style,
+            styleSpec
+        });
+    }
+}
+
+function validatePromoteId({key, value}) {
+    if (getType(value) === 'string') {
+        return validateString({key, value});
+    } else {
+        const errors = [];
+        for (const prop in value) {
+            errors.push(...validateString({key: `${key}.${prop}`, value: value[prop]}));
+        }
+        return errors;
+    }
+}

package/src/style-spec/validate/validate_string.js

@@ -0,0 +1,15 @@
+
+import getType from '../util/get_type';
+import ValidationError from '../error/validation_error';
+
+export default function validateString(options) {
+    const value = options.value;
+    const key = options.key;
+    const type = getType(value);
+
+    if (type !== 'string') {
+        return [new ValidationError(key, value, `string expected, ${type} found`)];
+    }
+
+    return [];
+}

package/src/style-spec/validate_mapbox_api_supported.js

@@ -0,0 +1,171 @@
+// @flow
+
+import validateStyle from './validate_style.min';
+import {v8} from './style-spec';
+import readStyle from './read_style';
+import ValidationError from './error/validation_error';
+import getType from './util/get_type';
+
+const SUPPORTED_SPEC_VERSION = 8;
+const MAX_SOURCES_IN_STYLE = 15;
+
+function isValid(value: ?string, regex: RegExp): boolean {
+    if (!value || getType(value) !== 'string') return true;
+    return !!value.match(regex);
+}
+
+function getSourceCount(source: Object): number {
+    if (source.url) {
+        return source.url.split(',').length;
+    } else {
+        return 0;
+    }
+}
+
+function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<?ValidationError> {
+    const allowed = new Set(keys);
+    const errors = [];
+    Object.keys(obj).forEach(k => {
+        if (!allowed.has(k)) {
+            const prop = path ? `${path}.${k}` : null;
+            errors.push(new ValidationError(prop, obj[k], `Unsupported property "${k}"`));
+        }
+    });
+    return errors;
+}
+
+function getSourceErrors(source: Object, i: number): Array<?ValidationError> {
+    const errors = [];
+
+    /*
+     * Inlined sources are not supported by the Mapbox Styles API, so only
+     * "type", "url", and "tileSize" properties are valid
+     */
+    const sourceKeys = ['type', 'url', 'tileSize'];
+    errors.push(...getAllowedKeyErrors(source, sourceKeys, 'source'));
+
+    /*
+     * "source" is required. Valid examples:
+     * mapbox://mapbox.abcd1234
+     * mapbox://penny.abcd1234
+     * mapbox://mapbox.abcd1234,penny.abcd1234
+     */
+    const sourceUrlPattern = /^mapbox:\/\/([^/]*)$/;
+    if (!isValid(source.url, sourceUrlPattern)) {
+        errors.push(new ValidationError(`sources[${i}]`, source.url, 'Source url must be a valid Mapbox tileset url'));
+    }
+
+    return errors;
+}
+
+function getSourcesErrors(sources: Object): Array<?ValidationError> {
+    const errors = [];
+    let count = 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]);
+        }
+
+        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;
+}
+
+function getRootErrors(style: Object, specKeys: Array<any>): Array<?ValidationError> {
+    const errors = [];
+
+    /*
+     * The following keys are optional but fully managed by the Mapbox Styles
+     * API. Values on stylesheet on POST or PATCH will be ignored: "owner",
+     * "id", "cacheControl", "draft", "created", "modified"
+     *
+     * The following keys are optional. The Mapbox Styles API respects value on
+     * stylesheet on PATCH, but ignores the value on POST: "visibility"
+     */
+    const optionalRootProperties = [
+        'owner',
+        'id',
+        'cacheControl',
+        'draft',
+        'created',
+        'modified',
+        'visibility'
+    ];
+
+    const allowedKeyErrors = getAllowedKeyErrors(style, [...specKeys, ...optionalRootProperties]);
+    errors.push(...allowedKeyErrors);
+
+    if (style.version > SUPPORTED_SPEC_VERSION || style.version < SUPPORTED_SPEC_VERSION) {
+        errors.push(new ValidationError('version', style.version, `Style version must be ${SUPPORTED_SPEC_VERSION}`));
+    }
+
+    /*
+     * "glyphs" is optional. If present, valid examples:
+     * mapbox://fonts/penny/{fontstack}/{range}.pbf
+     * mapbox://fonts/mapbox/{fontstack}/{range}.pbf
+     */
+    const glyphUrlPattern = /^mapbox:\/\/fonts\/([^/]*)\/{fontstack}\/{range}.pbf$/;
+    if (!isValid(style.glyphs, glyphUrlPattern)) {
+        errors.push(new ValidationError('glyphs', style.glyphs, 'Styles must reference glyphs hosted by Mapbox'));
+    }
+
+    /*
+     * "sprite" is optional. If present, valid examples:
+     * mapbox://sprites/penny/abcd1234
+     * mapbox://sprites/mapbox/abcd1234/draft
+     * mapbox://sprites/cyrus/abcd1234/abcd1234
+     */
+    const spriteUrlPattern = /^mapbox:\/\/sprites\/([^/]*)\/([^/]*)\/?([^/]*)?$/;
+    if (!isValid(style.sprite, spriteUrlPattern)) {
+        errors.push(new ValidationError('sprite', style.sprite, 'Styles must reference sprites hosted by Mapbox'));
+    }
+
+    /*
+     * "visibility" is optional. If present, valid examples:
+     * "private"
+     * "public"
+     */
+    const visibilityPattern = /^(public|private)$/;
+    if (!isValid(style.visibility, visibilityPattern)) {
+        errors.push(new ValidationError('visibility', style.visibility, 'Style visibility must be public or private'));
+    }
+
+    return errors;
+}
+
+/**
+ * Validate a Mapbox GL style against the style specification and check for
+ * compatibility with the Mapbox Styles API.
+ *
+ * @param {Object} style The style to be validated.
+ * @returns {Array<ValidationError>}
+ * @example
+ *   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> {
+    let s = style;
+    try {
+        s = readStyle(s);
+    } catch (e) {
+        return [e];
+    }
+
+    let errors = validateStyle(s, v8)
+        .concat(getRootErrors(s, Object.keys(v8.$root)));
+
+    if (s.sources) {
+        errors = errors.concat(getSourcesErrors(s.sources));
+    }
+
+    return errors;
+}

package/src/style-spec/validate_style.js

@@ -0,0 +1,39 @@
+
+import validateStyleMin from './validate_style.min';
+import {v8} from './style-spec';
+import readStyle from './read_style';
+
+/**
+ * Validate a Mapbox GL style against the style specification.
+ *
+ * @private
+ * @alias validate
+ * @param {Object|String|Buffer} style The style to be validated. If a `String`
+ *     or `Buffer` is provided, the returned errors will contain line numbers.
+ * @param {Object} [styleSpec] The style specification to validate against.
+ *     If omitted, the spec version is inferred from the stylesheet.
+ * @returns {Array<ValidationError|ParsingError>}
+ * @example
+ *   var validate = require('mapbox-gl-style-spec').validate;
+ *   var style = fs.readFileSync('./style.json', 'utf8');
+ *   var errors = validate(style);
+ */
+
+export default function validateStyle(style, styleSpec = v8) {
+    let s = style;
+
+    try {
+        s = readStyle(s);
+    } catch (e) {
+        return [e];
+    }
+
+    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;

package/src/style-spec/validate_style.min.js

@@ -0,0 +1,78 @@
+
+import validateConstants from './validate/validate_constants';
+import validate from './validate/validate';
+import latestStyleSpec from './reference/latest';
+import validateGlyphsURL from './validate/validate_glyphs_url';
+
+import validateSource from './validate/validate_source';
+import validateLight from './validate/validate_light';
+import validateLayer from './validate/validate_layer';
+import validateFilter from './validate/validate_filter';
+import validatePaintProperty from './validate/validate_paint_property';
+import validateLayoutProperty from './validate/validate_layout_property';
+
+/**
+ * Validate a Mapbox GL style against the style specification. This entrypoint,
+ * `mapbox-gl-style-spec/lib/validate_style.min`, is designed to produce as
+ * small a browserify bundle as possible by omitting unnecessary functionality
+ * and legacy style specifications.
+ *
+ * @private
+ * @param {Object} style The style to be validated.
+ * @param {Object} [styleSpec] The style specification to validate against.
+ *     If omitted, the latest style spec is used.
+ * @returns {Array<ValidationError>}
+ * @example
+ *   var validate = require('mapbox-gl-style-spec/lib/validate_style.min');
+ *   var errors = validate(style);
+ */
+function validateStyleMin(style, styleSpec = latestStyleSpec) {
+
+    let errors = [];
+
+    errors = errors.concat(validate({
+        key: '',
+        value: style,
+        valueSpec: styleSpec.$root,
+        styleSpec,
+        style,
+        objectElementValidators: {
+            glyphs: validateGlyphsURL,
+            '*'() {
+                return [];
+            }
+        }
+    }));
+
+    if (style.constants) {
+        errors = errors.concat(validateConstants({
+            key: 'constants',
+            value: style.constants,
+            style,
+            styleSpec
+        }));
+    }
+
+    return sortErrors(errors);
+}
+
+validateStyleMin.source = wrapCleanErrors(validateSource);
+validateStyleMin.light = wrapCleanErrors(validateLight);
+validateStyleMin.layer = wrapCleanErrors(validateLayer);
+validateStyleMin.filter = wrapCleanErrors(validateFilter);
+validateStyleMin.paintProperty = wrapCleanErrors(validatePaintProperty);
+validateStyleMin.layoutProperty = wrapCleanErrors(validateLayoutProperty);
+
+function sortErrors(errors) {
+    return [].concat(errors).sort((a, b) => {
+        return a.line - b.line;
+    });
+}
+
+function wrapCleanErrors(inner) {
+    return function(...args) {
+        return sortErrors(inner.apply(this, args));
+    };
+}
+
+export default validateStyleMin;

package/src/style-spec/visit.js

@@ -0,0 +1,77 @@
+// @flow
+
+import Reference from './reference/v8.json';
+import type {StylePropertySpecification} from './style-spec';
+import type {
+    StyleSpecification,
+    SourceSpecification,
+    LayerSpecification,
+    PropertyValueSpecification,
+    DataDrivenPropertyValueSpecification
+} from './types';
+
+function getPropertyReference(propertyName): StylePropertySpecification {
+    for (let i = 0; i < Reference.layout.length; i++) {
+        for (const key in Reference[Reference.layout[i]]) {
+            if (key === propertyName) return (Reference[Reference.layout[i]][key]: any);
+        }
+    }
+    for (let i = 0; i < Reference.paint.length; i++) {
+        for (const key in Reference[Reference.paint[i]]) {
+            if (key === propertyName) return (Reference[Reference.paint[i]][key]: any);
+        }
+    }
+
+    return (null: any);
+}
+
+export function eachSource(style: StyleSpecification, callback: (_: SourceSpecification) => void) {
+    for (const k in style.sources) {
+        callback(style.sources[k]);
+    }
+}
+
+export function eachLayer(style: StyleSpecification, callback: (_: LayerSpecification) => void) {
+    for (const layer of style.layers) {
+        callback(layer);
+    }
+}
+
+type PropertyCallback = ({
+    path: [string, 'paint' | 'layout', string], // [layerid, paint/layout, property key]
+    key: string,
+    value: PropertyValueSpecification<mixed> | DataDrivenPropertyValueSpecification<mixed>,
+    reference: StylePropertySpecification,
+    set: (PropertyValueSpecification<mixed> | DataDrivenPropertyValueSpecification<mixed>) => void
+}) => void;
+
+export function eachProperty(
+    style: StyleSpecification,
+    options: {paint?: boolean, layout?: boolean},
+    callback: PropertyCallback
+) {
+    function inner(layer, propertyType: 'paint' | 'layout') {
+        const properties = (layer[propertyType]: any);
+        if (!properties) return;
+        Object.keys(properties).forEach((key) => {
+            callback({
+                path: [layer.id, propertyType, key],
+                key,
+                value: properties[key],
+                reference: getPropertyReference(key),
+                set(x) {
+                    properties[key] = x;
+                }
+            });
+        });
+    }
+
+    eachLayer(style, (layer) => {
+        if (options.paint) {
+            inner(layer, 'paint');
+        }
+        if (options.layout) {
+            inner(layer, 'layout');
+        }
+    });
+}

package/src/symbol/anchor.js

@@ -0,0 +1,26 @@
+// @flow
+
+import Point from '@mapbox/point-geometry';
+
+import {register} from '../util/web_worker_transfer';
+
+class Anchor extends Point {
+    angle: any;
+    segment: number | void;
+
+    constructor(x: number, y: number, angle: number, segment?: number) {
+        super(x, y);
+        this.angle = angle;
+        if (segment !== undefined) {
+            this.segment = segment;
+        }
+    }
+
+    clone() {
+        return new Anchor(this.x, this.y, this.angle, this.segment);
+    }
+}
+
+register('Anchor', Anchor);
+
+export default Anchor;

package/src/symbol/check_max_angle.js

@@ -0,0 +1,81 @@
+// @flow
+
+export default checkMaxAngle;
+
+import type Point from '@mapbox/point-geometry';
+import type Anchor from './anchor';
+
+/**
+ * Labels placed around really sharp angles aren't readable. Check if any
+ * part of the potential label has a combined angle that is too big.
+ *
+ * @param line
+ * @param anchor The point on the line around which the label is anchored.
+ * @param labelLength The length of the label in geometry units.
+ * @param windowSize The check fails if the combined angles within a part of the line that is `windowSize` long is too big.
+ * @param maxAngle The maximum combined angle that any window along the label is allowed to have.
+ *
+ * @returns {boolean} whether the label should be placed
+ * @private
+ */
+function checkMaxAngle(line: Array<Point>, anchor: Anchor, labelLength: number, windowSize: number, maxAngle: number) {
+
+    // horizontal labels always pass
+    if (anchor.segment === undefined) return true;
+
+    let p = anchor;
+    let index = anchor.segment + 1;
+    let anchorDistance = 0;
+
+    // move backwards along the line to the first segment the label appears on
+    while (anchorDistance > -labelLength / 2) {
+        index--;
+
+        // there isn't enough room for the label after the beginning of the line
+        if (index < 0) return false;
+
+        anchorDistance -= line[index].dist(p);
+        p = line[index];
+    }
+
+    anchorDistance += line[index].dist(line[index + 1]);
+    index++;
+
+    // store recent corners and their total angle difference
+    const recentCorners = [];
+    let recentAngleDelta = 0;
+
+    // move forwards by the length of the label and check angles along the way
+    while (anchorDistance < labelLength / 2) {
+        const prev = line[index - 1];
+        const current = line[index];
+        const next = line[index + 1];
+
+        // there isn't enough room for the label before the end of the line
+        if (!next) return false;
+
+        let angleDelta = prev.angleTo(current) - current.angleTo(next);
+        // restrict angle to -pi..pi range
+        angleDelta = Math.abs(((angleDelta + 3 * Math.PI) % (Math.PI * 2)) - Math.PI);
+
+        recentCorners.push({
+            distance: anchorDistance,
+            angleDelta
+        });
+        recentAngleDelta += angleDelta;
+
+        // remove corners that are far enough away from the list of recent anchors
+        while (anchorDistance - recentCorners[0].distance > windowSize) {
+            recentAngleDelta -= recentCorners.shift().angleDelta;
+        }
+
+        // the sum of angles within the window area exceeds the maximum allowed value. check fails.
+        if (recentAngleDelta > maxAngle) return false;
+
+        index++;
+        anchorDistance += current.dist(next);
+    }
+
+    // no part of the line had an angle greater than the maximum allowed. check passes.
+    return true;
+}