mapbox-gl 1.13.2

package/src/style-spec/expression/parsing_error.js

@@ -0,0 +1,13 @@
+// @flow
+
+class ParsingError extends Error {
+    key: string;
+    message: string;
+    constructor(key: string, message: string) {
+        super(message);
+        this.message = message;
+        this.key = key;
+    }
+}
+
+export default ParsingError;

package/src/style-spec/expression/runtime_error.js

@@ -0,0 +1,17 @@
+// @flow
+
+class RuntimeError {
+    name: string;
+    message: string;
+
+    constructor(message: string) {
+        this.name = 'ExpressionEvaluationError';
+        this.message = message;
+    }
+
+    toJSON() {
+        return this.message;
+    }
+}
+
+export default RuntimeError;

package/src/style-spec/expression/scope.js

@@ -0,0 +1,36 @@
+// @flow
+
+import type {Expression} from './expression';
+
+/**
+ * Tracks `let` bindings during expression parsing.
+ * @private
+ */
+class Scope {
+    parent: ?Scope;
+    bindings: {[_: string]: Expression};
+    constructor(parent?: Scope, bindings: Array<[string, Expression]> = []) {
+        this.parent = parent;
+        this.bindings = {};
+        for (const [name, expression] of bindings) {
+            this.bindings[name] = expression;
+        }
+    }
+
+    concat(bindings: Array<[string, Expression]>) {
+        return new Scope(this, bindings);
+    }
+
+    get(name: string): Expression {
+        if (this.bindings[name]) { return this.bindings[name]; }
+        if (this.parent) { return this.parent.get(name); }
+        throw new Error(`${name} not found in scope.`);
+    }
+
+    has(name: string): boolean {
+        if (this.bindings[name]) return true;
+        return this.parent ? this.parent.has(name) : false;
+    }
+}
+
+export default Scope;

package/src/style-spec/expression/stops.js

@@ -0,0 +1,39 @@
+// @flow
+
+import RuntimeError from './runtime_error';
+
+import type {Expression} from './expression';
+
+export type Stops = Array<[number, Expression]>;
+
+/**
+ * Returns the index of the last stop <= input, or 0 if it doesn't exist.
+ * @private
+ */
+export function findStopLessThanOrEqualTo(stops: Array<number>, input: number) {
+    const lastIndex = stops.length - 1;
+    let lowerIndex = 0;
+    let upperIndex = lastIndex;
+    let currentIndex = 0;
+    let currentValue, nextValue;
+
+    while (lowerIndex <= upperIndex) {
+        currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
+        currentValue = stops[currentIndex];
+        nextValue = stops[currentIndex + 1];
+
+        if (currentValue <= input) {
+            if (currentIndex === lastIndex || input < nextValue) { // Search complete
+                return currentIndex;
+            }
+
+            lowerIndex = currentIndex + 1;
+        } else if (currentValue > input) {
+            upperIndex = currentIndex - 1;
+        } else {
+            throw new RuntimeError('Input is not a number.');
+        }
+    }
+
+    return 0;
+}

package/src/style-spec/expression/types/collator.js

@@ -0,0 +1,61 @@
+// @flow
+
+// Flow type declarations for Intl cribbed from
+// https://github.com/facebook/flow/issues/1270
+
+declare var Intl: {
+    Collator: Class<Intl$Collator>
+};
+
+declare class Intl$Collator {
+    constructor (
+        locales?: string | string[],
+        options?: CollatorOptions
+    ): Intl$Collator;
+
+    static (
+        locales?: string | string[],
+        options?: CollatorOptions
+    ): Intl$Collator;
+
+    compare (a: string, b: string): number;
+
+    resolvedOptions(): any;
+}
+
+type CollatorOptions = {
+    localeMatcher?: 'lookup' | 'best fit',
+    usage?: 'sort' | 'search',
+    sensitivity?: 'base' | 'accent' | 'case' | 'variant',
+    ignorePunctuation?: boolean,
+    numeric?: boolean,
+    caseFirst?: 'upper' | 'lower' | 'false'
+}
+
+export default class Collator {
+    locale: string | null;
+    sensitivity: 'base' | 'accent' | 'case' | 'variant';
+    collator: Intl$Collator;
+
+    constructor(caseSensitive: boolean, diacriticSensitive: boolean, locale: string | null) {
+        if (caseSensitive)
+            this.sensitivity = diacriticSensitive ? 'variant' : 'case';
+        else
+            this.sensitivity = diacriticSensitive ? 'accent' : 'base';
+
+        this.locale = locale;
+        this.collator = new Intl.Collator(this.locale ? this.locale : [],
+            {sensitivity: this.sensitivity, usage: 'search'});
+    }
+
+    compare(lhs: string, rhs: string): number {
+        return this.collator.compare(lhs, rhs);
+    }
+
+    resolvedLocale(): string {
+        // We create a Collator without "usage: search" because we don't want
+        // the search options encoded in our result (e.g. "en-u-co-search")
+        return new Intl.Collator(this.locale ? this.locale : [])
+            .resolvedOptions().locale;
+    }
+}

package/src/style-spec/expression/types/formatted.js

@@ -0,0 +1,73 @@
+// @flow
+import type Color from '../../util/color';
+import type ResolvedImage from '../types/resolved_image';
+
+export class FormattedSection {
+    text: string;
+    image: ResolvedImage | null;
+    scale: number | null;
+    fontStack: string | null;
+    textColor: Color | null;
+
+    constructor(text: string, image: ResolvedImage | null, scale: number | null, fontStack: string | null, textColor: Color | null) {
+        this.text = text;
+        this.image = image;
+        this.scale = scale;
+        this.fontStack = fontStack;
+        this.textColor = textColor;
+    }
+}
+
+export default class Formatted {
+    sections: Array<FormattedSection>;
+
+    constructor(sections: Array<FormattedSection>) {
+        this.sections = sections;
+    }
+
+    static fromString(unformatted: string): Formatted {
+        return new Formatted([new FormattedSection(unformatted, null, null, null, null)]);
+    }
+
+    isEmpty(): boolean {
+        if (this.sections.length === 0) return true;
+        return !this.sections.some(section => section.text.length !== 0 ||
+                                             (section.image && section.image.name.length !== 0));
+    }
+
+    static factory(text: Formatted | string): Formatted {
+        if (text instanceof Formatted) {
+            return text;
+        } else {
+            return Formatted.fromString(text);
+        }
+    }
+
+    toString(): string {
+        if (this.sections.length === 0) return '';
+        return this.sections.map(section => section.text).join('');
+    }
+
+    serialize(): Array<mixed> {
+        const serialized: Array<mixed> = ["format"];
+        for (const section of this.sections) {
+            if (section.image) {
+                serialized.push(["image", section.image.name]);
+                continue;
+            }
+            serialized.push(section.text);
+            const options: { [key: string]: mixed } = {};
+            if (section.fontStack) {
+                options["text-font"] = ["literal", section.fontStack.split(',')];
+            }
+            if (section.scale) {
+                options["font-scale"] = section.scale;
+            }
+            if (section.textColor) {
+                options["text-color"] = (["rgba"]: Array<mixed>).concat(section.textColor.toArray());
+            }
+            serialized.push(options);
+        }
+        return serialized;
+    }
+}

package/src/style-spec/expression/types/resolved_image.js

@@ -0,0 +1,29 @@
+// @flow
+
+export type ResolvedImageOptions = {
+    name: string,
+    available: boolean
+};
+
+export default class ResolvedImage {
+    name: string;
+    available: boolean;
+
+    constructor(options: ResolvedImageOptions) {
+        this.name = options.name;
+        this.available = options.available;
+    }
+
+    toString(): string {
+        return this.name;
+    }
+
+    static fromString(name: string): ResolvedImage | null {
+        if (!name) return null; // treat empty values as no image
+        return new ResolvedImage({name, available: false});
+    }
+
+    serialize(): Array<string> {
+        return ["image", this.name];
+    }
+}

package/src/style-spec/expression/types.js

@@ -0,0 +1,126 @@
+// @flow
+
+export type NullTypeT = { kind: 'null' };
+export type NumberTypeT = { kind: 'number' };
+export type StringTypeT = { kind: 'string' };
+export type BooleanTypeT = { kind: 'boolean' };
+export type ColorTypeT = { kind: 'color' };
+export type ObjectTypeT = { kind: 'object' };
+export type ValueTypeT = { kind: 'value' };
+export type ErrorTypeT = { kind: 'error' };
+export type CollatorTypeT = { kind: 'collator' };
+export type FormattedTypeT = { kind: 'formatted' };
+export type ResolvedImageTypeT = { kind: 'resolvedImage' };
+
+export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
+
+export type Type =
+    NullTypeT |
+    NumberTypeT |
+    StringTypeT |
+    BooleanTypeT |
+    ColorTypeT |
+    ObjectTypeT |
+    ValueTypeT |
+    ArrayType | // eslint-disable-line no-use-before-define
+    ErrorTypeT |
+    CollatorTypeT |
+    FormattedTypeT |
+    ResolvedImageTypeT
+
+export type ArrayType = {
+    kind: 'array',
+    itemType: Type,
+    N: ?number
+}
+
+export type NativeType = 'number' | 'string' | 'boolean' | 'null' | 'array' | 'object'
+
+export const NullType = {kind: 'null'};
+export const NumberType = {kind: 'number'};
+export const StringType = {kind: 'string'};
+export const BooleanType = {kind: 'boolean'};
+export const ColorType = {kind: 'color'};
+export const ObjectType = {kind: 'object'};
+export const ValueType = {kind: 'value'};
+export const ErrorType = {kind: 'error'};
+export const CollatorType = {kind: 'collator'};
+export const FormattedType = {kind: 'formatted'};
+export const ResolvedImageType = {kind: 'resolvedImage'};
+
+export function array(itemType: Type, N: ?number): ArrayType {
+    return {
+        kind: 'array',
+        itemType,
+        N
+    };
+}
+
+export function toString(type: Type): string {
+    if (type.kind === 'array') {
+        const itemType = toString(type.itemType);
+        return typeof type.N === 'number' ?
+            `array<${itemType}, ${type.N}>` :
+            type.itemType.kind === 'value' ? 'array' : `array<${itemType}>`;
+    } else {
+        return type.kind;
+    }
+}
+
+const valueMemberTypes = [
+    NullType,
+    NumberType,
+    StringType,
+    BooleanType,
+    ColorType,
+    FormattedType,
+    ObjectType,
+    array(ValueType),
+    ResolvedImageType
+];
+
+/**
+ * Returns null if `t` is a subtype of `expected`; otherwise returns an
+ * error message.
+ * @private
+ */
+export function checkSubtype(expected: Type, t: Type): ?string {
+    if (t.kind === 'error') {
+        // Error is a subtype of every type
+        return null;
+    } else if (expected.kind === 'array') {
+        if (t.kind === 'array' &&
+            ((t.N === 0 && t.itemType.kind === 'value') || !checkSubtype(expected.itemType, t.itemType)) &&
+            (typeof expected.N !== 'number' || expected.N === t.N)) {
+            return null;
+        }
+    } else if (expected.kind === t.kind) {
+        return null;
+    } else if (expected.kind === 'value') {
+        for (const memberType of valueMemberTypes) {
+            if (!checkSubtype(memberType, t)) {
+                return null;
+            }
+        }
+    }
+
+    return `Expected ${toString(expected)} but found ${toString(t)} instead.`;
+}
+
+export function isValidType(provided: Type, allowedTypes: Array<Type>): boolean {
+    return allowedTypes.some(t => t.kind === provided.kind);
+}
+
+export function isValidNativeType(provided: any, allowedTypes: Array<NativeType>): boolean {
+    return allowedTypes.some(t => {
+        if (t === 'null') {
+            return provided === null;
+        } else if (t === 'array') {
+            return Array.isArray(provided);
+        } else if (t === 'object') {
+            return provided && !Array.isArray(provided) && typeof provided === 'object';
+        } else {
+            return t === typeof provided;
+        }
+    });
+}

package/src/style-spec/expression/values.js

@@ -0,0 +1,123 @@
+// @flow
+
+import assert from 'assert';
+
+import Color from '../util/color';
+import Collator from './types/collator';
+import Formatted from './types/formatted';
+import ResolvedImage from './types/resolved_image';
+import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array} from './types';
+
+import type {Type} from './types';
+
+export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string | null {
+    if (!(
+        typeof r === 'number' && r >= 0 && r <= 255 &&
+        typeof g === 'number' && g >= 0 && g <= 255 &&
+        typeof b === 'number' && b >= 0 && b <= 255
+    )) {
+        const value = typeof a === 'number' ? [r, g, b, a] : [r, g, b];
+        return `Invalid rgba value [${value.join(', ')}]: 'r', 'g', and 'b' must be between 0 and 255.`;
+    }
+
+    if (!(
+        typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1)
+    )) {
+        return `Invalid rgba value [${[r, g, b, a].join(', ')}]: 'a' must be between 0 and 1.`;
+    }
+
+    return null;
+}
+
+export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | $ReadOnlyArray<Value> | { +[string]: Value }
+
+export function isValue(mixed: mixed): boolean {
+    if (mixed === null) {
+        return true;
+    } else if (typeof mixed === 'string') {
+        return true;
+    } else if (typeof mixed === 'boolean') {
+        return true;
+    } else if (typeof mixed === 'number') {
+        return true;
+    } else if (mixed instanceof Color) {
+        return true;
+    } else if (mixed instanceof Collator) {
+        return true;
+    } else if (mixed instanceof Formatted) {
+        return true;
+    } else if (mixed instanceof ResolvedImage) {
+        return true;
+    } else if (Array.isArray(mixed)) {
+        for (const item of mixed) {
+            if (!isValue(item)) {
+                return false;
+            }
+        }
+        return true;
+    } else if (typeof mixed === 'object') {
+        for (const key in mixed) {
+            if (!isValue(mixed[key])) {
+                return false;
+            }
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+export function typeOf(value: Value): Type {
+    if (value === null) {
+        return NullType;
+    } else if (typeof value === 'string') {
+        return StringType;
+    } else if (typeof value === 'boolean') {
+        return BooleanType;
+    } else if (typeof value === 'number') {
+        return NumberType;
+    } else if (value instanceof Color) {
+        return ColorType;
+    } else if (value instanceof Collator) {
+        return CollatorType;
+    } else if (value instanceof Formatted) {
+        return FormattedType;
+    } else if (value instanceof ResolvedImage) {
+        return ResolvedImageType;
+    } else if (Array.isArray(value)) {
+        const length = value.length;
+        let itemType: Type | typeof undefined;
+
+        for (const item of value) {
+            const t = typeOf(item);
+            if (!itemType) {
+                itemType = t;
+            } else if (itemType === t) {
+                continue;
+            } else {
+                itemType = ValueType;
+                break;
+            }
+        }
+
+        return array(itemType || ValueType, length);
+    } else {
+        assert(typeof value === 'object');
+        return ObjectType;
+    }
+}
+
+export function toString(value: Value) {
+    const type = typeof value;
+    if (value === null) {
+        return '';
+    } else if (type === 'string' || type === 'number' || type === 'boolean') {
+        return String(value);
+    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+        return value.toString();
+    } else {
+        return JSON.stringify(value);
+    }
+}
+
+export {Color, Collator};

package/src/style-spec/feature_filter/README.md

@@ -0,0 +1,55 @@
+## Filter
+
+Filter expressions are used to target specific data in a layer. This library implements the semantics specified by the [Mapbox GL JS spec](https://www.mapbox.com/mapbox-gl-style-spec/#filter).
+
+### API
+
+`featureFilter(filter)`
+
+Given a filter expressed as nested arrays, return a new function
+that evaluates whether a given feature (with a .properties or .tags property)
+passes its test.
+
+#### Parameters
+
+| parameter | type  | description      |
+| --------- | ----- | ---------------- |
+| `filter`  | Array | mapbox gl filter |
+
+**Returns** `Function`, filter-evaluating function
+
+### Usage
+
+``` javascript
+var ff = require('@mapbox/mapbox-gl-style-spec').featureFilter;
+
+// will match a feature with class of street_limited,
+// AND an admin_level less than or equal to 3,
+// that's NOT a polygon.
+var filter = [
+    "all",
+    ["==", "class", "street_limited"],
+    ["<=", "admin_level", 3],
+    ["!=", "$type", "Polygon"]
+]
+
+// will match a feature that has a class of
+// wetland OR wetland_noveg.
+// ["in", "class", "wetland", "wetland_noveg"]
+
+// testFilter will be a function that returns a boolean
+var testFilter = ff(filter);
+
+// Layer feature that you're testing. Must have type
+// and properties keys.
+var feature = {
+    type: 2,
+    properties: {
+       class: "street_limited",
+       admin_level: 1
+    }
+};
+
+// will return a boolean based on whether the feature matched the filter
+return testFilter({zoom: 0}, feature);
+```