@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,142 +0,0 @@
-// @flow
-
-import {StringType, NumberType} from '../types';
-
-import type {Expression} from '../expression';
-import type EvaluationContext from '../evaluation_context';
-import type ParsingContext from '../parsing_context';
-import type {Type} from '../types';
-
-declare var Intl: {
-    NumberFormat: Class<Intl$NumberFormat>
-};
-
-declare class Intl$NumberFormat {
-    constructor (
-        locales?: string | string[],
-        options?: NumberFormatOptions
-    ): Intl$NumberFormat;
-
-    static (
-        locales?: string | string[],
-        options?: NumberFormatOptions
-    ): Intl$NumberFormat;
-
-    format(a: number): string;
-
-    resolvedOptions(): any;
-}
-
-type NumberFormatOptions = {
-    style?: 'decimal' | 'currency' | 'percent';
-    currency?: null | string;
-    minimumFractionDigits?: null | string;
-    maximumFractionDigits?: null | string;
-};
-
-export default class NumberFormat implements Expression {
-    type: Type;
-    number: Expression;
-    locale: Expression | null;   // BCP 47 language tag
-    currency: Expression | null; // ISO 4217 currency code, required if style=currency
-    minFractionDigits: Expression | null; // Default 0
-    maxFractionDigits: Expression | null; // Default 3
-
-    constructor(number: Expression,
-                locale: Expression | null,
-                currency: Expression | null,
-                minFractionDigits: Expression | null,
-                maxFractionDigits: Expression | null) {
-        this.type = StringType;
-        this.number = number;
-        this.locale = locale;
-        this.currency = currency;
-        this.minFractionDigits = minFractionDigits;
-        this.maxFractionDigits = maxFractionDigits;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
-        if (args.length !== 3)
-            return context.error(`Expected two arguments.`);
-
-        const number = context.parse(args[1], 1, NumberType);
-        if (!number) return null;
-
-        const options = (args[2]: any);
-        if (typeof options !== "object" || Array.isArray(options))
-            return context.error(`NumberFormat options argument must be an object.`);
-
-        let locale = null;
-        if (options['locale']) {
-            locale = context.parse(options['locale'], 1, StringType);
-            if (!locale) return null;
-        }
-
-        let currency = null;
-        if (options['currency']) {
-            currency = context.parse(options['currency'], 1, StringType);
-            if (!currency) return null;
-        }
-
-        let minFractionDigits = null;
-        if (options['min-fraction-digits']) {
-            minFractionDigits = context.parse(options['min-fraction-digits'], 1, NumberType);
-            if (!minFractionDigits) return null;
-        }
-
-        let maxFractionDigits = null;
-        if (options['max-fraction-digits']) {
-            maxFractionDigits = context.parse(options['max-fraction-digits'], 1, NumberType);
-            if (!maxFractionDigits) return null;
-        }
-
-        return new NumberFormat(number, locale, currency, minFractionDigits, maxFractionDigits);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [],
-            {
-                style: this.currency ? "currency" : "decimal",
-                currency: this.currency ? this.currency.evaluate(ctx) : undefined,
-                minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : undefined,
-                maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : undefined,
-            }).format(this.number.evaluate(ctx));
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.number);
-        if (this.locale) {
-            fn(this.locale);
-        }
-        if (this.currency) {
-            fn(this.currency);
-        }
-        if (this.minFractionDigits) {
-            fn(this.minFractionDigits);
-        }
-        if (this.maxFractionDigits) {
-            fn(this.maxFractionDigits);
-        }
-    }
-
-    outputDefined() {
-        return false;
-    }
-
-    serialize() {
-        const options = {};
-        if (this.locale) {
-            options['locale'] = this.locale.serialize();
-        }
-        if (this.currency) {
-            options['currency'] = this.currency.serialize();
-        }
-        if (this.minFractionDigits) {
-            options['min-fraction-digits'] = this.minFractionDigits.serialize();
-        }
-        if (this.maxFractionDigits) {
-            options['max-fraction-digits'] = this.maxFractionDigits.serialize();
-        }
-        return ["number-format", this.number.serialize(), options];
-    }
-}

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

@@ -1,120 +0,0 @@
-// @flow
-
-import {NumberType} from '../types';
-
-import {findStopLessThanOrEqualTo} from '../stops';
-
-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';
-
-class Step implements Expression {
-    type: Type;
-
-    input: Expression;
-    labels: Array<number>;
-    outputs: Array<Expression>;
-
-    constructor(type: Type, input: Expression, stops: Stops) {
-        this.type = type;
-        this.input = input;
-
-        this.labels = [];
-        this.outputs = [];
-        for (const [label, expression] of stops) {
-            this.labels.push(label);
-            this.outputs.push(expression);
-        }
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        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.`);
-        }
-
-        const input = context.parse(args[1], 1, NumberType);
-        if (!input) return null;
-
-        const stops: Stops = [];
-
-        let outputType: Type = (null: any);
-        if (context.expectedType && context.expectedType.kind !== 'value') {
-            outputType = context.expectedType;
-        }
-
-        for (let i = 1; i < args.length; i += 2) {
-            const label = i === 1 ? -Infinity : args[i];
-            const value = args[i + 1];
-
-            const labelKey = i;
-            const valueKey = i + 1;
-
-            if (typeof label !== 'number') {
-                return context.error('Input/output pairs for "step" 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 "step" 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]);
-        }
-
-        return new Step(outputType, 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);
-        return outputs[index].evaluate(ctx);
-    }
-
-    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() {
-        const serialized = ["step", this.input.serialize()];
-        for (let i = 0; i < this.labels.length; i++) {
-            if (i > 0) {
-                serialized.push(this.labels[i]);
-            }
-            serialized.push(this.outputs[i].serialize());
-        }
-        return serialized;
-    }
-}
-
-export default Step;

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

@@ -1,46 +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 Var implements Expression {
-    type: Type;
-    name: string;
-    boundExpression: Expression;
-
-    constructor(name: string, boundExpression: Expression) {
-        this.type = boundExpression.type;
-        this.name = name;
-        this.boundExpression = boundExpression;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 2 || typeof args[1] !== 'string')
-            return context.error(`'var' expression requires exactly one string literal argument.`);
-
-        const name = args[1];
-        if (!context.scope.has(name)) {
-            return context.error(`Unknown variable "${name}". Make sure "${name}" has been bound in an enclosing "let" expression before using it.`, 1);
-        }
-
-        return new Var(name, context.scope.get(name));
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        return this.boundExpression.evaluate(ctx);
-    }
-
-    eachChild() {}
-
-    outputDefined() {
-        return false;
-    }
-
-    serialize() {
-        return ["var", this.name];
-    }
-}
-
-export default Var;

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

@@ -1,333 +0,0 @@
-// @flow
-
-import {isValue} from '../values';
-import type {Type} from '../types';
-import {BooleanType} from '../types';
-import type {Expression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {GeoJSON, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
-import MercatorCoordinate from '../../../geo/mercator_coordinate';
-import EXTENT from '../../../data/extent';
-import Point from '@mapbox/point-geometry';
-import type {CanonicalTileID} from '../../../source/tile_id';
-
-type GeoJSONPolygons =| GeoJSONPolygon | GeoJSONMultiPolygon;
-
-// minX, minY, maxX, maxY
-type BBox = [number, number, number, number];
-function updateBBox(bbox: BBox, coord: Point) {
-    bbox[0] = Math.min(bbox[0], coord[0]);
-    bbox[1] = Math.min(bbox[1], coord[1]);
-    bbox[2] = Math.max(bbox[2], coord[0]);
-    bbox[3] = Math.max(bbox[3], coord[1]);
-}
-
-function boxWithinBox(bbox1: BBox, bbox2: BBox) {
-    if (bbox1[0] <= bbox2[0]) return false;
-    if (bbox1[2] >= bbox2[2]) return false;
-    if (bbox1[1] <= bbox2[1]) return false;
-    if (bbox1[3] >= bbox2[3]) return false;
-    return true;
-}
-
-function getTileCoordinates(p, canonical: CanonicalTileID) {
-    const coord = MercatorCoordinate.fromLngLat({lng: p[0], lat: p[1]}, 0);
-    const tilesAtZoom = Math.pow(2, canonical.z);
-    return [Math.round(coord.x * tilesAtZoom * EXTENT), Math.round(coord.y * tilesAtZoom * EXTENT)];
-}
-
-function onBoundary(p, p1, p2) {
-    const x1 = p[0] - p1[0];
-    const y1 = p[1] - p1[1];
-    const x2 = p[0] - p2[0];
-    const y2 = p[1] - p2[1];
-    return (x1 * y2 - x2 * y1 === 0) && (x1 * x2 <= 0) && (y1 * y2 <= 0);
-}
-
-function rayIntersect(p, p1, p2) {
-    return ((p1[1] > p[1]) !== (p2[1] > p[1])) && (p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0]);
-}
-
-// ray casting algorithm for detecting if point is in polygon
-function pointWithinPolygon(point, rings) {
-    let inside = false;
-    for (let i = 0, len = rings.length; i < len; i++) {
-        const ring = rings[i];
-        for (let j = 0, len2 = ring.length; j < len2 - 1; j++) {
-            if (onBoundary(point, ring[j], ring[j + 1])) return false;
-            if (rayIntersect(point, ring[j], ring[j + 1])) inside = !inside;
-        }
-    }
-    return inside;
-}
-
-function pointWithinPolygons(point, polygons) {
-    for (let i = 0; i < polygons.length; i++) {
-        if (pointWithinPolygon(point, polygons[i])) return true;
-    }
-    return false;
-}
-
-function perp(v1, v2) {
-    return (v1[0] * v2[1] - v1[1] * v2[0]);
-}
-
-// check if p1 and p2 are in different sides of line segment q1->q2
-function  twoSided(p1, p2, q1, q2) {
-    // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
-    const x1 = p1[0] - q1[0];
-    const y1 = p1[1] - q1[1];
-    const x2 = p2[0] - q1[0];
-    const y2 = p2[1] - q1[1];
-    const x3 = q2[0] - q1[0];
-    const y3 = q2[1] - q1[1];
-    const det1 = (x1 * y3 - x3 * y1);
-    const det2 =  (x2 * y3 - x3 * y2);
-    if ((det1 > 0 && det2 < 0) || (det1 < 0 && det2 > 0)) return true;
-    return false;
-}
-// a, b are end points for line segment1, c and d are end points for line segment2
-function lineIntersectLine(a, b, c, d) {
-    // check if two segments are parallel or not
-    // precondition is end point a, b is inside polygon, if line a->b is
-    // parallel to polygon edge c->d, then a->b won't intersect with c->d
-    const vectorP = [b[0] - a[0], b[1] - a[1]];
-    const vectorQ = [d[0] - c[0], d[1] - c[1]];
-    if (perp(vectorQ, vectorP) === 0) return false;
-
-    // If lines are intersecting with each other, the relative location should be:
-    // a and b lie in different sides of segment c->d
-    // c and d lie in different sides of segment a->b
-    if (twoSided(a, b, c, d) && twoSided(c, d, a, b)) return true;
-    return false;
-}
-
-function lineIntersectPolygon(p1, p2, polygon) {
-    for (const ring of polygon) {
-        // loop through every edge of the ring
-        for (let j = 0; j < ring.length - 1; ++j) {
-            if (lineIntersectLine(p1, p2, ring[j], ring[j + 1])) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-function lineStringWithinPolygon(line, polygon) {
-    // First, check if geometry points of line segments are all inside polygon
-    for (let i = 0; i < line.length; ++i) {
-        if (!pointWithinPolygon(line[i], polygon)) {
-            return false;
-        }
-    }
-
-    // Second, check if there is line segment intersecting polygon edge
-    for (let i = 0; i < line.length - 1; ++i) {
-        if (lineIntersectPolygon(line[i], line[i + 1], polygon)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-function lineStringWithinPolygons(line, polygons) {
-    for (let i = 0; i < polygons.length; i++) {
-        if (lineStringWithinPolygon(line, polygons[i])) return true;
-    }
-    return false;
-}
-
-function getTilePolygon(coordinates, bbox, canonical) {
-    const polygon = [];
-    for (let i = 0; i < coordinates.length; i++) {
-        const ring = [];
-        for (let j = 0; j < coordinates[i].length; j++) {
-            const coord = getTileCoordinates(coordinates[i][j], canonical);
-            updateBBox(bbox, coord);
-            ring.push(coord);
-        }
-        polygon.push(ring);
-    }
-    return polygon;
-}
-
-function getTilePolygons(coordinates, bbox, canonical) {
-    const polygons = [];
-    for (let i = 0; i < coordinates.length; i++) {
-        const polygon = getTilePolygon(coordinates[i], bbox, canonical);
-        polygons.push(polygon);
-    }
-    return polygons;
-}
-
-function updatePoint(p, bbox, polyBBox, worldSize) {
-    if (p[0] < polyBBox[0] || p[0] > polyBBox[2]) {
-        const halfWorldSize = worldSize * 0.5;
-        let shift = (p[0] - polyBBox[0] > halfWorldSize) ? -worldSize : (polyBBox[0] - p[0] > halfWorldSize) ? worldSize : 0;
-        if (shift === 0) {
-            shift = (p[0] - polyBBox[2] > halfWorldSize) ? -worldSize : (polyBBox[2] - p[0] > halfWorldSize) ? worldSize : 0;
-        }
-        p[0] += shift;
-    }
-    updateBBox(bbox, p);
-}
-
-function resetBBox(bbox) {
-    bbox[0] = bbox[1] = Infinity;
-    bbox[2] = bbox[3] = -Infinity;
-}
-
-function getTilePoints(geometry, pointBBox, polyBBox, canonical) {
-    const worldSize = Math.pow(2, canonical.z) * EXTENT;
-    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
-    const tilePoints = [];
-    for (const points of geometry) {
-        for (const point of points) {
-            const p = [point.x + shifts[0], point.y + shifts[1]];
-            updatePoint(p, pointBBox, polyBBox, worldSize);
-            tilePoints.push(p);
-        }
-    }
-    return tilePoints;
-}
-
-function getTileLines(geometry, lineBBox, polyBBox, canonical) {
-    const worldSize = Math.pow(2, canonical.z) * EXTENT;
-    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
-    const tileLines = [];
-    for (const line of geometry) {
-        const tileLine = [];
-        for (const point of line) {
-            const p = [point.x + shifts[0], point.y + shifts[1]];
-            updateBBox(lineBBox, p);
-            tileLine.push(p);
-        }
-        tileLines.push(tileLine);
-    }
-    if (lineBBox[2] - lineBBox[0] <= worldSize / 2) {
-        resetBBox(lineBBox);
-        for (const line of tileLines) {
-            for (const p of line) {
-                updatePoint(p, lineBBox, polyBBox, worldSize);
-            }
-        }
-    }
-    return tileLines;
-}
-
-function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
-    const pointBBox = [Infinity, Infinity, -Infinity, -Infinity];
-    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
-
-    const canonical = ctx.canonicalID();
-
-    if (polygonGeometry.type === 'Polygon') {
-        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
-        const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
-        if (!boxWithinBox(pointBBox, polyBBox)) return false;
-
-        for (const point of tilePoints) {
-            if (!pointWithinPolygon(point, tilePolygon)) return false;
-        }
-    }
-    if (polygonGeometry.type === 'MultiPolygon') {
-        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
-        const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
-        if (!boxWithinBox(pointBBox, polyBBox)) return false;
-
-        for (const point of tilePoints) {
-            if (!pointWithinPolygons(point, tilePolygons)) return false;
-        }
-    }
-
-    return true;
-}
-
-function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
-    const lineBBox = [Infinity, Infinity, -Infinity, -Infinity];
-    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
-
-    const canonical = ctx.canonicalID();
-
-    if (polygonGeometry.type === 'Polygon') {
-        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
-        const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
-        if (!boxWithinBox(lineBBox, polyBBox)) return false;
-
-        for (const line of tileLines) {
-            if (!lineStringWithinPolygon(line, tilePolygon)) return false;
-        }
-    }
-    if (polygonGeometry.type === 'MultiPolygon') {
-        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
-        const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
-        if (!boxWithinBox(lineBBox, polyBBox)) return false;
-
-        for (const line of tileLines) {
-            if (!lineStringWithinPolygons(line, tilePolygons)) return false;
-        }
-    }
-    return true;
-}
-
-class Within implements Expression {
-    type: Type;
-    geojson: GeoJSON
-    geometries: GeoJSONPolygons;
-
-    constructor(geojson: GeoJSON, geometries: GeoJSONPolygons) {
-        this.type = BooleanType;
-        this.geojson = geojson;
-        this.geometries = geometries;
-    }
-
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
-        if (args.length !== 2)
-            return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
-        if (isValue(args[1])) {
-            const geojson = (args[1]: Object);
-            if (geojson.type === 'FeatureCollection') {
-                for (let i = 0; i < geojson.features.length; ++i) {
-                    const type = geojson.features[i].geometry.type;
-                    if (type === 'Polygon' || type === 'MultiPolygon') {
-                        return new Within(geojson, geojson.features[i].geometry);
-                    }
-                }
-            } else if (geojson.type === 'Feature') {
-                const type = geojson.geometry.type;
-                if (type === 'Polygon' || type === 'MultiPolygon') {
-                    return new Within(geojson, geojson.geometry);
-                }
-            } else if (geojson.type  === 'Polygon' || geojson.type === 'MultiPolygon') {
-                return new Within(geojson, geojson);
-            }
-        }
-        return context.error(`'within' expression requires valid geojson object that contains polygon geometry type.`);
-    }
-
-    evaluate(ctx: EvaluationContext) {
-        if (ctx.geometry() != null && ctx.canonicalID() != null) {
-            if (ctx.geometryType() === 'Point') {
-                return pointsWithinPolygons(ctx, this.geometries);
-            } else if (ctx.geometryType() === 'LineString') {
-                return linesWithinPolygons(ctx, this.geometries);
-            }
-        }
-        return false;
-    }
-
-    eachChild() {}
-
-    outputDefined(): boolean {
-        return true;
-    }
-
-    serialize(): Array<mixed> {
-        return ["within", this.geojson];
-    }
-
-}
-
-export default Within;

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

@@ -1,59 +0,0 @@
-// @flow
-
-import {Color} from './values';
-import type {FormattedSection} from './types/formatted';
-import type {GlobalProperties, Feature, FeatureState} from './index';
-import type {CanonicalTileID} from '../../source/tile_id';
-
-const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
-
-class EvaluationContext {
-    globals: GlobalProperties;
-    feature: ?Feature;
-    featureState: ?FeatureState;
-    formattedSection: ?FormattedSection;
-    availableImages: ?Array<string>;
-    canonical: ?CanonicalTileID;
-
-    _parseColorCache: {[_: string]: ?Color};
-
-    constructor() {
-        this.globals = (null: any);
-        this.feature = null;
-        this.featureState = null;
-        this.formattedSection = null;
-        this._parseColorCache = {};
-        this.availableImages = null;
-        this.canonical = null;
-    }
-
-    id() {
-        return this.feature && 'id' in this.feature ? this.feature.id : null;
-    }
-
-    geometryType() {
-        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
-    }
-
-    geometry() {
-        return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
-    }
-
-    canonicalID() {
-        return this.canonical;
-    }
-
-    properties() {
-        return this.feature && this.feature.properties || {};
-    }
-
-    parseColor(input: string): ?Color {
-        let cached = this._parseColorCache[input];
-        if (!cached) {
-            cached = this._parseColorCache[input] = Color.parse(input);
-        }
-        return cached;
-    }
-}
-
-export default EvaluationContext;