mapbox-gl 1.13.2

package/src/util/classify_rings.js

@@ -0,0 +1,52 @@
+// @flow
+
+import quickselect from 'quickselect';
+
+import {calculateSignedArea} from './util';
+
+import type Point from '@mapbox/point-geometry';
+
+// classifies an array of rings into polygons with outer rings and holes
+export default function classifyRings(rings: Array<Array<Point>>, maxRings: number) {
+    const len = rings.length;
+
+    if (len <= 1) return [rings];
+
+    const polygons = [];
+    let polygon,
+        ccw;
+
+    for (let i = 0; i < len; i++) {
+        const area = calculateSignedArea(rings[i]);
+        if (area === 0) continue;
+
+        (rings[i]: any).area = Math.abs(area);
+
+        if (ccw === undefined) ccw = area < 0;
+
+        if (ccw === area < 0) {
+            if (polygon) polygons.push(polygon);
+            polygon = [rings[i]];
+
+        } else {
+            (polygon: any).push(rings[i]);
+        }
+    }
+    if (polygon) polygons.push(polygon);
+
+    // Earcut performance degrades with the # of rings in a polygon. For this
+    // reason, we limit strip out all but the `maxRings` largest rings.
+    if (maxRings > 1) {
+        for (let j = 0; j < polygons.length; j++) {
+            if (polygons[j].length <= maxRings) continue;
+            quickselect(polygons[j], maxRings, 1, polygons[j].length - 1, compareAreas);
+            polygons[j] = polygons[j].slice(0, maxRings);
+        }
+    }
+
+    return polygons;
+}
+
+function compareAreas(a, b) {
+    return b.area - a.area;
+}

package/src/util/color_ramp.js

@@ -0,0 +1,61 @@
+// @flow
+
+import {RGBAImage} from './image';
+import {isPowerOfTwo} from './util';
+import assert from 'assert';
+
+import type {StylePropertyExpression} from '../style-spec/expression/index';
+
+export type ColorRampParams = {
+    expression: StylePropertyExpression;
+    evaluationKey: string;
+    resolution?: number;
+    image?: RGBAImage;
+    clips?: Array<Object>;
+}
+
+/**
+ * Given an expression that should evaluate to a color ramp,
+ * return a RGBA image representing that ramp expression.
+ *
+ * @private
+ */
+export function renderColorRamp(params: ColorRampParams): RGBAImage {
+    const evaluationGlobals = {};
+    const width = params.resolution || 256;
+    const height = params.clips ? params.clips.length : 1;
+    const image = params.image || new RGBAImage({width, height});
+
+    assert(isPowerOfTwo(width));
+
+    const renderPixel = (stride, index, progress) => {
+        evaluationGlobals[params.evaluationKey] = progress;
+        const pxColor = params.expression.evaluate((evaluationGlobals: any));
+        // the colors are being unpremultiplied because Color uses
+        // premultiplied values, and the Texture class expects unpremultiplied ones
+        image.data[stride + index + 0] = Math.floor(pxColor.r * 255 / pxColor.a);
+        image.data[stride + index + 1] = Math.floor(pxColor.g * 255 / pxColor.a);
+        image.data[stride + index + 2] = Math.floor(pxColor.b * 255 / pxColor.a);
+        image.data[stride + index + 3] = Math.floor(pxColor.a * 255);
+    };
+
+    if (!params.clips) {
+        for (let i = 0, j = 0; i < width; i++, j += 4) {
+            const progress = i / (width - 1);
+
+            renderPixel(0, j, progress);
+        }
+    } else {
+        for (let clip = 0, stride = 0; clip < height; ++clip, stride += width * 4) {
+            for (let i = 0, j = 0; i < width; i++, j += 4) {
+                // Remap progress between clips
+                const progress = i / (width - 1);
+                const {start, end} = params.clips[clip];
+                const evaluationProgress = start * (1 - progress) + end * progress;
+                renderPixel(stride, j, evaluationProgress);
+            }
+        }
+    }
+
+    return image;
+}

package/src/util/config.js

@@ -0,0 +1,30 @@
+// @flow strict
+
+type Config = {|
+  API_URL: string,
+  EVENTS_URL: ?string,
+  FEEDBACK_URL: string,
+  REQUIRE_ACCESS_TOKEN: boolean,
+  ACCESS_TOKEN: ?string,
+  MAX_PARALLEL_IMAGE_REQUESTS: number
+|};
+
+const config: Config = {
+    API_URL: 'https://api.mapbox.com',
+    get EVENTS_URL() {
+        if (!this.API_URL) { return null; }
+        if (this.API_URL.indexOf('https://api.mapbox.cn') === 0) {
+            return 'https://events.mapbox.cn/events/v2';
+        } else if (this.API_URL.indexOf('https://api.mapbox.com') === 0) {
+            return 'https://events.mapbox.com/events/v2';
+        } else {
+            return null;
+        }
+    },
+    FEEDBACK_URL: 'https://apps.mapbox.com/feedback',
+    REQUIRE_ACCESS_TOKEN: true,
+    ACCESS_TOKEN: null,
+    MAX_PARALLEL_IMAGE_REQUESTS: 16
+};
+
+export default config;

package/src/util/debug.js

@@ -0,0 +1,28 @@
+// @flow
+import {extend} from './util';
+import window from './window';
+
+/**
+ * This is a private namespace for utility functions that will get automatically stripped
+ * out in production builds.
+ *
+ * @private
+ */
+export const Debug = {
+    extend(dest: Object, ...sources: Array<?Object>): Object {
+        return extend(dest, ...sources);
+    },
+
+    run(fn: () => any) {
+        fn();
+    },
+
+    logToElement(message: string, overwrite: boolean = false, id: string = "log") {
+        const el = window.document.getElementById(id);
+        if (el) {
+            if (overwrite) el.innerHTML = '';
+            el.innerHTML += `<br>${message}`;
+        }
+
+    }
+};

package/src/util/dictionary_coder.js

@@ -0,0 +1,30 @@
+// @flow strict
+
+import assert from 'assert';
+
+class DictionaryCoder {
+    _stringToNumber: {[_: string]: number };
+    _numberToString: Array<string>;
+
+    constructor(strings: Array<string>) {
+        this._stringToNumber = {};
+        this._numberToString = [];
+        for (let i = 0; i < strings.length; i++) {
+            const string = strings[i];
+            this._stringToNumber[string] = i;
+            this._numberToString[i] = string;
+        }
+    }
+
+    encode(string: string) {
+        assert(string in this._stringToNumber);
+        return this._stringToNumber[string];
+    }
+
+    decode(n: number) {
+        assert(n < this._numberToString.length);
+        return this._numberToString[n];
+    }
+}
+
+export default DictionaryCoder;

package/src/util/dispatcher.js

@@ -0,0 +1,70 @@
+// @flow
+
+import {uniqueId, asyncAll} from './util';
+import Actor from './actor';
+import assert from 'assert';
+
+import type WorkerPool from './worker_pool';
+
+/**
+ * Responsible for sending messages from a {@link Source} to an associated
+ * {@link WorkerSource}.
+ *
+ * @private
+ */
+class Dispatcher {
+    workerPool: WorkerPool;
+    actors: Array<Actor>;
+    currentActor: number;
+    id: number;
+
+    // exposed to allow stubbing in unit tests
+    static Actor: Class<Actor>;
+
+    constructor(workerPool: WorkerPool, parent: any) {
+        this.workerPool = workerPool;
+        this.actors = [];
+        this.currentActor = 0;
+        this.id = uniqueId();
+        const workers = this.workerPool.acquire(this.id);
+        for (let i = 0; i < workers.length; i++) {
+            const worker = workers[i];
+            const actor = new Dispatcher.Actor(worker, parent, this.id);
+            actor.name = `Worker ${i}`;
+            this.actors.push(actor);
+        }
+        assert(this.actors.length);
+    }
+
+    /**
+     * Broadcast a message to all Workers.
+     * @private
+     */
+    broadcast(type: string, data: mixed, cb?: Function) {
+        assert(this.actors.length);
+        cb = cb || function () {};
+        asyncAll(this.actors, (actor, done) => {
+            actor.send(type, data, done);
+        }, cb);
+    }
+
+    /**
+     * Acquires an actor to dispatch messages to. The actors are distributed in round-robin fashion.
+     * @returns An actor object backed by a web worker for processing messages.
+     */
+    getActor(): Actor {
+        assert(this.actors.length);
+        this.currentActor = (this.currentActor + 1) % this.actors.length;
+        return this.actors[this.currentActor];
+    }
+
+    remove() {
+        this.actors.forEach((actor) => { actor.remove(); });
+        this.actors = [];
+        this.workerPool.release(this.id);
+    }
+}
+
+Dispatcher.Actor = Actor;
+
+export default Dispatcher;

package/src/util/dom.js

@@ -0,0 +1,142 @@
+// @flow strict
+
+import Point from '@mapbox/point-geometry';
+
+import window from './window';
+import assert from 'assert';
+
+const DOM = {};
+export default DOM;
+
+DOM.create = function (tagName: string, className: ?string, container?: HTMLElement) {
+    const el = window.document.createElement(tagName);
+    if (className !== undefined) el.className = className;
+    if (container) container.appendChild(el);
+    return el;
+};
+
+DOM.createNS = function (namespaceURI: string, tagName: string) {
+    const el = window.document.createElementNS(namespaceURI, tagName);
+    return el;
+};
+
+const docStyle = window.document && window.document.documentElement.style;
+
+function testProp(props) {
+    if (!docStyle) return props[0];
+    for (let i = 0; i < props.length; i++) {
+        if (props[i] in docStyle) {
+            return props[i];
+        }
+    }
+    return props[0];
+}
+
+const selectProp = testProp(['userSelect', 'MozUserSelect', 'WebkitUserSelect', 'msUserSelect']);
+let userSelect;
+
+DOM.disableDrag = function () {
+    if (docStyle && selectProp) {
+        userSelect = docStyle[selectProp];
+        docStyle[selectProp] = 'none';
+    }
+};
+
+DOM.enableDrag = function () {
+    if (docStyle && selectProp) {
+        docStyle[selectProp] = userSelect;
+    }
+};
+
+const transformProp = testProp(['transform', 'WebkitTransform']);
+
+DOM.setTransform = function(el: HTMLElement, value: string) {
+    // https://github.com/facebook/flow/issues/7754
+    // $FlowFixMe
+    el.style[transformProp] = value;
+};
+
+// Feature detection for {passive: false} support in add/removeEventListener.
+let passiveSupported = false;
+
+try {
+    // https://github.com/facebook/flow/issues/285
+    // $FlowFixMe
+    const options = Object.defineProperty({}, "passive", {
+        get() { // eslint-disable-line
+            passiveSupported = true;
+        }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+} catch (err) {
+    passiveSupported = false;
+}
+
+DOM.addEventListener = function(target: *, type: *, callback: *, options: {passive?: boolean, capture?: boolean} = {}) {
+    if ('passive' in options && passiveSupported) {
+        target.addEventListener(type, callback, options);
+    } else {
+        target.addEventListener(type, callback, options.capture);
+    }
+};
+
+DOM.removeEventListener = function(target: *, type: *, callback: *, options: {passive?: boolean, capture?: boolean} = {}) {
+    if ('passive' in options && passiveSupported) {
+        target.removeEventListener(type, callback, options);
+    } else {
+        target.removeEventListener(type, callback, options.capture);
+    }
+};
+
+// Suppress the next click, but only if it's immediate.
+const suppressClick: MouseEventListener = function (e) {
+    e.preventDefault();
+    e.stopPropagation();
+    window.removeEventListener('click', suppressClick, true);
+};
+
+DOM.suppressClick = function() {
+    window.addEventListener('click', suppressClick, true);
+    window.setTimeout(() => {
+        window.removeEventListener('click', suppressClick, true);
+    }, 0);
+};
+
+DOM.mousePos = function (el: HTMLElement, e: MouseEvent | window.TouchEvent | Touch) {
+    const rect = el.getBoundingClientRect();
+    return new Point(
+        e.clientX - rect.left - el.clientLeft,
+        e.clientY - rect.top - el.clientTop
+    );
+};
+
+DOM.touchPos = function (el: HTMLElement, touches: TouchList) {
+    const rect = el.getBoundingClientRect(),
+        points = [];
+    for (let i = 0; i < touches.length; i++) {
+        points.push(new Point(
+            touches[i].clientX - rect.left - el.clientLeft,
+            touches[i].clientY - rect.top - el.clientTop
+        ));
+    }
+    return points;
+};
+
+DOM.mouseButton = function (e: MouseEvent) {
+    assert(e.type === 'mousedown' || e.type === 'mouseup');
+    if (typeof window.InstallTrigger !== 'undefined' && e.button === 2 && e.ctrlKey &&
+        window.navigator.platform.toUpperCase().indexOf('MAC') >= 0) {
+        // Fix for https://github.com/mapbox/mapbox-gl-js/issues/3131:
+        // Firefox (detected by InstallTrigger) on Mac determines e.button = 2 when
+        // using Control + left click
+        return 0;
+    }
+    return e.button;
+};
+
+DOM.remove = function(node: HTMLElement) {
+    if (node.parentNode) {
+        node.parentNode.removeChild(node);
+    }
+};

package/src/util/evented.js

@@ -0,0 +1,174 @@
+// @flow
+
+import {extend} from './util';
+
+type Listener = (Object) => any;
+type Listeners = {[_: string]: Array<Listener> };
+
+function _addEventListener(type: string, listener: Listener, listenerList: Listeners) {
+    const listenerExists = listenerList[type] && listenerList[type].indexOf(listener) !== -1;
+    if (!listenerExists) {
+        listenerList[type] = listenerList[type] || [];
+        listenerList[type].push(listener);
+    }
+}
+
+function _removeEventListener(type: string, listener: Listener, listenerList: Listeners) {
+    if (listenerList && listenerList[type]) {
+        const index = listenerList[type].indexOf(listener);
+        if (index !== -1) {
+            listenerList[type].splice(index, 1);
+        }
+    }
+}
+
+export class Event {
+    +type: string;
+
+    constructor(type: string, data: Object = {}) {
+        extend(this, data);
+        this.type = type;
+    }
+}
+
+interface ErrorLike {
+    message: string;
+}
+
+export class ErrorEvent extends Event {
+    error: ErrorLike;
+
+    constructor(error: ErrorLike, data: Object = {}) {
+        super('error', extend({error}, data));
+    }
+}
+
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @mixin Evented
+ */
+export class Evented {
+    _listeners: Listeners;
+    _oneTimeListeners: Listeners;
+    _eventedParent: ?Evented;
+    _eventedParentData: ?(Object | () => Object);
+
+    /**
+     * Adds a listener to a specified event type.
+     *
+     * @param {string} type The event type to add a listen for.
+     * @param {Function} listener The function to be called when the event is fired.
+     *   The listener function is called with the data object passed to `fire`,
+     *   extended with `target` and `type` properties.
+     * @returns {Object} `this`
+     */
+    on(type: *, listener: Listener): this {
+        this._listeners = this._listeners || {};
+        _addEventListener(type, listener, this._listeners);
+
+        return this;
+    }
+
+    /**
+     * Removes a previously registered event listener.
+     *
+     * @param {string} type The event type to remove listeners for.
+     * @param {Function} listener The listener function to remove.
+     * @returns {Object} `this`
+     */
+    off(type: *, listener: Listener) {
+        _removeEventListener(type, listener, this._listeners);
+        _removeEventListener(type, listener, this._oneTimeListeners);
+
+        return this;
+    }
+
+    /**
+     * Adds a listener that will be called only once to a specified event type.
+     *
+     * The listener will be called first time the event fires after the listener is registered.
+     *
+     * @param {string} type The event type to listen for.
+     * @param {Function} listener The function to be called when the event is fired the first time.
+     * @returns {Object} `this`
+     */
+    once(type: *, listener: Listener) {
+        this._oneTimeListeners = this._oneTimeListeners || {};
+        _addEventListener(type, listener, this._oneTimeListeners);
+
+        return this;
+    }
+
+    fire(event: Event, properties?: Object) {
+        // Compatibility with (type: string, properties: Object) signature from previous versions.
+        // See https://github.com/mapbox/mapbox-gl-js/issues/6522,
+        //     https://github.com/mapbox/mapbox-gl-draw/issues/766
+        if (typeof event === 'string') {
+            event = new Event(event, properties || {});
+        }
+
+        const type = event.type;
+
+        if (this.listens(type)) {
+            (event: any).target = this;
+
+            // make sure adding or removing listeners inside other listeners won't cause an infinite loop
+            const listeners = this._listeners && this._listeners[type] ? this._listeners[type].slice() : [];
+            for (const listener of listeners) {
+                listener.call(this, event);
+            }
+
+            const oneTimeListeners = this._oneTimeListeners && this._oneTimeListeners[type] ? this._oneTimeListeners[type].slice() : [];
+            for (const listener of oneTimeListeners) {
+                _removeEventListener(type, listener, this._oneTimeListeners);
+                listener.call(this, event);
+            }
+
+            const parent = this._eventedParent;
+            if (parent) {
+                extend(
+                    event,
+                    typeof this._eventedParentData === 'function' ? this._eventedParentData() : this._eventedParentData
+                );
+                parent.fire(event);
+            }
+
+        // To ensure that no error events are dropped, print them to the
+        // console if they have no listeners.
+        } else if (event instanceof ErrorEvent) {
+            console.error(event.error);
+        }
+
+        return this;
+    }
+
+    /**
+     * Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.
+     *
+     * @param {string} type The event type
+     * @returns {boolean} `true` if there is at least one registered listener for specified event type, `false` otherwise
+     * @private
+     */
+    listens(type: string) {
+        return (
+            (this._listeners && this._listeners[type] && this._listeners[type].length > 0) ||
+            (this._oneTimeListeners && this._oneTimeListeners[type] && this._oneTimeListeners[type].length > 0) ||
+            (this._eventedParent && this._eventedParent.listens(type))
+        );
+    }
+
+    /**
+     * Bubble all events fired by this instance of Evented to this parent instance of Evented.
+     *
+     * @private
+     * @returns {Object} `this`
+     * @private
+     */
+    setEventedParent(parent: ?Evented, data?: Object | () => Object) {
+        this._eventedParent = parent;
+        this._eventedParentData = data;
+
+        return this;
+    }
+}