@scoova/mgl 1.0.0

package/src/util/evented.test.ts

@@ -0,0 +1,231 @@
+import {Event, Evented} from './evented';
+
+describe('Evented', () => {
+
+    test('calls listeners added with "on"', () => {
+        const evented = new Evented();
+        const listener = jest.fn();
+        evented.on('a', listener);
+        evented.fire(new Event('a'));
+        evented.fire(new Event('a'));
+        expect(listener).toHaveBeenCalledTimes(2);
+    });
+
+    test('calls listeners added with "once" once', () => {
+        const evented = new Evented();
+        const listener = jest.fn();
+        evented.once('a', listener);
+        evented.fire(new Event('a'));
+        evented.fire(new Event('a'));
+        expect(listener).toHaveBeenCalledTimes(1);
+        expect(evented.listens('a')).toBeFalsy();
+
+    });
+
+    test('returns a promise when no listener is provided to "once" method', async () => {
+        const evented = new Evented();
+        const promise = evented.once('a');
+        evented.fire(new Event('a'));
+        evented.fire(new Event('a'));
+        await promise;
+        expect(evented.listens('a')).toBeFalsy();
+
+    });
+
+    test('passes data to listeners', () => {
+        const evented = new Evented();
+        evented.on('a', (data) => {
+            expect(data.foo).toBe('bar');
+        });
+        evented.fire(new Event('a', {foo: 'bar'}));
+
+    });
+
+    test('passes "target" to listeners', () => {
+        const evented = new Evented();
+        evented.on('a', (data) => {
+            expect(data.target).toBe(evented);
+        });
+        evented.fire(new Event('a'));
+
+    });
+
+    test('passes "type" to listeners', () => {
+        const evented = new Evented();
+        evented.on('a', (data) => {
+            expect(data.type).toBe('a');
+        });
+        evented.fire(new Event('a'));
+
+    });
+
+    test('removes listeners with "off"', () => {
+        const evented = new Evented();
+        const listener = jest.fn();
+        evented.on('a', listener);
+        evented.off('a', listener);
+        evented.fire(new Event('a'));
+        expect(listener).not.toHaveBeenCalled();
+    });
+
+    test('removes one-time listeners with "off"', () => {
+        const evented = new Evented();
+        const listener = jest.fn();
+        evented.once('a', listener);
+        evented.off('a', listener);
+        evented.fire(new Event('a'));
+        expect(listener).not.toHaveBeenCalled();
+    });
+
+    test('once listener is removed prior to call', () => {
+        const evented = new Evented();
+        const listener = jest.fn();
+        evented.once('a', () => {
+            listener();
+            evented.fire(new Event('a'));
+        });
+        evented.fire(new Event('a'));
+        expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    test('reports if an event has listeners with "listens"', () => {
+        const evented = new Evented();
+        evented.on('a', () => {});
+        expect(evented.listens('a')).toBeTruthy();
+        expect(evented.listens('b')).toBeFalsy();
+
+    });
+
+    test('does not report true to "listens" if all listeners have been removed', () => {
+        const evented = new Evented();
+        const listener = () => {};
+        evented.on('a', listener);
+        evented.off('a', listener);
+        expect(evented.listens('a')).toBeFalsy();
+
+    });
+
+    test('does not immediately call listeners added within another listener', () => {
+        const evented = new Evented();
+        evented.on('a', () => {
+            evented.on('a', () => { throw new Error('fail'); });
+        });
+        evented.fire(new Event('a'));
+    });
+
+    test('has backward compatibility for fire(string, object) API', () => {
+        const evented = new Evented();
+        const listener = jest.fn(x => x);
+        evented.on('a', listener);
+        evented.fire('a' as any as Event, {foo: 'bar'});
+        expect(listener).toHaveBeenCalledTimes(1);
+        expect(listener.mock.calls[0][0].foo).toBe('bar');
+
+    });
+
+    test('on is idempotent', () => {
+        const evented = new Evented();
+        const order = [];
+        const listenerA = jest.fn(() => order.push('A'));
+        const listenerB = jest.fn(() => order.push('B'));
+        evented.on('a', listenerA);
+        evented.on('a', listenerB);
+        evented.on('a', listenerA);
+        evented.fire(new Event('a'));
+        expect(listenerA).toHaveBeenCalledTimes(1);
+        expect(order).toEqual(['A', 'B']);
+
+    });
+});
+
+describe('evented parents', () => {
+
+    test('adds parents with "setEventedParent"', () => {
+        const listener = jest.fn();
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSource.setEventedParent(eventedSink);
+        eventedSink.on('a', listener);
+        eventedSource.fire(new Event('a'));
+        eventedSource.fire(new Event('a'));
+        expect(listener).toHaveBeenCalledTimes(2);
+    });
+
+    test('passes original data to parent listeners', () => {
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSource.setEventedParent(eventedSink);
+        eventedSink.on('a', (data) => {
+            expect(data.foo).toBe('bar');
+        });
+        eventedSource.fire(new Event('a', {foo: 'bar'}));
+
+    });
+
+    test('attaches parent data to parent listeners', () => {
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSource.setEventedParent(eventedSink, {foz: 'baz'});
+        eventedSink.on('a', (data) => {
+            expect(data.foz).toBe('baz');
+        });
+        eventedSource.fire(new Event('a', {foo: 'bar'}));
+
+    });
+
+    test('attaches parent data from a function to parent listeners', () => {
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSource.setEventedParent(eventedSink, () => ({foz: 'baz'}));
+        eventedSink.on('a', (data) => {
+            expect(data.foz).toBe('baz');
+        });
+        eventedSource.fire(new Event('a', {foo: 'bar'}));
+
+    });
+
+    test('passes original "target" to parent listeners', () => {
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSource.setEventedParent(eventedSink);
+        eventedSource.setEventedParent(null);
+        eventedSink.on('a', (data) => {
+            expect(data.target).toBe(eventedSource);
+        });
+        eventedSource.fire(new Event('a'));
+
+    });
+
+    test('removes parents with "setEventedParent(null)"', () => {
+        const listener = jest.fn();
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSink.on('a', listener);
+        eventedSource.setEventedParent(eventedSink);
+        eventedSource.setEventedParent(null);
+        eventedSource.fire(new Event('a'));
+        expect(listener).not.toHaveBeenCalled();
+    });
+
+    test('reports if an event has parent listeners with "listens"', () => {
+        const eventedSource = new Evented();
+        const eventedSink = new Evented();
+        eventedSink.on('a', () => {});
+        eventedSource.setEventedParent(eventedSink);
+        expect(eventedSink.listens('a')).toBeTruthy();
+
+    });
+
+    test('eventedParent data function is evaluated on every fire', () => {
+        const eventedSource = new Evented();
+        const eventedParent = new Evented();
+        let i = 0;
+        eventedSource.setEventedParent(eventedParent, () => i++);
+        eventedSource.on('a', () => {});
+        eventedSource.fire(new Event('a'));
+        expect(i).toBe(1);
+        eventedSource.fire(new Event('a'));
+        expect(i).toBe(2);
+
+    });
+});

package/src/util/evented.ts

@@ -0,0 +1,178 @@
+import {extend} from './util';
+
+/**
+ * A listener method used as a callback to events
+ */
+export type Listener = (a: any) => 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);
+        }
+    }
+}
+
+/**
+ * The event class
+ */
+export class Event {
+    readonly type: string;
+
+    constructor(type: string, data: any = {}) {
+        extend(this, data);
+        this.type = type;
+    }
+}
+
+interface ErrorLike {
+    message: string;
+}
+
+/**
+ * An error event
+ */
+export class ErrorEvent extends Event {
+    error: ErrorLike;
+
+    constructor(error: ErrorLike, data: any = {}) {
+        super('error', extend({error}, data));
+    }
+}
+
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @group Event Related
+ */
+export class Evented {
+    _listeners: Listeners;
+    _oneTimeListeners: Listeners;
+    _eventedParent: Evented;
+    _eventedParentData: any | (() => any);
+
+    /**
+     * Adds a listener to a specified event type.
+     *
+     * @param type - The event type to add a listen for.
+     * @param 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.
+     */
+    on(type: string, listener: Listener): this {
+        this._listeners = this._listeners || {};
+        _addEventListener(type, listener, this._listeners);
+
+        return this;
+    }
+
+    /**
+     * Removes a previously registered event listener.
+     *
+     * @param type - The event type to remove listeners for.
+     * @param listener - The listener function to remove.
+     */
+    off(type: string, 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 type - The event type to listen for.
+     * @param listener - The function to be called when the event is fired the first time.
+     * @returns `this` or a promise if a listener is not provided
+     */
+    once(type: string, listener?: Listener): this | Promise<any> {
+        if (!listener) {
+            return new Promise((resolve) => this.once(type, resolve));
+        }
+        this._oneTimeListeners = this._oneTimeListeners || {};
+        _addEventListener(type, listener, this._oneTimeListeners);
+
+        return this;
+    }
+
+    fire(event: Event | string, properties?: any) {
+        // 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 as 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 type - The event type
+     * @returns `true` if there is at least one registered listener for specified event type, `false` otherwise
+     */
+    listens(type: string): boolean {
+        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.
+     */
+    setEventedParent(parent?: Evented | null, data?: any | (() => any)) {
+        this._eventedParent = parent;
+        this._eventedParentData = data;
+
+        return this;
+    }
+}

package/src/util/find_pole_of_inaccessibility.test.ts

@@ -0,0 +1,21 @@
+import Point from '@mapbox/point-geometry';
+import {findPoleOfInaccessibility} from './find_pole_of_inaccessibility';
+
+test('polygon_poi', () => {
+
+    const closedRing = [
+        new Point(0, 0),
+        new Point(10, 10),
+        new Point(10, 0),
+        new Point(0, 0)
+    ];
+    const closedRingHole = [
+        new Point(2, 1),
+        new Point(6, 6),
+        new Point(6, 1),
+        new Point(2, 1)
+    ];
+    expect(findPoleOfInaccessibility([closedRing], 0.1)).toEqual(new Point(7.0703125, 2.9296875));
+    expect(findPoleOfInaccessibility([closedRing, closedRingHole], 0.1)).toEqual(new Point(7.96875, 2.03125));
+
+});

package/src/util/find_pole_of_inaccessibility.ts

@@ -0,0 +1,130 @@
+import Queue from 'tinyqueue';
+
+import Point from '@mapbox/point-geometry';
+import {distToSegmentSquared} from './intersection_tests';
+
+/**
+ * Finds an approximation of a polygon's Pole Of Inaccessibility https://en.wikipedia.org/wiki/Pole_of_inaccessibility
+ * This is a copy of https://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 Inaccessibility.
+ */
+export function findPoleOfInaccessibility(
+    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/geolocation_support.test.ts

@@ -0,0 +1,43 @@
+import {checkGeolocationSupport} from './geolocation_support';
+
+describe('checkGeolocationSupport', () => {
+    beforeEach(() => {
+        jest.resetModules();
+    });
+
+    test('it should return false if geolocation is not defined', async () => {
+        await expect(checkGeolocationSupport()).resolves.toBeFalsy();
+    });
+
+    test('it should return the cached value on second call', async () => {
+        const returnValue = await checkGeolocationSupport();
+        expect(returnValue).toBeFalsy();
+        (window.navigator as any).geolocation = {};
+        const rv = await checkGeolocationSupport();
+        expect(rv).toBe(returnValue);
+    });
+
+    test('it should return the true if geolocation is defined', async () => {
+        (window.navigator as any).geolocation = {};
+        const returnValue = await checkGeolocationSupport(true);
+        expect(returnValue).toBeTruthy();
+    });
+
+    test('it should check permissions if possible', async () => {
+        (window.navigator as any).geolocation = {};
+        (window.navigator as any).permissions = {
+            query: () => Promise.resolve({state: 'granted'})
+        };
+        const returnValue = await checkGeolocationSupport(true);
+        expect(returnValue).toBeTruthy();
+    });
+
+    test('it should check permissions and geolocation for iOS 16 promise rejection', async () => {
+        (window.navigator as any).geolocation = undefined;
+        (window.navigator as any).permissions = {
+            query: () => Promise.reject(new Error('perissions error'))
+        };
+        const returnValue = await checkGeolocationSupport(true);
+        expect(returnValue).toBeFalsy();
+    });
+});

package/src/util/geolocation_support.ts

@@ -0,0 +1,23 @@
+let supportsGeolocation;
+
+export async function checkGeolocationSupport(forceRecalculation = false): Promise<boolean> {
+    if (supportsGeolocation !== undefined && !forceRecalculation) {
+        return supportsGeolocation;
+    }
+    if (window.navigator.permissions === undefined) {
+        supportsGeolocation = !!window.navigator.geolocation;
+        return supportsGeolocation;
+    }
+    // navigator.permissions has incomplete browser support
+    // https://caniuse.com/#feat=permissions-api
+    // Test for the case where a browser disables Geolocation because of an
+    // insecure origin
+    try {
+        const permissions = await window.navigator.permissions.query({name: 'geolocation'});
+        supportsGeolocation = permissions.state !== 'denied'; // eslint-disable-line require-atomic-updates
+    } catch {
+        // Fix for iOS16 which rejects query but still supports geolocation
+        supportsGeolocation = !!window.navigator.geolocation; // eslint-disable-line require-atomic-updates
+    }
+    return supportsGeolocation;
+}

package/src/util/global_worker_pool.ts

@@ -0,0 +1,65 @@
+import {WorkerPool, PRELOAD_POOL_ID} from './worker_pool';
+
+let globalWorkerPool;
+
+/**
+ * Creates (if necessary) and returns the single, global WorkerPool instance
+ * to be shared across each Map
+ */
+export function getGlobalWorkerPool() {
+    if (!globalWorkerPool) {
+        globalWorkerPool = new WorkerPool();
+    }
+    return globalWorkerPool;
+}
+
+/**
+ * Initializes resources like WebWorkers that can be shared across maps to lower load
+ * times in some situations. `setWorkerUrl()` and `setWorkerCount()`, if being
+ * used, must be set before `prewarm()` is called to have an effect.
+ *
+ * By default, the lifecycle of these resources is managed automatically, and they are
+ * lazily initialized when a Map is first created. By invoking `prewarm()`, these
+ * resources will be created ahead of time, and will not be cleared when the last Map
+ * is removed from the page. This allows them to be re-used by new Map instances that
+ * are created later. They can be manually cleared by calling
+ * `clearPrewarmedResources()`. This is only necessary if your web page remains
+ * active but stops using maps altogether.
+ *
+ * This is primarily useful when using GL-JS maps in a single page app, wherein a user
+ * would navigate between various views that can cause Map instances to constantly be
+ * created and destroyed.
+ *
+ * @example
+ * ```ts
+ * prewarm()
+ * ```
+ */
+export function prewarm() {
+    const workerPool = getGlobalWorkerPool();
+    workerPool.acquire(PRELOAD_POOL_ID);
+}
+
+/**
+ * Clears up resources that have previously been created by `prewarm()`.
+ * Note that this is typically not necessary. You should only call this function
+ * if you expect the user of your app to not return to a Map view at any point
+ * in your application.
+ *
+ * @example
+ * ```ts
+ * clearPrewarmedResources()
+ * ```
+ */
+export function clearPrewarmedResources() {
+    const pool = globalWorkerPool;
+    if (pool) {
+        // Remove the pool only if all maps that referenced the preloaded global worker pool have been removed.
+        if (pool.isPreloaded() && pool.numActive() === 1) {
+            pool.release(PRELOAD_POOL_ID);
+            globalWorkerPool = null;
+        } else {
+            console.warn('Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()');
+        }
+    }
+}