@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/util/classify_rings.js

@@ -1,52 +0,0 @@
-// @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

@@ -1,28 +0,0 @@
-// @flow
-
-import {RGBAImage} from './image';
-
-import type {StylePropertyExpression} from '../style-spec/expression/index';
-
-/**
- * Given an expression that should evaluate to a color ramp, return
- * a 256x1 px RGBA image representing that ramp expression.
- *
- * @private
- */
-export default function renderColorRamp(expression: StylePropertyExpression, colorRampEvaluationParameter: string): RGBAImage {
-    const colorRampData = new Uint8Array(256 * 4);
-    const evaluationGlobals = {};
-    for (let i = 0, j = 0; i < 256; i++, j += 4) {
-        evaluationGlobals[colorRampEvaluationParameter] = i / 255;
-        const pxColor = expression.evaluate((evaluationGlobals: any));
-        // the colors are being unpremultiplied because Color uses
-        // premultiplied values, and the Texture class expects unpremultiplied ones
-        colorRampData[j + 0] = Math.floor(pxColor.r * 255 / pxColor.a);
-        colorRampData[j + 1] = Math.floor(pxColor.g * 255 / pxColor.a);
-        colorRampData[j + 2] = Math.floor(pxColor.b * 255 / pxColor.a);
-        colorRampData[j + 3] = Math.floor(pxColor.a * 255);
-    }
-
-    return new RGBAImage({width: 256, height: 1}, colorRampData);
-}

package/src/util/config.js

@@ -1,30 +0,0 @@
-// @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

@@ -1,12 +0,0 @@
-// @flow
-import {extend} from './util';
-
-/**
- * This is a private namespace for utility functions that will get automatically stripped
- * out in production builds.
- */
-export const Debug = {
-    extend(dest: Object, ...sources: Array<?Object>): Object {
-        return extend(dest, ...sources);
-    }
-};

package/src/util/dictionary_coder.js

@@ -1,30 +0,0 @@
-// @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

@@ -1,70 +0,0 @@
-// @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

@@ -1,144 +0,0 @@
-// @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.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();
-    const t = window.TouchEvent && (e instanceof window.TouchEvent) ? e.touches[0] : e;
-    return new Point(
-        t.clientX - rect.left - el.clientLeft,
-        t.clientY - rect.top - el.clientTop
-    );
-};
-
-DOM.touchPos = function (el: HTMLElement, e: TouchEvent) {
-    const rect = el.getBoundingClientRect(),
-        points = [];
-    const touches = (e.type === 'touchend') ? e.changedTouches : e.touches;
-    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

@@ -1,174 +0,0 @@
-// @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;
-    }
-}

package/src/util/find_pole_of_inaccessibility.js

@@ -1,129 +0,0 @@
-// @flow
-
-import Queue from 'tinyqueue';
-
-import Point from '@mapbox/point-geometry';
-import {distToSegmentSquared} from './intersection_tests';
-
-/**
- * Finds an approximation of a polygon's Pole Of Inaccessibiliy https://en.wikipedia.org/wiki/Pole_of_inaccessibility
- * This is a copy of http://github.com/mapbox/polylabel adapted to use Points
- *
- * @param polygonRings first item in array is the outer ring followed optionally by the list of holes, should be an element of the result of util/classify_rings
- * @param precision Specified in input coordinate units. If 0 returns after first run, if > 0 repeatedly narrows the search space until the radius of the area searched for the best pole is less than precision
- * @param debug Print some statistics to the console during execution
- * @returns Pole of Inaccessibiliy.
- * @private
- */
-export default function (polygonRings: Array<Array<Point>>, precision?: number = 1, debug?: boolean = false): Point {
-    // find the bounding box of the outer ring
-    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-    const outerRing = polygonRings[0];
-    for (let i = 0; i < outerRing.length; i++) {
-        const p = outerRing[i];
-        if (!i || p.x < minX) minX = p.x;
-        if (!i || p.y < minY) minY = p.y;
-        if (!i || p.x > maxX) maxX = p.x;
-        if (!i || p.y > maxY) maxY = p.y;
-    }
-
-    const width = maxX - minX;
-    const height = maxY - minY;
-    const cellSize = Math.min(width, height);
-    let h = cellSize / 2;
-
-    // a priority queue of cells in order of their "potential" (max distance to polygon)
-    const cellQueue = new Queue([], compareMax);
-
-    if (cellSize === 0) return new Point(minX, minY);
-
-    // cover polygon with initial cells
-    for (let x = minX; x < maxX; x += cellSize) {
-        for (let y = minY; y < maxY; y += cellSize) {
-            cellQueue.push(new Cell(x + h, y + h, h, polygonRings));
-        }
-    }
-
-    // take centroid as the first best guess
-    let bestCell = getCentroidCell(polygonRings);
-    let numProbes = cellQueue.length;
-
-    while (cellQueue.length) {
-        // pick the most promising cell from the queue
-        const cell = cellQueue.pop();
-
-        // update the best cell if we found a better one
-        if (cell.d > bestCell.d || !bestCell.d) {
-            bestCell = cell;
-            if (debug) console.log('found best %d after %d probes', Math.round(1e4 * cell.d) / 1e4, numProbes);
-        }
-
-        // do not drill down further if there's no chance of a better solution
-        if (cell.max - bestCell.d <= precision) continue;
-
-        // split the cell into four cells
-        h = cell.h / 2;
-        cellQueue.push(new Cell(cell.p.x - h, cell.p.y - h, h, polygonRings));
-        cellQueue.push(new Cell(cell.p.x + h, cell.p.y - h, h, polygonRings));
-        cellQueue.push(new Cell(cell.p.x - h, cell.p.y + h, h, polygonRings));
-        cellQueue.push(new Cell(cell.p.x + h, cell.p.y + h, h, polygonRings));
-        numProbes += 4;
-    }
-
-    if (debug) {
-        console.log(`num probes: ${numProbes}`);
-        console.log(`best distance: ${bestCell.d}`);
-    }
-
-    return bestCell.p;
-}
-
-function compareMax(a, b) {
-    return b.max - a.max;
-}
-
-function Cell(x, y, h, polygon) {
-    this.p = new Point(x, y);
-    this.h = h; // half the cell size
-    this.d = pointToPolygonDist(this.p, polygon); // distance from cell center to polygon
-    this.max = this.d + this.h * Math.SQRT2; // max distance to polygon within a cell
-}
-
-// signed distance from point to polygon outline (negative if point is outside)
-function pointToPolygonDist(p, polygon) {
-    let inside = false;
-    let minDistSq = Infinity;
-
-    for (let k = 0; k < polygon.length; k++) {
-        const ring = polygon[k];
-
-        for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
-            const a = ring[i];
-            const b = ring[j];
-
-            if ((a.y > p.y !== b.y > p.y) &&
-                (p.x < (b.x - a.x) * (p.y - a.y) / (b.y - a.y) + a.x)) inside = !inside;
-
-            minDistSq = Math.min(minDistSq, distToSegmentSquared(p, a, b));
-        }
-    }
-
-    return (inside ? 1 : -1) * Math.sqrt(minDistSq);
-}
-
-// get polygon centroid
-function getCentroidCell(polygon) {
-    let area = 0;
-    let x = 0;
-    let y = 0;
-    const points = polygon[0];
-    for (let i = 0, len = points.length, j = len - 1; i < len; j = i++) {
-        const a = points[i];
-        const b = points[j];
-        const f = a.x * b.y - b.x * a.y;
-        x += (a.x + b.x) * f;
-        y += (a.y + b.y) * f;
-        area += f * 3;
-    }
-    return new Cell(x / area, y / area, 0, polygon);
-}

package/src/util/global_worker_pool.js

@@ -1,17 +0,0 @@
-// @flow
-
-import WorkerPool from './worker_pool';
-
-let globalWorkerPool;
-
-/**
- * Creates (if necessary) and returns the single, global WorkerPool instance
- * to be shared across each Map
- * @private
- */
-export default function getGlobalWorkerPool () {
-    if (!globalWorkerPool) {
-        globalWorkerPool = new WorkerPool();
-    }
-    return globalWorkerPool;
-}