@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,233 +0,0 @@
-// @flow
-
-import Scope from './scope';
-import {checkSubtype} from './types';
-import ParsingError from './parsing_error';
-import Literal from './definitions/literal';
-import Assertion from './definitions/assertion';
-import Coercion from './definitions/coercion';
-import EvaluationContext from './evaluation_context';
-import CompoundExpression from './compound_expression';
-import CollatorExpression from './definitions/collator';
-import Within from './definitions/within';
-import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant';
-import Var from './definitions/var';
-
-import type {Expression, ExpressionRegistry} from './expression';
-import type {Type} from './types';
-
-/**
- * State associated parsing at a given point in an expression tree.
- * @private
- */
-class ParsingContext {
-    registry: ExpressionRegistry;
-    path: Array<number>;
-    key: string;
-    scope: Scope;
-    errors: Array<ParsingError>;
-
-    // The expected type of this expression. Provided only to allow Expression
-    // implementations to infer argument types: Expression#parse() need not
-    // check that the output type of the parsed expression matches
-    // `expectedType`.
-    expectedType: ?Type;
-
-    constructor(
-        registry: ExpressionRegistry,
-        path: Array<number> = [],
-        expectedType: ?Type,
-        scope: Scope = new Scope(),
-        errors: Array<ParsingError> = []
-    ) {
-        this.registry = registry;
-        this.path = path;
-        this.key = path.map(part => `[${part}]`).join('');
-        this.scope = scope;
-        this.errors = errors;
-        this.expectedType = expectedType;
-    }
-
-    /**
-     * @param expr the JSON expression to parse
-     * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
-     * @param options
-     * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
-     * @private
-     */
-    parse(
-        expr: mixed,
-        index?: number,
-        expectedType?: ?Type,
-        bindings?: Array<[string, Expression]>,
-        options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'} = {}
-    ): ?Expression {
-        if (index) {
-            return this.concat(index, expectedType, bindings)._parse(expr, options);
-        }
-        return this._parse(expr, options);
-    }
-
-    _parse(expr: mixed, options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'}): ?Expression {
-        if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
-            expr = ['literal', expr];
-        }
-
-        function annotate(parsed, type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
-            if (typeAnnotation === 'assert') {
-                return new Assertion(type, [parsed]);
-            } else if (typeAnnotation === 'coerce') {
-                return new Coercion(type, [parsed]);
-            } else {
-                return parsed;
-            }
-        }
-
-        if (Array.isArray(expr)) {
-            if (expr.length === 0) {
-                return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
-            }
-
-            const op = expr[0];
-            if (typeof op !== 'string') {
-                this.error(`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`, 0);
-                return null;
-            }
-
-            const Expr = this.registry[op];
-            if (Expr) {
-                let parsed = Expr.parse(expr, this);
-                if (!parsed) return null;
-
-                if (this.expectedType) {
-                    const expected = this.expectedType;
-                    const actual = parsed.type;
-
-                    // When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
-                    // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
-                    // Otherwise, we do static type-checking.
-                    //
-                    // These behaviors are overridable for:
-                    //   * The "coalesce" operator, which needs to omit type annotations.
-                    //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
-                    //
-                    if ((expected.kind === 'string' || expected.kind === 'number' || expected.kind === 'boolean' || expected.kind === 'object' || expected.kind === 'array') && actual.kind === 'value') {
-                        parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
-                    } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
-                        parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
-                    } else if (this.checkSubtype(expected, actual)) {
-                        return null;
-                    }
-                }
-
-                // If an expression's arguments are all literals, we can evaluate
-                // it immediately and replace it with a literal value in the
-                // parsed/compiled result. Expressions that expect an image should
-                // not be resolved here so we can later get the available images.
-                if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
-                    const ec = new EvaluationContext();
-                    try {
-                        parsed = new Literal(parsed.type, parsed.evaluate(ec));
-                    } catch (e) {
-                        this.error(e.message);
-                        return null;
-                    }
-                }
-
-                return parsed;
-            }
-
-            return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
-        } else if (typeof expr === 'undefined') {
-            return this.error(`'undefined' value invalid. Use null instead.`);
-        } else if (typeof expr === 'object') {
-            return this.error(`Bare objects invalid. Use ["literal", {...}] instead.`);
-        } else {
-            return this.error(`Expected an array, but found ${typeof expr} instead.`);
-        }
-    }
-
-    /**
-     * Returns a copy of this context suitable for parsing the subexpression at
-     * index `index`, optionally appending to 'let' binding map.
-     *
-     * Note that `errors` property, intended for collecting errors while
-     * parsing, is copied by reference rather than cloned.
-     * @private
-     */
-    concat(index: number, expectedType?: ?Type, bindings?: Array<[string, Expression]>) {
-        const path = typeof index === 'number' ? this.path.concat(index) : this.path;
-        const scope = bindings ? this.scope.concat(bindings) : this.scope;
-        return new ParsingContext(
-            this.registry,
-            path,
-            expectedType || null,
-            scope,
-            this.errors
-        );
-    }
-
-    /**
-     * Push a parsing (or type checking) error into the `this.errors`
-     * @param error The message
-     * @param keys Optionally specify the source of the error at a child
-     * of the current expression at `this.key`.
-     * @private
-     */
-    error(error: string, ...keys: Array<number>) {
-        const key = `${this.key}${keys.map(k => `[${k}]`).join('')}`;
-        this.errors.push(new ParsingError(key, error));
-    }
-
-    /**
-     * Returns null if `t` is a subtype of `expected`; otherwise returns an
-     * error message and also pushes it to `this.errors`.
-     */
-    checkSubtype(expected: Type, t: Type): ?string {
-        const error = checkSubtype(expected, t);
-        if (error) this.error(error);
-        return error;
-    }
-}
-
-export default ParsingContext;
-
-function isConstant(expression: Expression) {
-    if (expression instanceof Var) {
-        return isConstant(expression.boundExpression);
-    } else if (expression instanceof CompoundExpression && expression.name === 'error') {
-        return false;
-    } else if (expression instanceof CollatorExpression) {
-        // Although the results of a Collator expression with fixed arguments
-        // generally shouldn't change between executions, we can't serialize them
-        // as constant expressions because results change based on environment.
-        return false;
-    } else if (expression instanceof Within) {
-        return false;
-    }
-
-    const isTypeAnnotation = expression instanceof Coercion ||
-        expression instanceof Assertion;
-
-    let childrenConstant = true;
-    expression.eachChild(child => {
-        // We can _almost_ assume that if `expressions` children are constant,
-        // they would already have been evaluated to Literal values when they
-        // were parsed.  Type annotations are the exception, because they might
-        // have been inferred and added after a child was parsed.
-
-        // So we recurse into isConstant() for the children of type annotations,
-        // but otherwise simply check whether they are Literals.
-        if (isTypeAnnotation) {
-            childrenConstant = childrenConstant && isConstant(child);
-        } else {
-            childrenConstant = childrenConstant && child instanceof Literal;
-        }
-    });
-    if (!childrenConstant) {
-        return false;
-    }
-
-    return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'accumulated', 'is-supported-script']);
-}

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

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

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

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

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

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

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

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

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