@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,111 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import validateExpression from './validate_expression';
-import validateEnum from './validate_enum';
-import getType from '../util/get_type';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
-import extend from '../util/extend';
-import {isExpressionFilter} from '../feature_filter';
-
-export default function validateFilter(options) {
-    if (isExpressionFilter(deepUnbundle(options.value))) {
-        return validateExpression(extend({}, options, {
-            expressionContext: 'filter',
-            valueSpec: {value: 'boolean'}
-        }));
-    } else {
-        return validateNonExpressionFilter(options);
-    }
-}
-
-function validateNonExpressionFilter(options) {
-    const value = options.value;
-    const key = options.key;
-
-    if (getType(value) !== 'array') {
-        return [new ValidationError(key, value, `array expected, ${getType(value)} found`)];
-    }
-
-    const styleSpec = options.styleSpec;
-    let type;
-
-    let errors = [];
-
-    if (value.length < 1) {
-        return [new ValidationError(key, value, 'filter array must have at least 1 element')];
-    }
-
-    errors = errors.concat(validateEnum({
-        key: `${key}[0]`,
-        value: value[0],
-        valueSpec: styleSpec.filter_operator,
-        style: options.style,
-        styleSpec: options.styleSpec
-    }));
-
-    switch (unbundle(value[0])) {
-    case '<':
-    case '<=':
-    case '>':
-    case '>=':
-        if (value.length >= 2 && unbundle(value[1]) === '$type') {
-            errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${value[0]}"`));
-        }
-        /* falls through */
-    case '==':
-    case '!=':
-        if (value.length !== 3) {
-            errors.push(new ValidationError(key, value, `filter array for operator "${value[0]}" must have 3 elements`));
-        }
-        /* falls through */
-    case 'in':
-    case '!in':
-        if (value.length >= 2) {
-            type = getType(value[1]);
-            if (type !== 'string') {
-                errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
-            }
-        }
-        for (let i = 2; i < value.length; i++) {
-            type = getType(value[i]);
-            if (unbundle(value[1]) === '$type') {
-                errors = errors.concat(validateEnum({
-                    key: `${key}[${i}]`,
-                    value: value[i],
-                    valueSpec: styleSpec.geometry_type,
-                    style: options.style,
-                    styleSpec: options.styleSpec
-                }));
-            } else if (type !== 'string' && type !== 'number' && type !== 'boolean') {
-                errors.push(new ValidationError(`${key}[${i}]`, value[i], `string, number, or boolean expected, ${type} found`));
-            }
-        }
-        break;
-
-    case 'any':
-    case 'all':
-    case 'none':
-        for (let i = 1; i < value.length; i++) {
-            errors = errors.concat(validateNonExpressionFilter({
-                key: `${key}[${i}]`,
-                value: value[i],
-                style: options.style,
-                styleSpec: options.styleSpec
-            }));
-        }
-        break;
-
-    case 'has':
-    case '!has':
-        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 !== 'string') {
-            errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
-        }
-        break;
-
-    }
-
-    return errors;
-}

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

@@ -1,11 +0,0 @@
-// @flow
-import validateExpression from './validate_expression';
-import validateString from './validate_string';
-
-export default function validateFormatted(options: any) {
-    if (validateString(options).length === 0) {
-        return [];
-    }
-
-    return validateExpression(options);
-}

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

@@ -1,207 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import getType from '../util/get_type';
-import validate from './validate';
-import validateObject from './validate_object';
-import validateArray from './validate_array';
-import validateNumber from './validate_number';
-import {isExpression} from '../expression';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
-import {
-    supportsPropertyExpression,
-    supportsZoomExpression,
-    supportsInterpolation
-} from '../util/properties';
-
-export default function validateFunction(options) {
-    const functionValueSpec = options.valueSpec;
-    const functionType = unbundle(options.value.type);
-    let stopKeyType;
-    let stopDomainValues = {};
-    let previousStopDomainValue;
-    let previousStopDomainZoom;
-
-    const isZoomFunction = functionType !== 'categorical' && options.value.property === undefined;
-    const isPropertyFunction = !isZoomFunction;
-    const isZoomAndPropertyFunction =
-        getType(options.value.stops) === 'array' &&
-        getType(options.value.stops[0]) === 'array' &&
-        getType(options.value.stops[0][0]) === 'object';
-
-    const errors = validateObject({
-        key: options.key,
-        value: options.value,
-        valueSpec: options.styleSpec.function,
-        style: options.style,
-        styleSpec: options.styleSpec,
-        objectElementValidators: {
-            stops: validateFunctionStops,
-            default: validateFunctionDefault
-        }
-    });
-
-    if (functionType === 'identity' && isZoomFunction) {
-        errors.push(new ValidationError(options.key, options.value, 'missing required property "property"'));
-    }
-
-    if (functionType !== 'identity' && !options.value.stops) {
-        errors.push(new ValidationError(options.key, options.value, 'missing required property "stops"'));
-    }
-
-    if (functionType === 'exponential' && options.valueSpec.expression && !supportsInterpolation(options.valueSpec)) {
-        errors.push(new ValidationError(options.key, options.value, 'exponential functions not supported'));
-    }
-
-    if (options.styleSpec.$version >= 8) {
-        if (isPropertyFunction && !supportsPropertyExpression(options.valueSpec)) {
-            errors.push(new ValidationError(options.key, options.value, 'property functions not supported'));
-        } else if (isZoomFunction && !supportsZoomExpression(options.valueSpec)) {
-            errors.push(new ValidationError(options.key, options.value, 'zoom functions not supported'));
-        }
-    }
-
-    if ((functionType === 'categorical' || isZoomAndPropertyFunction) && options.value.property === undefined) {
-        errors.push(new ValidationError(options.key, options.value, '"property" property is required'));
-    }
-
-    return errors;
-
-    function validateFunctionStops(options) {
-        if (functionType === 'identity') {
-            return [new ValidationError(options.key, options.value, 'identity function may not have a "stops" property')];
-        }
-
-        let errors = [];
-        const value = options.value;
-
-        errors = errors.concat(validateArray({
-            key: options.key,
-            value,
-            valueSpec: options.valueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec,
-            arrayElementValidator: validateFunctionStop
-        }));
-
-        if (getType(value) === 'array' && value.length === 0) {
-            errors.push(new ValidationError(options.key, value, 'array must have at least one stop'));
-        }
-
-        return errors;
-    }
-
-    function validateFunctionStop(options) {
-        let errors = [];
-        const value = options.value;
-        const key = options.key;
-
-        if (getType(value) !== 'array') {
-            return [new ValidationError(key, value, `array expected, ${getType(value)} found`)];
-        }
-
-        if (value.length !== 2) {
-            return [new ValidationError(key, value, `array length 2 expected, length ${value.length} found`)];
-        }
-
-        if (isZoomAndPropertyFunction) {
-            if (getType(value[0]) !== 'object') {
-                return [new ValidationError(key, value, `object expected, ${getType(value[0])} found`)];
-            }
-            if (value[0].zoom === undefined) {
-                return [new ValidationError(key, value, 'object stop key must have zoom')];
-            }
-            if (value[0].value === undefined) {
-                return [new ValidationError(key, value, 'object stop key must have value')];
-            }
-            if (previousStopDomainZoom && previousStopDomainZoom > unbundle(value[0].zoom)) {
-                return [new ValidationError(key, value[0].zoom, 'stop zoom values must appear in ascending order')];
-            }
-            if (unbundle(value[0].zoom) !== previousStopDomainZoom) {
-                previousStopDomainZoom = unbundle(value[0].zoom);
-                previousStopDomainValue = undefined;
-                stopDomainValues = {};
-            }
-            errors = errors.concat(validateObject({
-                key: `${key}[0]`,
-                value: value[0],
-                valueSpec: {zoom: {}},
-                style: options.style,
-                styleSpec: options.styleSpec,
-                objectElementValidators: {zoom: validateNumber, value: validateStopDomainValue}
-            }));
-        } else {
-            errors = errors.concat(validateStopDomainValue({
-                key: `${key}[0]`,
-                value: value[0],
-                valueSpec: {},
-                style: options.style,
-                styleSpec: options.styleSpec
-            }, value));
-        }
-
-        if (isExpression(deepUnbundle(value[1]))) {
-            return errors.concat([new ValidationError(`${key}[1]`, value[1], 'expressions are not allowed in function stops.')]);
-        }
-
-        return errors.concat(validate({
-            key: `${key}[1]`,
-            value: value[1],
-            valueSpec: functionValueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec
-        }));
-    }
-
-    function validateStopDomainValue(options, stop) {
-        const type = getType(options.value);
-        const value = unbundle(options.value);
-
-        const reportValue = options.value !== null ? options.value : stop;
-
-        if (!stopKeyType) {
-            stopKeyType = type;
-        } else if (type !== stopKeyType) {
-            return [new ValidationError(options.key, reportValue, `${type} stop domain type must match previous stop domain type ${stopKeyType}`)];
-        }
-
-        if (type !== 'number' && type !== 'string' && type !== 'boolean') {
-            return [new ValidationError(options.key, reportValue, 'stop domain value must be a number, string, or boolean')];
-        }
-
-        if (type !== 'number' && functionType !== 'categorical') {
-            let message = `number expected, ${type} found`;
-            if (supportsPropertyExpression(functionValueSpec) && functionType === undefined) {
-                message += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.';
-            }
-            return [new ValidationError(options.key, reportValue, message)];
-        }
-
-        if (functionType === 'categorical' && type === 'number' && (!isFinite(value) || Math.floor(value) !== value)) {
-            return [new ValidationError(options.key, reportValue, `integer expected, found ${value}`)];
-        }
-
-        if (functionType !== 'categorical' && type === 'number' && previousStopDomainValue !== undefined && value < previousStopDomainValue) {
-            return [new ValidationError(options.key, reportValue, 'stop domain values must appear in ascending order')];
-        } else {
-            previousStopDomainValue = value;
-        }
-
-        if (functionType === 'categorical' && value in stopDomainValues) {
-            return [new ValidationError(options.key, reportValue, 'stop domain values must be unique')];
-        } else {
-            stopDomainValues[value] = true;
-        }
-
-        return [];
-    }
-
-    function validateFunctionDefault(options) {
-        return validate({
-            key: options.key,
-            value: options.value,
-            valueSpec: functionValueSpec,
-            style: options.style,
-            styleSpec: options.styleSpec
-        });
-    }
-}

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

@@ -1,21 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import validateString from './validate_string';
-
-export default function(options) {
-    const value = options.value;
-    const key = options.key;
-
-    const errors = validateString(options);
-    if (errors.length) return errors;
-
-    if (value.indexOf('{fontstack}') === -1) {
-        errors.push(new ValidationError(key, value, '"glyphs" url must include a "{fontstack}" token'));
-    }
-
-    if (value.indexOf('{range}') === -1) {
-        errors.push(new ValidationError(key, value, '"glyphs" url must include a "{range}" token'));
-    }
-
-    return errors;
-}

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

@@ -1,11 +0,0 @@
-// @flow
-import validateExpression from './validate_expression';
-import validateString from './validate_string';
-
-export default function validateImage(options: any) {
-    if (validateString(options).length === 0) {
-        return [];
-    }
-
-    return validateExpression(options);
-}

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

@@ -1,134 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import {unbundle} from '../util/unbundle_jsonlint';
-import validateObject from './validate_object';
-import validateFilter from './validate_filter';
-import validatePaintProperty from './validate_paint_property';
-import validateLayoutProperty from './validate_layout_property';
-import validateSpec from './validate';
-import extend from '../util/extend';
-
-export default function validateLayer(options) {
-    let errors = [];
-
-    const layer = options.value;
-    const key = options.key;
-    const style = options.style;
-    const styleSpec = options.styleSpec;
-
-    if (!layer.type && !layer.ref) {
-        errors.push(new ValidationError(key, layer, 'either "type" or "ref" is required'));
-    }
-    let type = unbundle(layer.type);
-    const ref = unbundle(layer.ref);
-
-    if (layer.id) {
-        const layerId = unbundle(layer.id);
-        for (let i = 0; i < options.arrayIndex; i++) {
-            const otherLayer = style.layers[i];
-            if (unbundle(otherLayer.id) === layerId) {
-                errors.push(new ValidationError(key, layer.id, `duplicate layer id "${layer.id}", previously used at line ${otherLayer.id.__line__}`));
-            }
-        }
-    }
-
-    if ('ref' in layer) {
-        ['type', 'source', 'source-layer', 'filter', 'layout'].forEach((p) => {
-            if (p in layer) {
-                errors.push(new ValidationError(key, layer[p], `"${p}" is prohibited for ref layers`));
-            }
-        });
-
-        let parent;
-
-        style.layers.forEach((layer) => {
-            if (unbundle(layer.id) === ref) parent = layer;
-        });
-
-        if (!parent) {
-            errors.push(new ValidationError(key, layer.ref, `ref layer "${ref}" not found`));
-        } 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') {
-        if (!layer.source) {
-            errors.push(new ValidationError(key, layer, 'missing required property "source"'));
-        } else {
-            const source = style.sources && style.sources[layer.source];
-            const sourceType = source && unbundle(source.type);
-            if (!source) {
-                errors.push(new ValidationError(key, layer.source, `source "${layer.source}" not found`));
-            } else if (sourceType === 'vector' && type === 'raster') {
-                errors.push(new ValidationError(key, layer.source, `layer "${layer.id}" requires a raster source`));
-            } else if (sourceType === 'raster' && type !== 'raster') {
-                errors.push(new ValidationError(key, layer.source, `layer "${layer.id}" requires a vector source`));
-            } else if (sourceType === 'vector' && !layer['source-layer']) {
-                errors.push(new ValidationError(key, layer, `layer "${layer.id}" must specify a "source-layer"`));
-            } else if (sourceType === 'raster-dem' && type !== 'hillshade') {
-                errors.push(new ValidationError(key, layer.source, 'raster-dem source can only be used with layer type \'hillshade\'.'));
-            } else if (type === 'line' && layer.paint && layer.paint['line-gradient'] &&
-                       (sourceType !== 'geojson' || !source.lineMetrics)) {
-                errors.push(new ValidationError(key, layer, `layer "${layer.id}" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`));
-            }
-        }
-    }
-
-    errors = errors.concat(validateObject({
-        key,
-        value: layer,
-        valueSpec: styleSpec.layer,
-        style: options.style,
-        styleSpec: options.styleSpec,
-        objectElementValidators: {
-            '*'() {
-                return [];
-            },
-            // We don't want to enforce the spec's `"requires": true` for backward compatibility with refs;
-            // the actual requirement is validated above. See https://github.com/mapbox/mapbox-gl-js/issues/5772.
-            type() {
-                return validateSpec({
-                    key: `${key}.type`,
-                    value: layer.type,
-                    valueSpec: styleSpec.layer.type,
-                    style: options.style,
-                    styleSpec: options.styleSpec,
-                    object: layer,
-                    objectKey: 'type'
-                });
-            },
-            filter: validateFilter,
-            layout(options) {
-                return validateObject({
-                    layer,
-                    key: options.key,
-                    value: options.value,
-                    style: options.style,
-                    styleSpec: options.styleSpec,
-                    objectElementValidators: {
-                        '*'(options) {
-                            return validateLayoutProperty(extend({layerType: type}, options));
-                        }
-                    }
-                });
-            },
-            paint(options) {
-                return validateObject({
-                    layer,
-                    key: options.key,
-                    value: options.value,
-                    style: options.style,
-                    styleSpec: options.styleSpec,
-                    objectElementValidators: {
-                        '*'(options) {
-                            return validatePaintProperty(extend({layerType: type}, options));
-                        }
-                    }
-                });
-            }
-        }
-    }));
-
-    return errors;
-}

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

@@ -1,6 +0,0 @@
-
-import validateProperty from './validate_property';
-
-export default function validateLayoutProperty(options) {
-    return validateProperty(options, 'layout');
-}

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

@@ -1,47 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import getType from '../util/get_type';
-import validate from './validate';
-
-export default function validateLight(options) {
-    const light = options.value;
-    const styleSpec = options.styleSpec;
-    const lightSpec = styleSpec.light;
-    const style = options.style;
-
-    let errors = [];
-
-    const rootType = getType(light);
-    if (light === undefined) {
-        return errors;
-    } else if (rootType !== 'object') {
-        errors = errors.concat([new ValidationError('light', light, `object expected, ${rootType} found`)]);
-        return errors;
-    }
-
-    for (const key in light) {
-        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/src/style-spec/validate/validate_number.js

@@ -1,29 +0,0 @@
-
-import getType from '../util/get_type';
-import ValidationError from '../error/validation_error';
-
-export default function validateNumber(options) {
-    const key = options.key;
-    const value = options.value;
-    const valueSpec = options.valueSpec;
-    let type = getType(value);
-
-    // eslint-disable-next-line no-self-compare
-    if (type === 'number' && value !== value) {
-        type = 'NaN';
-    }
-
-    if (type !== 'number') {
-        return [new ValidationError(key, value, `number expected, ${type} found`)];
-    }
-
-    if ('minimum' in valueSpec && value < valueSpec.minimum) {
-        return [new ValidationError(key, value, `${value} is less than the minimum value ${valueSpec.minimum}`)];
-    }
-
-    if ('maximum' in valueSpec && value > valueSpec.maximum) {
-        return [new ValidationError(key, value, `${value} is greater than the maximum value ${valueSpec.maximum}`)];
-    }
-
-    return [];
-}

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

@@ -1,61 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import getType from '../util/get_type';
-import validateSpec from './validate';
-
-export default function validateObject(options) {
-    const key = options.key;
-    const object = options.value;
-    const elementSpecs = options.valueSpec || {};
-    const elementValidators = options.objectElementValidators || {};
-    const style = options.style;
-    const styleSpec = options.styleSpec;
-    let errors = [];
-
-    const type = getType(object);
-    if (type !== 'object') {
-        return [new ValidationError(key, object, `object expected, ${type} found`)];
-    }
-
-    for (const objectKey in object) {
-        const elementSpecKey = objectKey.split('.')[0]; // treat 'paint.*' as 'paint'
-        const elementSpec = elementSpecs[elementSpecKey] || elementSpecs['*'];
-
-        let validateElement;
-        if (elementValidators[elementSpecKey]) {
-            validateElement = elementValidators[elementSpecKey];
-        } else if (elementSpecs[elementSpecKey]) {
-            validateElement = validateSpec;
-        } else if (elementValidators['*']) {
-            validateElement = elementValidators['*'];
-        } else if (elementSpecs['*']) {
-            validateElement = validateSpec;
-        } else {
-            errors.push(new ValidationError(key, object[objectKey], `unknown property "${objectKey}"`));
-            continue;
-        }
-
-        errors = errors.concat(validateElement({
-            key: (key ? `${key}.` : key) + objectKey,
-            value: object[objectKey],
-            valueSpec: elementSpec,
-            style,
-            styleSpec,
-            object,
-            objectKey
-        }, object));
-    }
-
-    for (const elementSpecKey in elementSpecs) {
-        // Don't check `required` when there's a custom validator for that property.
-        if (elementValidators[elementSpecKey]) {
-            continue;
-        }
-
-        if (elementSpecs[elementSpecKey].required && elementSpecs[elementSpecKey]['default'] === undefined && object[elementSpecKey] === undefined) {
-            errors.push(new ValidationError(key, object, `missing required property "${elementSpecKey}"`));
-        }
-    }
-
-    return errors;
-}

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

@@ -1,6 +0,0 @@
-
-import validateProperty from './validate_property';
-
-export default function validatePaintProperty(options) {
-    return validateProperty(options, 'paint');
-}