@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,267 +0,0 @@
-// @flow
-
-import UnitBezier from '@mapbox/unitbezier';
-
-import * as interpolate from '../../util/interpolate';
-import {toString, NumberType, ColorType} from '../types';
-import {findStopLessThanOrEqualTo} from '../stops';
-import {hcl, lab} from '../../util/color_spaces';
-
-import type {Stops} from '../stops';
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-export type InterpolationType =
-    { name: 'linear' } |
-    { name: 'exponential', base: number } |
-    { name: 'cubic-bezier', controlPoints: [number, number, number, number] };
-
-class Interpolate implements Expression {
-    type: Type;
-
-    operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab';
-    interpolation: InterpolationType;
-    input: Expression;
-    labels: Array<number>;
-    outputs: Array<Expression>;
-
-    constructor(type: Type, operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab', interpolation: InterpolationType, input: Expression, stops: Stops) {
-        this.type = type;
-        this.operator = operator;
-        this.interpolation = interpolation;
-        this.input = input;
-
-        this.labels = [];
-        this.outputs = [];
-        for (const [label, expression] of stops) {
-            this.labels.push(label);
-            this.outputs.push(expression);
-        }
-    }
-
-    static interpolationFactor(interpolation: InterpolationType, input: number, lower: number, upper: number) {
-        let t = 0;
-        if (interpolation.name === 'exponential') {
-            t = exponentialInterpolation(input, interpolation.base, lower, upper);
-        } else if (interpolation.name === 'linear') {
-            t = exponentialInterpolation(input, 1, lower, upper);
-        } else if (interpolation.name === 'cubic-bezier') {
-            const c = interpolation.controlPoints;
-            const ub = new UnitBezier(c[0], c[1], c[2], c[3]);
-            t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
-        }
-        return t;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        let [operator, interpolation, input, ...rest] = args;
-
-        if (!Array.isArray(interpolation) || interpolation.length === 0) {
-            return context.error(`Expected an interpolation type expression.`, 1);
-        }
-
-        if (interpolation[0] === 'linear') {
-            interpolation = {name: 'linear'};
-        } else if (interpolation[0] === 'exponential') {
-            const base = interpolation[1];
-            if (typeof base !== 'number')
-                return context.error(`Exponential interpolation requires a numeric base.`, 1, 1);
-            interpolation = {
-                name: 'exponential',
-                base
-            };
-        } else if (interpolation[0] === 'cubic-bezier') {
-            const controlPoints = interpolation.slice(1);
-            if (
-                controlPoints.length !== 4 ||
-                controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)
-            ) {
-                return context.error('Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.', 1);
-            }
-
-            interpolation = {
-                name: 'cubic-bezier',
-                controlPoints: (controlPoints: any)
-            };
-        } else {
-            return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
-        }
-
-        if (args.length - 1 < 4) {
-            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-        }
-
-        if ((args.length - 1) % 2 !== 0) {
-            return context.error(`Expected an even number of arguments.`);
-        }
-
-        input = context.parse(input, 2, NumberType);
-        if (!input) return null;
-
-        const stops: Stops = [];
-
-        let outputType: Type = (null: any);
-        if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
-            outputType = ColorType;
-        } else if (context.expectedType && context.expectedType.kind !== 'value') {
-            outputType = context.expectedType;
-        }
-
-        for (let i = 0; i < rest.length; i += 2) {
-            const label = rest[i];
-            const value = rest[i + 1];
-
-            const labelKey = i + 3;
-            const valueKey = i + 4;
-
-            if (typeof label !== 'number') {
-                return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
-            }
-
-            if (stops.length && stops[stops.length - 1][0] >= label) {
-                return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
-            }
-
-            const parsed = context.parse(value, valueKey, outputType);
-            if (!parsed) return null;
-            outputType = outputType || parsed.type;
-            stops.push([label, parsed]);
-        }
-
-        if (outputType.kind !== 'number' &&
-            outputType.kind !== 'color' &&
-            !(
-                outputType.kind === 'array' &&
-                outputType.itemType.kind === 'number' &&
-                typeof outputType.N === 'number'
-            )
-        ) {
-            return context.error(`Type ${toString(outputType)} is not interpolatable.`);
-        }
-
-        return new Interpolate(outputType, (operator: any), interpolation, input, stops);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const labels = this.labels;
-        const outputs = this.outputs;
-
-        if (labels.length === 1) {
-            return outputs[0].evaluate(ctx);
-        }
-
-        const value = ((this.input.evaluate(ctx): any): number);
-        if (value <= labels[0]) {
-            return outputs[0].evaluate(ctx);
-        }
-
-        const stopCount = labels.length;
-        if (value >= labels[stopCount - 1]) {
-            return outputs[stopCount - 1].evaluate(ctx);
-        }
-
-        const index = findStopLessThanOrEqualTo(labels, value);
-        const lower = labels[index];
-        const upper = labels[index + 1];
-        const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
-
-        const outputLower = outputs[index].evaluate(ctx);
-        const outputUpper = outputs[index + 1].evaluate(ctx);
-
-        if (this.operator === 'interpolate') {
-            return (interpolate[this.type.kind.toLowerCase()]: any)(outputLower, outputUpper, t); // eslint-disable-line import/namespace
-        } else if (this.operator === 'interpolate-hcl') {
-            return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
-        } else {
-            return lab.reverse(lab.interpolate(lab.forward(outputLower), lab.forward(outputUpper), t));
-        }
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.input);
-        for (const expression of this.outputs) {
-            fn(expression);
-        }
-    }
-
-    outputDefined(): boolean {
-        return this.outputs.every(out => out.outputDefined());
-    }
-
-    serialize(): Array<mixed> {
-        let interpolation;
-        if (this.interpolation.name === 'linear') {
-            interpolation = ["linear"];
-        } else if (this.interpolation.name === 'exponential') {
-            if  (this.interpolation.base === 1) {
-                interpolation = ["linear"];
-            } else {
-                interpolation = ["exponential", this.interpolation.base];
-            }
-        } else {
-            interpolation = ["cubic-bezier" ].concat(this.interpolation.controlPoints);
-        }
-
-        const serialized = [this.operator, interpolation, this.input.serialize()];
-
-        for (let i = 0; i < this.labels.length; i++) {
-            serialized.push(
-                this.labels[i],
-                this.outputs[i].serialize()
-            );
-        }
-        return serialized;
-    }
-}
-
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- * How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
-*/
-function exponentialInterpolation(input, base, lowerValue, upperValue) {
-    const difference = upperValue - lowerValue;
-    const progress = input - lowerValue;
-
-    if (difference === 0) {
-        return 0;
-    } else if (base === 1) {
-        return progress / difference;
-    } else {
-        return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
-    }
-}
-
-export default Interpolate;

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

@@ -1,61 +0,0 @@
-// @flow
-
-import {NumberType, toString} from '../types';
-
-import {typeOf} from '../values';
-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} from '../types';
-
-class Length implements Expression {
-    type: Type;
-    input: Expression;
-
-    constructor(input: Expression) {
-        this.type = NumberType;
-        this.input = input;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 2)
-            return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
-
-        const input = context.parse(args[1], 1);
-        if (!input) return null;
-
-        if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
-            return context.error(`Expected argument of type string or array, but found ${toString(input.type)} instead.`);
-
-        return new Length(input);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const input = this.input.evaluate(ctx);
-        if (typeof input === 'string') {
-            return input.length;
-        } else if (Array.isArray(input)) {
-            return input.length;
-        } else {
-            throw new RuntimeError(`Expected value to be of type string or array, but found ${toString(typeOf(input))} instead.`);
-        }
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.input);
-    }
-
-    outputDefined() {
-        return false;
-    }
-
-    serialize() {
-        const serialized = ["length"];
-        this.eachChild(child => { serialized.push(child.serialize()); });
-        return serialized;
-    }
-}
-
-export default Length;

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

@@ -1,72 +0,0 @@
-// @flow
-
-import type {Type} from '../types';
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext  from '../evaluation_context';
-
-class Let implements Expression {
-    type: Type;
-    bindings: Array<[string, Expression]>;
-    result: Expression;
-
-    constructor(bindings: Array<[string, Expression]>, result: Expression) {
-        this.type = result.type;
-        this.bindings = [].concat(bindings);
-        this.result = result;
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        return this.result.evaluate(ctx);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        for (const binding of this.bindings) {
-            fn(binding[1]);
-        }
-        fn(this.result);
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length < 4)
-            return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
-
-        const bindings: Array<[string, Expression]> = [];
-        for (let i = 1; i < args.length - 1; i += 2) {
-            const name = args[i];
-
-            if (typeof name !== 'string') {
-                return context.error(`Expected string, but found ${typeof name} instead.`, i);
-            }
-
-            if (/[^a-zA-Z0-9_]/.test(name)) {
-                return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
-            }
-
-            const value = context.parse(args[i + 1], i + 1);
-            if (!value) return null;
-
-            bindings.push([name, value]);
-        }
-
-        const result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
-        if (!result) return null;
-
-        return new Let(bindings, result);
-    }
-
-    outputDefined() {
-        return this.result.outputDefined();
-    }
-
-    serialize() {
-        const serialized = ["let"];
-        for (const [name, expr] of this.bindings) {
-            serialized.push(name, expr.serialize());
-        }
-        serialized.push(this.result.serialize());
-        return serialized;
-    }
-}
-
-export default Let;

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

@@ -1,77 +0,0 @@
-// @flow
-
-import assert from 'assert';
-import {isValue, typeOf, Color} from '../values';
-import Formatted from '../types/formatted';
-
-import type {Type} from '../types';
-import type {Value}  from '../values';
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-
-class Literal implements Expression {
-    type: Type;
-    value: Value;
-
-    constructor(type: Type, value: Value) {
-        this.type = type;
-        this.value = value;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 2)
-            return context.error(`'literal' expression requires exactly one argument, but found ${args.length - 1} instead.`);
-
-        if (!isValue(args[1]))
-            return context.error(`invalid value`);
-
-        const value = (args[1]: any);
-        let type = typeOf(value);
-
-        // special case: infer the item type if possible for zero-length arrays
-        const expected = context.expectedType;
-        if (
-            type.kind === 'array' &&
-            type.N === 0 &&
-            expected &&
-            expected.kind === 'array' &&
-            (typeof expected.N !== 'number' || expected.N === 0)
-        ) {
-            type = expected;
-        }
-
-        return new Literal(type, value);
-    }
-
-    evaluate() {
-        return this.value;
-    }
-
-    eachChild() {}
-
-    outputDefined() {
-        return true;
-    }
-
-    serialize(): Array<mixed> {
-        if (this.type.kind === 'array' || this.type.kind === 'object') {
-            return ["literal", this.value];
-        } else if (this.value instanceof Color) {
-            // Constant-folding can generate Literal expressions that you
-            // couldn't actually generate with a "literal" expression,
-            // so we have to implement an equivalent serialization here
-            return ["rgba"].concat(this.value.toArray());
-        } else if (this.value instanceof Formatted) {
-            // Same as Color
-            return this.value.serialize();
-        } else {
-            assert(this.value === null ||
-                typeof this.value === 'string' ||
-                typeof this.value === 'number' ||
-                typeof this.value === 'boolean');
-            return (this.value: any);
-        }
-    }
-}
-
-export default Literal;

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

@@ -1,158 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import {typeOf} from '../values';
-import {ValueType, type Type} from '../types';
-
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-
-// Map input label values to output expression index
-type Cases = {[number | string]: number};
-
-class Match implements Expression {
-    type: Type;
-    inputType: Type;
-
-    input: Expression;
-    cases: Cases;
-    outputs: Array<Expression>;
-    otherwise: Expression;
-
-    constructor(inputType: Type, outputType: Type, input: Expression, cases: Cases, outputs: Array<Expression>, otherwise: Expression) {
-        this.inputType = inputType;
-        this.type = outputType;
-        this.input = input;
-        this.cases = cases;
-        this.outputs = outputs;
-        this.otherwise = otherwise;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length < 5)
-            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-        if (args.length % 2 !== 1)
-            return context.error(`Expected an even number of arguments.`);
-
-        let inputType;
-        let outputType;
-        if (context.expectedType && context.expectedType.kind !== 'value') {
-            outputType = context.expectedType;
-        }
-        const cases = {};
-        const outputs = [];
-        for (let i = 2; i < args.length - 1; i += 2) {
-            let labels = args[i];
-            const value = args[i + 1];
-
-            if (!Array.isArray(labels)) {
-                labels = [labels];
-            }
-
-            const labelContext = context.concat(i);
-            if (labels.length === 0) {
-                return labelContext.error('Expected at least one branch label.');
-            }
-
-            for (const label of labels) {
-                if (typeof label !== 'number' && typeof label !== 'string') {
-                    return labelContext.error(`Branch labels must be numbers or strings.`);
-                } else if (typeof label === 'number' && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
-                    return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
-
-                } else if (typeof label === 'number' && Math.floor(label) !== label) {
-                    return labelContext.error(`Numeric branch labels must be integer values.`);
-
-                } else if (!inputType) {
-                    inputType = typeOf(label);
-                } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
-                    return null;
-                }
-
-                if (typeof cases[String(label)] !== 'undefined') {
-                    return labelContext.error('Branch labels must be unique.');
-                }
-
-                cases[String(label)] = outputs.length;
-            }
-
-            const result = context.parse(value, i, outputType);
-            if (!result) return null;
-            outputType = outputType || result.type;
-            outputs.push(result);
-        }
-
-        const input = context.parse(args[1], 1, ValueType);
-        if (!input) return null;
-
-        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
-        if (!otherwise) return null;
-
-        assert(inputType && outputType);
-
-        if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType: any), input.type)) {
-            return null;
-        }
-
-        return new Match((inputType: any), (outputType: any), input, cases, outputs, otherwise);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        const input = (this.input.evaluate(ctx): any);
-        const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
-        return output.evaluate(ctx);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.input);
-        this.outputs.forEach(fn);
-        fn(this.otherwise);
-    }
-
-    outputDefined(): boolean {
-        return this.outputs.every(out => out.outputDefined()) && this.otherwise.outputDefined();
-    }
-
-    serialize(): Array<mixed> {
-        const serialized = ["match", this.input.serialize()];
-
-        // Sort so serialization has an arbitrary defined order, even though
-        // branch order doesn't affect evaluation
-        const sortedLabels = Object.keys(this.cases).sort();
-
-        // Group branches by unique match expression to support condensed
-        // serializations of the form [case1, case2, ...] -> matchExpression
-        const groupedByOutput: Array<[number, Array<number | string>]> = [];
-        const outputLookup: {[index: number]: number} = {}; // lookup index into groupedByOutput for a given output expression
-        for (const label of sortedLabels) {
-            const outputIndex = outputLookup[this.cases[label]];
-            if (outputIndex === undefined) {
-                // First time seeing this output, add it to the end of the grouped list
-                outputLookup[this.cases[label]] = groupedByOutput.length;
-                groupedByOutput.push([this.cases[label], [label]]);
-            } else {
-                // We've seen this expression before, add the label to that output's group
-                groupedByOutput[outputIndex][1].push(label);
-            }
-        }
-
-        const coerceLabel = (label) => this.inputType.kind === 'number' ? Number(label) : label;
-
-        for (const [outputIndex, labels] of groupedByOutput) {
-            if (labels.length === 1) {
-                // Only a single label matches this output expression
-                serialized.push(coerceLabel(labels[0]));
-            } else {
-                // Array of literal labels pointing to this output expression
-                serialized.push(labels.map(coerceLabel));
-            }
-            serialized.push(this.outputs[outputIndex].serialize());
-        }
-        serialized.push(this.otherwise.serialize());
-        return serialized;
-    }
-}
-
-export default Match;