@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/style-spec/util/color.js

@@ -1,95 +0,0 @@
-// @flow
-
-import {parseCSSColor} from 'csscolorparser';
-
-/**
- * An RGBA color value. Create instances from color strings using the static
- * method `Color.parse`. The constructor accepts RGB channel values in the range
- * `[0, 1]`, premultiplied by A.
- *
- * @param {number} r The red channel.
- * @param {number} g The green channel.
- * @param {number} b The blue channel.
- * @param {number} a The alpha channel.
- * @private
- */
-class Color {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-
-    constructor(r: number, g: number, b: number, a: number = 1) {
-        this.r = r;
-        this.g = g;
-        this.b = b;
-        this.a = a;
-    }
-
-    static black: Color;
-    static white: Color;
-    static transparent: Color;
-    static red: Color;
-
-    /**
-     * Parses valid CSS color strings and returns a `Color` instance.
-     * @returns A `Color` instance, or `undefined` if the input is not a valid color string.
-     */
-    static parse(input?: string | Color | null): Color | void {
-        if (!input) {
-            return undefined;
-        }
-
-        if (input instanceof Color) {
-            return input;
-        }
-
-        if (typeof input !== 'string') {
-            return undefined;
-        }
-
-        const rgba = parseCSSColor(input);
-        if (!rgba) {
-            return undefined;
-        }
-
-        return new Color(
-            rgba[0] / 255 * rgba[3],
-            rgba[1] / 255 * rgba[3],
-            rgba[2] / 255 * rgba[3],
-            rgba[3]
-        );
-    }
-
-    /**
-     * Returns an RGBA string representing the color value.
-     *
-     * @returns An RGBA string.
-     * @example
-     * var purple = new Color.parse('purple');
-     * purple.toString; // = "rgba(128,0,128,1)"
-     * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
-     * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
-     */
-    toString(): string {
-        const [r, g, b, a] = this.toArray();
-        return `rgba(${Math.round(r)},${Math.round(g)},${Math.round(b)},${a})`;
-    }
-
-    toArray(): [number, number, number, number] {
-        const {r, g, b, a} = this;
-        return a === 0 ? [0, 0, 0, 0] : [
-            r * 255 / a,
-            g * 255 / a,
-            b * 255 / a,
-            a
-        ];
-    }
-}
-
-Color.black = new Color(0, 0, 0, 1);
-Color.white = new Color(1, 1, 1, 1);
-Color.transparent = new Color(0, 0, 0, 0);
-Color.red = new Color(1, 0, 0, 1);
-
-export default Color;

package/src/style-spec/util/color_spaces.js

@@ -1,139 +0,0 @@
-// @flow
-
-import Color from './color';
-
-import {number as interpolateNumber} from './interpolate';
-
-type LABColor = {
-    l: number,
-    a: number,
-    b: number,
-    alpha: number
-};
-
-type HCLColor = {
-    h: number,
-    c: number,
-    l: number,
-    alpha: number
-};
-
-// Constants
-const Xn = 0.950470, // D65 standard referent
-    Yn = 1,
-    Zn = 1.088830,
-    t0 = 4 / 29,
-    t1 = 6 / 29,
-    t2 = 3 * t1 * t1,
-    t3 = t1 * t1 * t1,
-    deg2rad = Math.PI / 180,
-    rad2deg = 180 / Math.PI;
-
-// Utilities
-function xyz2lab(t: number) {
-    return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
-}
-
-function lab2xyz(t: number) {
-    return t > t1 ? t * t * t : t2 * (t - t0);
-}
-
-function xyz2rgb(x: number) {
-    return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
-}
-
-function rgb2xyz(x: number) {
-    x /= 255;
-    return x <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
-}
-
-// LAB
-function rgbToLab(rgbColor: Color): LABColor {
-    const b = rgb2xyz(rgbColor.r),
-        a = rgb2xyz(rgbColor.g),
-        l = rgb2xyz(rgbColor.b),
-        x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn),
-        y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn),
-        z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn);
-
-    return {
-        l: 116 * y - 16,
-        a: 500 * (x - y),
-        b: 200 * (y - z),
-        alpha: rgbColor.a
-    };
-}
-
-function labToRgb(labColor: LABColor): Color {
-    let y = (labColor.l + 16) / 116,
-        x = isNaN(labColor.a) ? y : y + labColor.a / 500,
-        z = isNaN(labColor.b) ? y : y - labColor.b / 200;
-    y = Yn * lab2xyz(y);
-    x = Xn * lab2xyz(x);
-    z = Zn * lab2xyz(z);
-    return new Color(
-        xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
-        xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),
-        xyz2rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z),
-        labColor.alpha
-    );
-}
-
-function interpolateLab(from: LABColor, to: LABColor, t: number) {
-    return {
-        l: interpolateNumber(from.l, to.l, t),
-        a: interpolateNumber(from.a, to.a, t),
-        b: interpolateNumber(from.b, to.b, t),
-        alpha: interpolateNumber(from.alpha, to.alpha, t)
-    };
-}
-
-// HCL
-function rgbToHcl(rgbColor: Color): HCLColor {
-    const {l, a, b} = rgbToLab(rgbColor);
-    const h = Math.atan2(b, a) * rad2deg;
-    return {
-        h: h < 0 ? h + 360 : h,
-        c: Math.sqrt(a * a + b * b),
-        l,
-        alpha: rgbColor.a
-    };
-}
-
-function hclToRgb(hclColor: HCLColor): Color {
-    const h = hclColor.h * deg2rad,
-        c = hclColor.c,
-        l = hclColor.l;
-    return labToRgb({
-        l,
-        a: Math.cos(h) * c,
-        b: Math.sin(h) * c,
-        alpha: hclColor.alpha
-    });
-}
-
-function interpolateHue(a: number, b: number, t: number) {
-    const d = b - a;
-    return a + t * (d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d);
-}
-
-function interpolateHcl(from: HCLColor, to: HCLColor, t: number) {
-    return {
-        h: interpolateHue(from.h, to.h, t),
-        c: interpolateNumber(from.c, to.c, t),
-        l: interpolateNumber(from.l, to.l, t),
-        alpha: interpolateNumber(from.alpha, to.alpha, t)
-    };
-}
-
-export const lab = {
-    forward: rgbToLab,
-    reverse: labToRgb,
-    interpolate: interpolateLab
-};
-
-export const hcl = {
-    forward: rgbToHcl,
-    reverse: hclToRgb,
-    interpolate: interpolateHcl
-};

package/src/style-spec/util/deep_equal.js

@@ -1,28 +0,0 @@
-// @flow
-
-/**
- * Deeply compares two object literals.
- *
- * @private
- */
-function deepEqual(a: ?mixed, b: ?mixed): boolean {
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b) || a.length !== b.length) return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i])) return false;
-        }
-        return true;
-    }
-    if (typeof a === 'object' && a !== null && b !== null) {
-        if (!(typeof b === 'object')) return false;
-        const keys = Object.keys(a);
-        if (keys.length !== Object.keys(b).length) return false;
-        for (const key in a) {
-            if (!deepEqual(a[key], b[key])) return false;
-        }
-        return true;
-    }
-    return a === b;
-}
-
-export default deepEqual;

package/src/style-spec/util/extend.js

@@ -1,10 +0,0 @@
-// @flow
-
-export default function (output: any, ...inputs: Array<any>) {
-    for (const input of inputs) {
-        for (const k in input) {
-            output[k] = input[k];
-        }
-    }
-    return output;
-}

package/src/style-spec/util/get_type.js

@@ -1,17 +0,0 @@
-// @flow
-
-export default function getType(val: mixed): string {
-    if (val instanceof Number) {
-        return 'number';
-    } else if (val instanceof String) {
-        return 'string';
-    } else if (val instanceof Boolean) {
-        return 'boolean';
-    } else if (Array.isArray(val)) {
-        return 'array';
-    } else if (val === null) {
-        return 'null';
-    } else {
-        return typeof val;
-    }
-}

package/src/style-spec/util/interpolate.js

@@ -1,22 +0,0 @@
-// @flow
-
-import Color from './color';
-
-export function number(a: number, b: number, t: number) {
-    return (a * (1 - t)) + (b * t);
-}
-
-export function color(from: Color, to: Color, t: number) {
-    return new Color(
-        number(from.r, to.r, t),
-        number(from.g, to.g, t),
-        number(from.b, to.b, t),
-        number(from.a, to.a, t)
-    );
-}
-
-export function array(from: Array<number>, to: Array<number>, t: number): Array<number> {
-    return from.map((d, i) => {
-        return number(d, to[i], t);
-    });
-}

package/src/style-spec/util/properties.js

@@ -1,15 +0,0 @@
-// @flow
-
-import type {StylePropertySpecification} from '../style-spec';
-
-export function supportsPropertyExpression(spec: StylePropertySpecification): boolean {
-    return spec['property-type'] === 'data-driven' || spec['property-type'] === 'cross-faded-data-driven';
-}
-
-export function supportsZoomExpression(spec: StylePropertySpecification): boolean {
-    return !!spec.expression && spec.expression.parameters.indexOf('zoom') > -1;
-}
-
-export function supportsInterpolation(spec: StylePropertySpecification): boolean {
-    return !!spec.expression && spec.expression.interpolated;
-}

package/src/style-spec/util/ref_properties.js

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

package/src/style-spec/util/result.js

@@ -1,19 +0,0 @@
-// @flow
-
-/**
- * A type used for returning and propagating errors. The first element of the union
- * represents success and contains a value, and the second represents an error and
- * contains an error value.
- * @private
- */
-export type Result<T, E> =
-    | {| result: 'success', value: T |}
-    | {| result: 'error', value: E |};
-
-export function success<T, E>(value: T): Result<T, E> {
-    return {result: 'success', value};
-}
-
-export function error<T, E>(value: E): Result<T, E> {
-    return {result: 'error', value};
-}

package/src/style-spec/util/unbundle_jsonlint.js

@@ -1,24 +0,0 @@
-// @flow
-
-// Turn jsonlint-lines-primitives objects into primitive objects
-export function unbundle(value: mixed) {
-    if (value instanceof Number || value instanceof String || value instanceof Boolean) {
-        return value.valueOf();
-    } else {
-        return value;
-    }
-}
-
-export function deepUnbundle(value: mixed): mixed {
-    if (Array.isArray(value)) {
-        return value.map(deepUnbundle);
-    } else if (value instanceof Object && !(value instanceof Number || value instanceof String || value instanceof Boolean)) {
-        const unbundledValue: { [key: string]: mixed } = {};
-        for (const key in value) {
-            unbundledValue[key] = deepUnbundle(value[key]);
-        }
-        return unbundledValue;
-    }
-
-    return unbundle(value);
-}

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

@@ -1,11 +0,0 @@
-
-import validateStyle from '../validate_style.min';
-
-/*
- * Validate a style against the latest specification. This method is optimized
- * to keep its bundle size small by refraining from requiring jslint or old
- * style spec versions.
- * @see validateStyleMin
- * @deprecated This file exists for backwards compatibility and will be dropped in the next minor release.
- */
-export default validateStyle;

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

@@ -1,75 +0,0 @@
-
-import extend from '../util/extend';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
-import {isExpression} from '../expression';
-import {isFunction} from '../function';
-
-import validateFunction from './validate_function';
-import validateExpression from './validate_expression';
-import validateObject from './validate_object';
-import validateArray from './validate_array';
-import validateBoolean from './validate_boolean';
-import validateNumber from './validate_number';
-import validateColor from './validate_color';
-import validateConstants from './validate_constants';
-import validateEnum from './validate_enum';
-import validateFilter from './validate_filter';
-import validateLayer from './validate_layer';
-import validateSource from './validate_source';
-import validateLight from './validate_light';
-import validateString from './validate_string';
-import validateFormatted from './validate_formatted';
-import validateImage from './validate_image';
-
-const VALIDATORS = {
-    '*'() {
-        return [];
-    },
-    'array': validateArray,
-    'boolean': validateBoolean,
-    'number': validateNumber,
-    'color': validateColor,
-    'constants': validateConstants,
-    'enum': validateEnum,
-    'filter': validateFilter,
-    'function': validateFunction,
-    'layer': validateLayer,
-    'object': validateObject,
-    'source': validateSource,
-    'light': validateLight,
-    'string': validateString,
-    'formatted': validateFormatted,
-    'resolvedImage': validateImage
-};
-
-// Main recursive validation function. Tracks:
-//
-// - key: string representing location of validation in style tree. Used only
-//   for more informative error reporting.
-// - value: current value from style being evaluated. May be anything from a
-//   high level object that needs to be descended into deeper or a simple
-//   scalar value.
-// - valueSpec: current spec being evaluated. Tracks value.
-// - styleSpec: current full spec being evaluated.
-
-export default function validate(options) {
-    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);
-
-    } else {
-        const valid = validateObject(extend({}, options, {
-            valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec
-        }));
-        return valid;
-    }
-}

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

@@ -1,52 +0,0 @@
-
-import getType from '../util/get_type';
-import validate from './validate';
-import ValidationError from '../error/validation_error';
-
-export default function validateArray(options) {
-    const array = options.value;
-    const arraySpec = options.valueSpec;
-    const style = options.style;
-    const styleSpec = options.styleSpec;
-    const key = options.key;
-    const validateArrayElement = options.arrayElementValidator || validate;
-
-    if (getType(array) !== 'array') {
-        return [new ValidationError(key, array, `array expected, ${getType(array)} found`)];
-    }
-
-    if (arraySpec.length && array.length !== arraySpec.length) {
-        return [new ValidationError(key, array, `array length ${arraySpec.length} expected, length ${array.length} found`)];
-    }
-
-    if (arraySpec['min-length'] && array.length < arraySpec['min-length']) {
-        return [new ValidationError(key, array, `array length at least ${arraySpec['min-length']} expected, length ${array.length} found`)];
-    }
-
-    let arrayElementSpec = {
-        "type": arraySpec.value,
-        "values": arraySpec.values
-    };
-
-    if (styleSpec.$version < 7) {
-        arrayElementSpec.function = arraySpec.function;
-    }
-
-    if (getType(arraySpec.value) === 'object') {
-        arrayElementSpec = arraySpec.value;
-    }
-
-    let errors = [];
-    for (let i = 0; i < array.length; i++) {
-        errors = errors.concat(validateArrayElement({
-            array,
-            arrayIndex: i,
-            value: array[i],
-            valueSpec: arrayElementSpec,
-            style,
-            styleSpec,
-            key: `${key}[${i}]`
-        }));
-    }
-    return errors;
-}

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

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

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

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

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

@@ -1,13 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-
-export default function validateConstants(options) {
-    const key = options.key;
-    const constants = options.value;
-
-    if (constants) {
-        return [new ValidationError(key, constants, 'constants have been deprecated as of v8')];
-    } else {
-        return [];
-    }
-}

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

@@ -1,21 +0,0 @@
-
-import ValidationError from '../error/validation_error';
-import {unbundle} from '../util/unbundle_jsonlint';
-
-export default function validateEnum(options) {
-    const key = options.key;
-    const value = options.value;
-    const valueSpec = options.valueSpec;
-    const errors = [];
-
-    if (Array.isArray(valueSpec.values)) { // <=v7
-        if (valueSpec.values.indexOf(unbundle(value)) === -1) {
-            errors.push(new ValidationError(key, value, `expected one of [${valueSpec.values.join(', ')}], ${JSON.stringify(value)} found`));
-        }
-    } else { // >=v8
-        if (Object.keys(valueSpec.values).indexOf(unbundle(value)) === -1) {
-            errors.push(new ValidationError(key, value, `expected one of [${Object.keys(valueSpec.values).join(', ')}], ${JSON.stringify(value)} found`));
-        }
-    }
-    return errors;
-}

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

@@ -1,43 +0,0 @@
-// @flow
-
-import ValidationError from '../error/validation_error';
-
-import {createExpression, createPropertyExpression} from '../expression';
-import {deepUnbundle} from '../util/unbundle_jsonlint';
-import {isStateConstant, isGlobalPropertyConstant, isFeatureConstant} from '../expression/is_constant';
-
-export default function validateExpression(options: any): Array<ValidationError> {
-    const expression = (options.expressionContext === 'property' ? createPropertyExpression : createExpression)(deepUnbundle(options.value), options.valueSpec);
-    if (expression.result === 'error') {
-        return expression.value.map((error) => {
-            return new ValidationError(`${options.key}${error.key}`, options.value, error.message);
-        });
-    }
-
-    const expressionObj = (expression.value: any).expression || (expression.value: any)._styleExpression.expression;
-
-    if (options.expressionContext === 'property' && (options.propertyKey === 'text-font') &&
-        !expressionObj.outputDefined()) {
-        return [new ValidationError(options.key, options.value, `Invalid data expression for "${options.propertyKey}". Output values must be contained as literals within the expression.`)];
-    }
-
-    if (options.expressionContext === 'property' && options.propertyType === 'layout' &&
-        (!isStateConstant(expressionObj))) {
-        return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with layout properties.')];
-    }
-
-    if (options.expressionContext === 'filter' && !isStateConstant(expressionObj)) {
-        return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with filters.')];
-    }
-
-    if (options.expressionContext && options.expressionContext.indexOf('cluster') === 0) {
-        if (!isGlobalPropertyConstant(expressionObj, ['zoom', 'feature-state'])) {
-            return [new ValidationError(options.key, options.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
-        }
-        if (options.expressionContext === 'cluster-initial' && !isFeatureConstant(expressionObj)) {
-            return [new ValidationError(options.key, options.value, 'Feature data expressions are not supported with initial expression part of cluster properties.')];
-        }
-    }
-
-    return [];
-}