@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,162 +0,0 @@
-// @flow
-
-import {toString} from './types';
-
-import ParsingContext from './parsing_context';
-import EvaluationContext from './evaluation_context';
-import assert from 'assert';
-
-import type {Expression, ExpressionRegistry} from './expression';
-import type {Type} from './types';
-import type {Value} from './values';
-
-export type Varargs = {| type: Type |};
-type Signature = Array<Type> | Varargs;
-type Evaluate = (EvaluationContext, Array<Expression>) => Value;
-type Definition = [Type, Signature, Evaluate] |
-    {|type: Type, overloads: Array<[Signature, Evaluate]>|};
-
-class CompoundExpression implements Expression {
-    name: string;
-    type: Type;
-    _evaluate: Evaluate;
-    args: Array<Expression>;
-
-    static definitions: {[_: string]: Definition };
-
-    constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>) {
-        this.name = name;
-        this.type = type;
-        this._evaluate = evaluate;
-        this.args = args;
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        return this._evaluate(ctx, this.args);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        this.args.forEach(fn);
-    }
-
-    outputDefined() {
-        return false;
-    }
-
-    serialize(): Array<mixed> {
-        return [this.name].concat(this.args.map(arg => arg.serialize()));
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        const op: string = (args[0]: any);
-        const definition = CompoundExpression.definitions[op];
-        if (!definition) {
-            return context.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
-        }
-
-        // Now check argument types against each signature
-        const type = Array.isArray(definition) ?
-            definition[0] : definition.type;
-
-        const availableOverloads = Array.isArray(definition) ?
-            [[definition[1], definition[2]]] :
-            definition.overloads;
-
-        const overloads = availableOverloads.filter(([signature]) => (
-            !Array.isArray(signature) || // varags
-            signature.length === args.length - 1 // correct param count
-        ));
-
-        let signatureContext: ParsingContext = (null: any);
-
-        for (const [params, evaluate] of overloads) {
-            // Use a fresh context for each attempted signature so that, if
-            // we eventually succeed, we haven't polluted `context.errors`.
-            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
-
-            // First parse all the args, potentially coercing to the
-            // types expected by this overload.
-            const parsedArgs: Array<Expression> = [];
-            let argParseFailed = false;
-            for (let i = 1; i < args.length; i++) {
-                const arg = args[i];
-                const expectedType = Array.isArray(params) ?
-                    params[i - 1] :
-                    params.type;
-
-                const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
-                if (!parsed) {
-                    argParseFailed = true;
-                    break;
-                }
-                parsedArgs.push(parsed);
-            }
-            if (argParseFailed) {
-                // Couldn't coerce args of this overload to expected type, move
-                // on to next one.
-                continue;
-            }
-
-            if (Array.isArray(params)) {
-                if (params.length !== parsedArgs.length) {
-                    signatureContext.error(`Expected ${params.length} arguments, but found ${parsedArgs.length} instead.`);
-                    continue;
-                }
-            }
-
-            for (let i = 0; i < parsedArgs.length; i++) {
-                const expected = Array.isArray(params) ? params[i] : params.type;
-                const arg = parsedArgs[i];
-                signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
-            }
-
-            if (signatureContext.errors.length === 0) {
-                return new CompoundExpression(op, type, evaluate, parsedArgs);
-            }
-        }
-
-        assert(!signatureContext || signatureContext.errors.length > 0);
-
-        if (overloads.length === 1) {
-            context.errors.push(...signatureContext.errors);
-        } else {
-            const expected = overloads.length ? overloads : availableOverloads;
-            const signatures = expected
-                .map(([params]) => stringifySignature(params))
-                .join(' | ');
-
-            const actualTypes = [];
-            // For error message, re-parse arguments without trying to
-            // apply any coercions
-            for (let i = 1; i < args.length; i++) {
-                const parsed = context.parse(args[i], 1 + actualTypes.length);
-                if (!parsed) return null;
-                actualTypes.push(toString(parsed.type));
-            }
-            context.error(`Expected arguments of type ${signatures}, but found (${actualTypes.join(', ')}) instead.`);
-        }
-
-        return null;
-    }
-
-    static register(
-        registry: ExpressionRegistry,
-        definitions: {[_: string]: Definition }
-    ) {
-        assert(!CompoundExpression.definitions);
-        CompoundExpression.definitions = definitions;
-        for (const name in definitions) {
-            registry[name] = CompoundExpression;
-        }
-    }
-}
-
-function stringifySignature(signature: Signature): string {
-    if (Array.isArray(signature)) {
-        return `(${signature.map(toString).join(', ')})`;
-    } else {
-        return `(${toString(signature.type)}...)`;
-    }
-}
-
-export default CompoundExpression;

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

@@ -1,130 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import {
-    ObjectType,
-    ValueType,
-    StringType,
-    NumberType,
-    BooleanType,
-    checkSubtype,
-    toString,
-    array
-} 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';
-
-const types = {
-    string: StringType,
-    number: NumberType,
-    boolean: BooleanType,
-    object: ObjectType
-};
-
-class Assertion implements Expression {
-    type: Type;
-    args: Array<Expression>;
-
-    constructor(type: Type, args: Array<Expression>) {
-        this.type = type;
-        this.args = args;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length < 2)
-            return context.error(`Expected at least one argument.`);
-
-        let i = 1;
-        let type;
-
-        const name: string = (args[0]: any);
-        if (name === 'array') {
-            let itemType;
-            if (args.length > 2) {
-                const type = args[1];
-                if (typeof type !== 'string' || !(type in types) || type === 'object')
-                    return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-                itemType = types[type];
-                i++;
-            } else {
-                itemType = ValueType;
-            }
-
-            let N;
-            if (args.length > 3) {
-                if (args[2] !== null &&
-                    (typeof args[2] !== 'number' ||
-                        args[2] < 0 ||
-                        args[2] !== Math.floor(args[2]))
-                ) {
-                    return context.error('The length argument to "array" must be a positive integer literal', 2);
-                }
-                N = args[2];
-                i++;
-            }
-
-            type = array(itemType, N);
-        } else {
-            assert(types[name], name);
-            type = types[name];
-        }
-
-        const parsed = [];
-        for (; i < args.length; i++) {
-            const input = context.parse(args[i], i, ValueType);
-            if (!input) return null;
-            parsed.push(input);
-        }
-
-        return new Assertion(type, parsed);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        for (let i = 0; i < this.args.length; i++) {
-            const value = this.args[i].evaluate(ctx);
-            const error = checkSubtype(this.type, typeOf(value));
-            if (!error) {
-                return value;
-            } else if (i === this.args.length - 1) {
-                throw new RuntimeError(`Expected value to be of type ${toString(this.type)}, but found ${toString(typeOf(value))} instead.`);
-            }
-        }
-
-        assert(false);
-        return null;
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        this.args.forEach(fn);
-    }
-
-    outputDefined(): boolean {
-        return this.args.every(arg => arg.outputDefined());
-    }
-
-    serialize(): Array<mixed> {
-        const type = this.type;
-        const serialized = [type.kind];
-        if (type.kind === 'array') {
-            const itemType = type.itemType;
-            if (itemType.kind === 'string' ||
-                itemType.kind === 'number' ||
-                itemType.kind === 'boolean') {
-                serialized.push(itemType.kind);
-                const N = type.N;
-                if (typeof N === 'number' || this.args.length > 1) {
-                    serialized.push(N);
-                }
-            }
-        }
-        return serialized.concat(this.args.map(arg => arg.serialize()));
-    }
-}
-
-export default Assertion;

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

@@ -1,70 +0,0 @@
-// @flow
-
-import {array, ValueType, NumberType} from '../types';
-
-import RuntimeError from '../runtime_error';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type, ArrayType} from '../types';
-import type {Value} from '../values';
-
-class At implements Expression {
-    type: Type;
-    index: Expression;
-    input: Expression;
-
-    constructor(type: Type, index: Expression, input: Expression) {
-        this.type = type;
-        this.index = index;
-        this.input = input;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 3)
-            return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
-
-        const index = context.parse(args[1], 1, NumberType);
-        const input = context.parse(args[2], 2, array(context.expectedType || ValueType));
-
-        if (!index || !input) return null;
-
-        const t: ArrayType = (input.type: any);
-        return new At(t.itemType, index, input);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const index = ((this.index.evaluate(ctx): any): number);
-        const array = ((this.input.evaluate(ctx): any): Array<Value>);
-
-        if (index < 0) {
-            throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);
-        }
-
-        if (index >= array.length) {
-            throw new RuntimeError(`Array index out of bounds: ${index} > ${array.length - 1}.`);
-        }
-
-        if (index !== Math.floor(index)) {
-            throw new RuntimeError(`Array index must be an integer, but found ${index} instead.`);
-        }
-
-        return array[index];
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.index);
-        fn(this.input);
-    }
-
-    outputDefined() {
-        return false;
-    }
-
-    serialize() {
-        return ["at", this.index.serialize(), this.input.serialize()];
-    }
-}
-
-export default At;

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

@@ -1,85 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import {BooleanType} from '../types';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-type Branches = Array<[Expression, Expression]>;
-
-class Case implements Expression {
-    type: Type;
-
-    branches: Branches;
-    otherwise: Expression;
-
-    constructor(type: Type, branches: Branches, otherwise: Expression) {
-        this.type = type;
-        this.branches = branches;
-        this.otherwise = otherwise;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length < 4)
-            return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
-        if (args.length % 2 !== 0)
-            return context.error(`Expected an odd number of arguments.`);
-
-        let outputType: ?Type;
-        if (context.expectedType && context.expectedType.kind !== 'value') {
-            outputType = context.expectedType;
-        }
-
-        const branches = [];
-        for (let i = 1; i < args.length - 1; i += 2) {
-            const test = context.parse(args[i], i, BooleanType);
-            if (!test) return null;
-
-            const result = context.parse(args[i + 1], i + 1, outputType);
-            if (!result) return null;
-
-            branches.push([test, result]);
-
-            outputType = outputType || result.type;
-        }
-
-        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
-        if (!otherwise) return null;
-
-        assert(outputType);
-        return new Case((outputType: any), branches, otherwise);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        for (const [test, expression] of this.branches) {
-            if (test.evaluate(ctx)) {
-                return expression.evaluate(ctx);
-            }
-        }
-        return this.otherwise.evaluate(ctx);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        for (const [test, expression] of this.branches) {
-            fn(test);
-            fn(expression);
-        }
-        fn(this.otherwise);
-    }
-
-    outputDefined(): boolean {
-        return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
-    }
-
-    serialize() {
-        const serialized = ["case"];
-        this.eachChild(child => { serialized.push(child.serialize()); });
-        return serialized;
-    }
-}
-
-export default Case;

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

@@ -1,93 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import {checkSubtype, ValueType} from '../types';
-import ResolvedImage from '../types/resolved_image';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-class Coalesce implements Expression {
-    type: Type;
-    args: Array<Expression>;
-
-    constructor(type: Type, args: Array<Expression>) {
-        this.type = type;
-        this.args = args;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length < 2) {
-            return context.error("Expectected at least one argument.");
-        }
-        let outputType: Type = (null: any);
-        const expectedType = context.expectedType;
-        if (expectedType && expectedType.kind !== 'value') {
-            outputType = expectedType;
-        }
-        const parsedArgs = [];
-
-        for (const arg of args.slice(1)) {
-            const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, {typeAnnotation: 'omit'});
-            if (!parsed) return null;
-            outputType = outputType || parsed.type;
-            parsedArgs.push(parsed);
-        }
-        assert(outputType);
-
-        // Above, we parse arguments without inferred type annotation so that
-        // they don't produce a runtime error for `null` input, which would
-        // preempt the desired null-coalescing behavior.
-        // Thus, if any of our arguments would have needed an annotation, we
-        // need to wrap the enclosing coalesce expression with it instead.
-        const needsAnnotation = expectedType &&
-            parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
-
-        return needsAnnotation ?
-            new Coalesce(ValueType, parsedArgs) :
-            new Coalesce((outputType: any), parsedArgs);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        let result = null;
-        let argCount = 0;
-        let requestedImageName;
-        for (const arg of this.args) {
-            argCount++;
-            result = arg.evaluate(ctx);
-            // we need to keep track of the first requested image in a coalesce statement
-            // if coalesce can't find a valid image, we return the first image name so styleimagemissing can fire
-            if (result && result instanceof ResolvedImage && !result.available) {
-                if (!requestedImageName) {
-                    requestedImageName = result.name;
-                }
-                result = null;
-                if (argCount === this.args.length) {
-                    result = requestedImageName;
-                }
-            }
-
-            if (result !== null) break;
-        }
-        return result;
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        this.args.forEach(fn);
-    }
-
-    outputDefined(): boolean {
-        return this.args.every(arg => arg.outputDefined());
-    }
-
-    serialize() {
-        const serialized = ["coalesce"];
-        this.eachChild(child => { serialized.push(child.serialize()); });
-        return serialized;
-    }
-}
-
-export default Coalesce;

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

@@ -1,133 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import {BooleanType, ColorType, NumberType, StringType, ValueType} from '../types';
-import {Color, toString as valueToString, validateRGBA} from '../values';
-import RuntimeError from '../runtime_error';
-import Formatted from '../types/formatted';
-import FormatExpression from '../definitions/format';
-import ImageExpression from '../definitions/image';
-import ResolvedImage from '../types/resolved_image';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-const types = {
-    'to-boolean': BooleanType,
-    'to-color': ColorType,
-    'to-number': NumberType,
-    'to-string': StringType
-};
-
-/**
- * Special form for error-coalescing coercion expressions "to-number",
- * "to-color".  Since these coercions can fail at runtime, they accept multiple
- * arguments, only evaluating one at a time until one succeeds.
- *
- * @private
- */
-class Coercion implements Expression {
-    type: Type;
-    args: Array<Expression>;
-
-    constructor(type: Type, args: Array<Expression>) {
-        this.type = type;
-        this.args = args;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length < 2)
-            return context.error(`Expected at least one argument.`);
-
-        const name: string = (args[0]: any);
-        assert(types[name], name);
-
-        if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
-            return context.error(`Expected one argument.`);
-
-        const type = types[name];
-
-        const parsed = [];
-        for (let i = 1; i < args.length; i++) {
-            const input = context.parse(args[i], i, ValueType);
-            if (!input) return null;
-            parsed.push(input);
-        }
-
-        return new Coercion(type, parsed);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        if (this.type.kind === 'boolean') {
-            return Boolean(this.args[0].evaluate(ctx));
-        } else if (this.type.kind === 'color') {
-            let input;
-            let error;
-            for (const arg of this.args) {
-                input = arg.evaluate(ctx);
-                error = null;
-                if (input instanceof Color) {
-                    return input;
-                } else if (typeof input === 'string') {
-                    const c = ctx.parseColor(input);
-                    if (c) return c;
-                } else if (Array.isArray(input)) {
-                    if (input.length < 3 || input.length > 4) {
-                        error = `Invalid rbga value ${JSON.stringify(input)}: expected an array containing either three or four numeric values.`;
-                    } else {
-                        error = validateRGBA(input[0], input[1], input[2], input[3]);
-                    }
-                    if (!error) {
-                        return new Color((input[0]: any) / 255, (input[1]: any) / 255, (input[2]: any) / 255, (input[3]: any));
-                    }
-                }
-            }
-            throw new RuntimeError(error || `Could not parse color from value '${typeof input === 'string' ? input : String(JSON.stringify(input))}'`);
-        } else if (this.type.kind === 'number') {
-            let value = null;
-            for (const arg of this.args) {
-                value = arg.evaluate(ctx);
-                if (value === null) return 0;
-                const num = Number(value);
-                if (isNaN(num)) continue;
-                return num;
-            }
-            throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
-        } else if (this.type.kind === 'formatted') {
-            // There is no explicit 'to-formatted' but this coercion can be implicitly
-            // created by properties that expect the 'formatted' type.
-            return Formatted.fromString(valueToString(this.args[0].evaluate(ctx)));
-        } else if (this.type.kind === 'resolvedImage') {
-            return ResolvedImage.fromString(valueToString(this.args[0].evaluate(ctx)));
-        } else {
-            return valueToString(this.args[0].evaluate(ctx));
-        }
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        this.args.forEach(fn);
-    }
-
-    outputDefined(): boolean {
-        return this.args.every(arg => arg.outputDefined());
-    }
-
-    serialize() {
-        if (this.type.kind === 'formatted') {
-            return new FormatExpression([{content: this.args[0], scale: null, font: null, textColor: null}]).serialize();
-        }
-
-        if (this.type.kind === 'resolvedImage') {
-            return new ImageExpression(this.args[0]).serialize();
-        }
-
-        const serialized = [`to-${this.type.kind}`];
-        this.eachChild(child => { serialized.push(child.serialize()); });
-        return serialized;
-    }
-}
-
-export default Coercion;