@mapgis/mapbox-gl 16.0.0 → 16.2.0

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

@@ -1,64 +0,0 @@
-
-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

@@ -1,111 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,171 +0,0 @@
-// @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

@@ -1,39 +0,0 @@
-
-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

@@ -1,78 +0,0 @@
-
-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

@@ -1,77 +0,0 @@
-// @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

@@ -1,26 +0,0 @@
-// @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

@@ -1,81 +0,0 @@
-// @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;
-}