@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,78 +0,0 @@
-// @flow
-
-import {StringType, BooleanType, CollatorType} from '../types';
-import Collator from '../types/collator';
-
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type ParsingContext from '../parsing_context';
-import type {Type} from '../types';
-
-export default class CollatorExpression implements Expression {
-    type: Type;
-    caseSensitive: Expression;
-    diacriticSensitive: Expression;
-    locale: Expression | null;
-
-    constructor(caseSensitive: Expression, diacriticSensitive: Expression, locale: Expression | null) {
-        this.type = CollatorType;
-        this.locale = locale;
-        this.caseSensitive = caseSensitive;
-        this.diacriticSensitive = diacriticSensitive;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length !== 2)
-            return context.error(`Expected one argument.`);
-
-        const options = (args[1]: any);
-        if (typeof options !== "object" || Array.isArray(options))
-            return context.error(`Collator options argument must be an object.`);
-
-        const caseSensitive = context.parse(
-            options['case-sensitive'] === undefined ? false : options['case-sensitive'], 1, BooleanType);
-        if (!caseSensitive) return null;
-
-        const diacriticSensitive = context.parse(
-            options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'], 1, BooleanType);
-        if (!diacriticSensitive) return null;
-
-        let locale = null;
-        if (options['locale']) {
-            locale = context.parse(options['locale'], 1, StringType);
-            if (!locale) return null;
-        }
-
-        return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.caseSensitive);
-        fn(this.diacriticSensitive);
-        if (this.locale) {
-            fn(this.locale);
-        }
-    }
-
-    outputDefined() {
-        // Technically the set of possible outputs is the combinatoric set of Collators produced
-        // by all possible outputs of locale/caseSensitive/diacriticSensitive
-        // But for the primary use of Collators in comparison operators, we ignore the Collator's
-        // possible outputs anyway, so we can get away with leaving this false for now.
-        return false;
-    }
-
-    serialize() {
-        const options = {};
-        options['case-sensitive'] = this.caseSensitive.serialize();
-        options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
-        if (this.locale) {
-            options['locale'] = this.locale.serialize();
-        }
-        return ["collator", options];
-    }
-}

package/src/style-spec/expression/definitions/comparison.js

@@ -1,184 +0,0 @@
-// @flow
-
-import {toString, ValueType, BooleanType, CollatorType} from '../types';
-import Assertion from './assertion';
-import {typeOf} from '../values';
-import RuntimeError from '../runtime_error';
-
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type ParsingContext from '../parsing_context';
-import type {Type} from '../types';
-
-type ComparisonOperator = '==' | '!=' | '<' | '>' | '<=' | '>=' ;
-
-function isComparableType(op: ComparisonOperator, type: Type) {
-    if (op === '==' || op === '!=') {
-        // equality operator
-        return type.kind === 'boolean' ||
-            type.kind === 'string' ||
-            type.kind === 'number' ||
-            type.kind === 'null' ||
-            type.kind === 'value';
-    } else {
-        // ordering operator
-        return type.kind === 'string' ||
-            type.kind === 'number' ||
-            type.kind === 'value';
-    }
-}
-
-function eq(ctx, a, b) { return a === b; }
-function neq(ctx, a, b) { return a !== b; }
-function lt(ctx, a, b) { return a < b; }
-function gt(ctx, a, b) { return a > b; }
-function lteq(ctx, a, b) { return a <= b; }
-function gteq(ctx, a, b) { return a >= b; }
-
-function eqCollate(ctx, a, b, c) { return c.compare(a, b) === 0; }
-function neqCollate(ctx, a, b, c) { return !eqCollate(ctx, a, b, c); }
-function ltCollate(ctx, a, b, c) { return c.compare(a, b) < 0; }
-function gtCollate(ctx, a, b, c) { return c.compare(a, b) > 0; }
-function lteqCollate(ctx, a, b, c) { return c.compare(a, b) <= 0; }
-function gteqCollate(ctx, a, b, c) { return c.compare(a, b) >= 0; }
-
-/**
- * Special form for comparison operators, implementing the signatures:
- * - (T, T, ?Collator) => boolean
- * - (T, value, ?Collator) => boolean
- * - (value, T, ?Collator) => boolean
- *
- * For inequalities, T must be either value, string, or number. For ==/!=, it
- * can also be boolean or null.
- *
- * Equality semantics are equivalent to Javascript's strict equality (===/!==)
- * -- i.e., when the arguments' types don't match, == evaluates to false, != to
- * true.
- *
- * When types don't match in an ordering comparison, a runtime error is thrown.
- *
- * @private
- */
-function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollator) {
-    const isOrderComparison = op !== '==' && op !== '!=';
-
-    return class Comparison implements Expression {
-        type: Type;
-        lhs: Expression;
-        rhs: Expression;
-        collator: ?Expression;
-        hasUntypedArgument: boolean;
-
-        constructor(lhs: Expression, rhs: Expression, collator: ?Expression) {
-            this.type = BooleanType;
-            this.lhs = lhs;
-            this.rhs = rhs;
-            this.collator = collator;
-            this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
-        }
-
-        static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-            if (args.length !== 3 && args.length !== 4)
-                return context.error(`Expected two or three arguments.`);
-
-            const op: ComparisonOperator = (args[0]: any);
-
-            let lhs = context.parse(args[1], 1, ValueType);
-            if (!lhs) return null;
-            if (!isComparableType(op, lhs.type)) {
-                return context.concat(1).error(`"${op}" comparisons are not supported for type '${toString(lhs.type)}'.`);
-            }
-            let rhs = context.parse(args[2], 2, ValueType);
-            if (!rhs) return null;
-            if (!isComparableType(op, rhs.type)) {
-                return context.concat(2).error(`"${op}" comparisons are not supported for type '${toString(rhs.type)}'.`);
-            }
-
-            if (
-                lhs.type.kind !== rhs.type.kind &&
-                lhs.type.kind !== 'value' &&
-                rhs.type.kind !== 'value'
-            ) {
-                return context.error(`Cannot compare types '${toString(lhs.type)}' and '${toString(rhs.type)}'.`);
-            }
-
-            if (isOrderComparison) {
-                // typing rules specific to less/greater than operators
-                if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
-                    // (value, T)
-                    lhs = new Assertion(rhs.type, [lhs]);
-                } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
-                    // (T, value)
-                    rhs = new Assertion(lhs.type, [rhs]);
-                }
-            }
-
-            let collator = null;
-            if (args.length === 4) {
-                if (
-                    lhs.type.kind !== 'string' &&
-                    rhs.type.kind !== 'string' &&
-                    lhs.type.kind !== 'value' &&
-                    rhs.type.kind !== 'value'
-                ) {
-                    return context.error(`Cannot use collator to compare non-string types.`);
-                }
-                collator = context.parse(args[3], 3, CollatorType);
-                if (!collator) return null;
-            }
-
-            return new Comparison(lhs, rhs, collator);
-        }
-
-        evaluate(ctx: EvaluationContext) {
-            const lhs = this.lhs.evaluate(ctx);
-            const rhs = this.rhs.evaluate(ctx);
-
-            if (isOrderComparison && this.hasUntypedArgument) {
-                const lt = typeOf(lhs);
-                const rt = typeOf(rhs);
-                // check that type is string or number, and equal
-                if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
-                    throw new RuntimeError(`Expected arguments for "${op}" to be (string, string) or (number, number), but found (${lt.kind}, ${rt.kind}) instead.`);
-                }
-            }
-
-            if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
-                const lt = typeOf(lhs);
-                const rt = typeOf(rhs);
-                if (lt.kind !== 'string' || rt.kind !== 'string') {
-                    return compareBasic(ctx, lhs, rhs);
-                }
-            }
-
-            return this.collator ?
-                compareWithCollator(ctx, lhs, rhs, this.collator.evaluate(ctx)) :
-                compareBasic(ctx, lhs, rhs);
-        }
-
-        eachChild(fn: (_: Expression) => void) {
-            fn(this.lhs);
-            fn(this.rhs);
-            if (this.collator) {
-                fn(this.collator);
-            }
-        }
-
-        outputDefined(): boolean {
-            return true;
-        }
-
-        serialize() {
-            const serialized = [op];
-            this.eachChild(child => { serialized.push(child.serialize()); });
-            return serialized;
-        }
-    };
-}
-
-export const Equals = makeComparison('==', eq, eqCollate);
-export const NotEquals = makeComparison('!=', neq, neqCollate);
-export const LessThan = makeComparison('<', lt, ltCollate);
-export const GreaterThan = makeComparison('>', gt, gtCollate);
-export const LessThanOrEqual = makeComparison('<=', lteq, lteqCollate);
-export const GreaterThanOrEqual = makeComparison('>=', gteq, gteqCollate);

package/src/style-spec/expression/definitions/format.js

@@ -1,144 +0,0 @@
-// @flow
-
-import {NumberType, ValueType, FormattedType, array, StringType, ColorType, ResolvedImageType} from '../types';
-import Formatted, {FormattedSection} from '../types/formatted';
-import {toString, typeOf} from '../values';
-
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type ParsingContext from '../parsing_context';
-import type {Type} from '../types';
-
-type FormattedSectionExpression = {
-    // Content of a section may be Image expression or other
-    // type of expression that is coercable to 'string'.
-    content: Expression,
-    scale: Expression | null;
-    font: Expression | null;
-    textColor: Expression | null;
-}
-
-export default class FormatExpression implements Expression {
-    type: Type;
-    sections: Array<FormattedSectionExpression>;
-
-    constructor(sections: Array<FormattedSectionExpression>) {
-        this.type = FormattedType;
-        this.sections = sections;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length < 2) {
-            return context.error(`Expected at least one argument.`);
-        }
-
-        const firstArg = args[1];
-        if (!Array.isArray(firstArg) && typeof firstArg === 'object')  {
-            return context.error(`First argument must be an image or text section.`);
-        }
-
-        const sections: Array<FormattedSectionExpression> = [];
-        let nextTokenMayBeObject = false;
-        for (let i = 1; i <= args.length - 1; ++i) {
-            const arg = (args[i]: any);
-
-            if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
-                nextTokenMayBeObject = false;
-
-                let scale = null;
-                if (arg['font-scale']) {
-                    scale = context.parse(arg['font-scale'], 1, NumberType);
-                    if (!scale) return null;
-                }
-
-                let font = null;
-                if (arg['text-font']) {
-                    font = context.parse(arg['text-font'], 1, array(StringType));
-                    if (!font) return null;
-                }
-
-                let textColor = null;
-                if (arg['text-color']) {
-                    textColor = context.parse(arg['text-color'], 1, ColorType);
-                    if (!textColor) return null;
-                }
-
-                const lastExpression = sections[sections.length - 1];
-                lastExpression.scale = scale;
-                lastExpression.font = font;
-                lastExpression.textColor = textColor;
-            } else {
-                const content = context.parse(args[i], 1, ValueType);
-                if (!content) return null;
-
-                const kind = content.type.kind;
-                if (kind !== 'string' && kind !== 'value' && kind !== 'null' && kind !== 'resolvedImage')
-                    return context.error(`Formatted text type must be 'string', 'value', 'image' or 'null'.`);
-
-                nextTokenMayBeObject = true;
-                sections.push({content, scale: null, font: null, textColor: null});
-            }
-        }
-
-        return new FormatExpression(sections);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const evaluateSection = section => {
-            const evaluatedContent = section.content.evaluate(ctx);
-            if (typeOf(evaluatedContent) === ResolvedImageType) {
-                return new FormattedSection('', evaluatedContent, null, null, null);
-            }
-
-            return new FormattedSection(
-                    toString(evaluatedContent),
-                    null,
-                    section.scale ? section.scale.evaluate(ctx) : null,
-                    section.font ? section.font.evaluate(ctx).join(',') : null,
-                    section.textColor ? section.textColor.evaluate(ctx) : null
-            );
-        };
-
-        return new Formatted(this.sections.map(evaluateSection));
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        for (const section of this.sections) {
-            fn(section.content);
-            if (section.scale) {
-                fn(section.scale);
-            }
-            if (section.font) {
-                fn(section.font);
-            }
-            if (section.textColor) {
-                fn(section.textColor);
-            }
-        }
-    }
-
-    outputDefined() {
-        // Technically the combinatoric set of all children
-        // Usually, this.text will be undefined anyway
-        return false;
-    }
-
-    serialize() {
-        const serialized = ["format"];
-        for (const section of this.sections) {
-            serialized.push(section.content.serialize());
-            const options = {};
-            if (section.scale) {
-                options['font-scale'] = section.scale.serialize();
-            }
-            if (section.font) {
-                options['text-font'] = section.font.serialize();
-            }
-            if (section.textColor) {
-                options['text-color'] = section.textColor.serialize();
-            }
-            serialized.push(options);
-        }
-        return serialized;
-    }
-}

package/src/style-spec/expression/definitions/format_section_override.js

@@ -1,54 +0,0 @@
-// @flow
-
-import assert from 'assert';
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-import type {ZoomConstantExpression} from '../../expression';
-import {NullType} from '../types';
-import {PossiblyEvaluatedPropertyValue} from '../../../style/properties';
-import {register} from '../../../util/web_worker_transfer';
-
-export default class FormatSectionOverride<T> implements Expression {
-    type: Type;
-    defaultValue: PossiblyEvaluatedPropertyValue<T>;
-
-    constructor(defaultValue: PossiblyEvaluatedPropertyValue<T>) {
-        assert(defaultValue.property.overrides !== undefined);
-        this.type = defaultValue.property.overrides ? defaultValue.property.overrides.runtimeType : NullType;
-        this.defaultValue = defaultValue;
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        if (ctx.formattedSection) {
-            const overrides = this.defaultValue.property.overrides;
-            if (overrides && overrides.hasOverride(ctx.formattedSection)) {
-                return overrides.getOverride(ctx.formattedSection);
-            }
-        }
-
-        if (ctx.feature && ctx.featureState) {
-            return this.defaultValue.evaluate(ctx.feature, ctx.featureState);
-        }
-
-        return this.defaultValue.property.specification.default;
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        if (!this.defaultValue.isConstant()) {
-            const expr: ZoomConstantExpression<'source'> = ((this.defaultValue.value): any);
-            fn(expr._styleExpression.expression);
-        }
-    }
-
-    // Cannot be statically evaluated, as the output depends on the evaluation context.
-    outputDefined() {
-        return false;
-    }
-
-    serialize() {
-        return null;
-    }
-}
-
-register('FormatSectionOverride', FormatSectionOverride, {omit: ['defaultValue']});

package/src/style-spec/expression/definitions/image.js

@@ -1,52 +0,0 @@
-// @flow
-
-import {ResolvedImageType, StringType} from '../types';
-import ResolvedImage from '../types/resolved_image';
-
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type ParsingContext from '../parsing_context';
-import type {Type} from '../types';
-
-export default class ImageExpression implements Expression {
-    type: Type;
-    input: Expression;
-
-    constructor(input: Expression) {
-        this.type = ResolvedImageType;
-        this.input = input;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length !== 2) {
-            return context.error(`Expected two arguments.`);
-        }
-
-        const name = context.parse(args[1], 1, StringType);
-        if (!name) return context.error(`No image name provided.`);
-
-        return new ImageExpression(name);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const evaluatedImageName = this.input.evaluate(ctx);
-
-        const value = ResolvedImage.fromString(evaluatedImageName);
-        if (value && ctx.availableImages) value.available = ctx.availableImages.indexOf(evaluatedImageName) > -1;
-
-        return value;
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.input);
-    }
-
-    outputDefined() {
-        // The output of image is determined by the list of available images in the evaluation context
-        return false;
-    }
-
-    serialize() {
-        return ["image", this.input.serialize()];
-    }
-}

package/src/style-spec/expression/definitions/in.js

@@ -1,92 +0,0 @@
-// @flow
-
-import {ValueType, BooleanType, toString} from '../types';
-import RuntimeError from '../runtime_error';
-import {typeOf} from '../values';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-import type {Value} from '../values';
-
-function isComparableType(type: Type) {
-    return type.kind === 'boolean' ||
-           type.kind === 'string' ||
-           type.kind === 'number' ||
-           type.kind === 'null' ||
-           type.kind === 'value';
-}
-
-function isComparableRuntimeValue(needle: boolean | string | number | null) {
-    return typeof needle === 'boolean' ||
-           typeof needle === 'string' ||
-           typeof needle === 'number';
-}
-
-function isSearchableRuntimeValue(haystack: Array<Value> | string) {
-    return Array.isArray(haystack) ||
-           typeof haystack === 'string';
-}
-
-class In implements Expression {
-    type: Type;
-    needle: Expression;
-    haystack: Expression;
-
-    constructor(needle: Expression, haystack: Expression) {
-        this.type = BooleanType;
-        this.needle = needle;
-        this.haystack = haystack;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 3) {
-            return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
-        }
-
-        const needle = context.parse(args[1], 1, ValueType);
-
-        const haystack = context.parse(args[2], 2, ValueType);
-
-        if (!needle || !haystack) return null;
-
-        if (!isComparableType(needle.type)) {
-            return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
-        }
-
-        return new In(needle, haystack);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const needle = (this.needle.evaluate(ctx): any);
-        const haystack = (this.haystack.evaluate(ctx): any);
-
-        if (needle == null || !haystack) return false;
-
-        if (!isComparableRuntimeValue(needle)) {
-            throw new RuntimeError(`Expected first argument to be of type boolean, string or number, but found ${toString(typeOf(needle))} instead.`);
-        }
-
-        if (!isSearchableRuntimeValue(haystack)) {
-            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
-        }
-
-        return haystack.indexOf(needle) >= 0;
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.needle);
-        fn(this.haystack);
-    }
-
-    outputDefined() {
-        return true;
-    }
-
-    serialize() {
-        return ["in", this.needle.serialize(), this.haystack.serialize()];
-    }
-}
-
-export default In;