@wemap/providers 12.10.8 → 12.10.9

package/src/providers/position/absolute/AbsolutePositionProvider.ts

@@ -1,277 +0,0 @@
-import { Level, GeoRelativePosition, UserPosition } from '@wemap/geo';
-import { TimeUtils } from '@wemap/utils';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import MapMatchingHandler from '../../../mapmatching/MapMatchingHandler.js';
-import GnssWifiProvider from './GnssWifiProvider.js';
-import GeoRelativePositionProvider from '../relative/GeoRelativePositionProvider.js';
-import ProvidersOptions from '../../../ProvidersOptions.js';
-import VpsProvider from '../../vision/vps/VpsProvider.js';
-import PoleStarProvider from './PoleStarProvider.js';
-import { AbsolutePosition } from '../../../events/Types.js';
-
-class AbsolutePositionProvider extends Provider<AbsolutePosition> {
-
-    // Use the new absolute position if its accuracy is at least x times better than the last one.
-    static ACCURACY_RELOC_RATIO = 1; // or 1.5
-    static USE_MM_FOR_FEED = true;
-
-    _polestarProviderId?: number;
-    _vpsProviderId?: number;
-    _gnssWifiProviderId?: number;
-    _relativePositionProviderId?: number;
-    _mapMatchingHandlerId?: number;
-
-    useAllAbsolutePositions = false;
-    _waitUntilNextVpsPosition = false;
-    _lastPolestarFix: number | null = null;
-
-    getName = () => 'AbsolutePosition';
-
-
-    availability() {
-        return AvailabilityHelper.some([
-            GeoRelativePositionProvider.getAvailability(),
-            GnssWifiProvider.getAvailability(),
-            ...(ProvidersOptions.hasPoleStar ? [PoleStarProvider.getAvailability()] : []),
-            VpsProvider.getAvailability()
-        ]);
-    }
-
-
-    start() {
-        GeoRelativePositionProvider.getAvailability()
-            .then((error) => {
-                if (!error) {
-                    this._relativePositionProviderId = GeoRelativePositionProvider.addEventListener(
-                        e => this._onRelativePosition(e)
-                    );
-                } else {
-                    // do nothing
-                }
-            });
-
-        // GnssWifi
-        this._gnssWifiProviderId = GnssWifiProvider.addEventListener(
-            event => {
-                const clone = event.clone();
-                clone.bearing = null;
-                this._onAbsolutePosition(clone, false);
-            }
-        );
-
-        // Vps
-        this._vpsProviderId = VpsProvider.addEventListener(
-            event => this._onAbsolutePosition(event.absolutePosition),
-            this.notifyError,
-            false
-        );
-
-        // PoleStar
-        if (ProvidersOptions.hasPoleStar) {
-            this._polestarProviderId = PoleStarProvider.addEventListener(polestarPositionEvent => {
-
-                this._lastPolestarFix = TimeUtils.preciseTime();
-                const psPositionUsed = this._onAbsolutePosition(polestarPositionEvent);
-
-                /**
-                 * In the case of a degraded position from PoleStar and a good position from GnssWifi,
-                 *  we still need to retrieve the level from PoleStar.
-                 * To do so, we duplicate lastEvent and add the level from PoleStar to the current
-                 *  position, then we notify with the new position.
-                 */
-                if (!psPositionUsed && this.lastEvent?.level === null) {
-                    const lastPositionWithLevel = this.lastEvent.clone();
-                    lastPositionWithLevel.level = polestarPositionEvent.level;
-                    this.notify(lastPositionWithLevel);
-                }
-            });
-        }
-
-        this._mapMatchingHandlerId = MapMatchingHandler.addEventListener();
-    }
-
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this._relativePositionProviderId) {
-            GeoRelativePositionProvider.removeEventListener(this._relativePositionProviderId);
-            delete this._relativePositionProviderId;
-        }
-        if (this._gnssWifiProviderId) {
-            GnssWifiProvider.removeEventListener(this._gnssWifiProviderId);
-            delete this._gnssWifiProviderId;
-        }
-        if (this._vpsProviderId) {
-            VpsProvider.removeEventListener(this._vpsProviderId);
-            delete this._vpsProviderId;
-        }
-        if (this._polestarProviderId) {
-            PoleStarProvider.removeEventListener(this._polestarProviderId);
-            delete this._polestarProviderId;
-        }
-
-        MapMatchingHandler.removeEventListener(this._mapMatchingHandlerId);
-    }
-
-
-    private _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent: AbsolutePosition, canContainLevel = true) {
-
-        const newPosition = newPositionEvent;
-        const lastPosition = this.lastEvent || null;
-
-        // 1. Verifiy if it is the first known absolute position
-        if (!lastPosition) {
-            return true;
-        }
-
-        // 2. Is the new position accuracy is better enough than the last position accuracy
-        const isBetterEnough = newPosition.accuracy! * AbsolutePositionProvider.ACCURACY_RELOC_RATIO <= lastPosition.accuracy!;
-        if (isBetterEnough) {
-            return true;
-        }
-
-        // 3.a. Is the new position is far from the new one (regarding accuracy)
-        // This condition return true if the two positions accuracy circles does not intersect.
-        // This is important if the person put the current page in the background during a while. But,
-        //  could be dangerous if two providers do not provide close positions (ping-pong effect). This
-        //  is why the 3.b. condition has been added.
-        // TODO: add a routine to augment the current position accuracy when the page is in background
-        const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy! + newPosition.accuracy!;
-        if (isFarEnough) {
-            return true;
-        }
-
-        // 3.b. Added on 16/06/22
-        // The goal of this condition is to avoid continuous jumps between positions from two providers
-        // (i.e. GnssWifi and PoleStar)
-        const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy! <= lastPosition.accuracy!;
-
-        if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
-            return true;
-        }
-
-        // 4. Added on 23/06/22
-        // The goal of this condition is to take into account levels change when map-matching is not enabled / set
-        const isChangingLevel = canContainLevel && !Level.equals(newPosition.level, lastPosition.level);
-        if (isChangingLevel) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * @returns if input position is used by the system (true = used, false = discarded)
-     */
-    private _onAbsolutePosition(positionEvent: AbsolutePosition, canContainLevel = true) {
-
-        if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel)
-            && !this.useAllAbsolutePositions) {
-            return false;
-        }
-
-        const newPosition = positionEvent.clone();
-        const lastPosition = this.lastEvent ? this.lastEvent : null;
-
-        if (lastPosition) {
-            if (!canContainLevel) {
-                newPosition.level = lastPosition.level;
-            }
-
-            // If the new position does not have a bearing, retrieve the bearing from the last position
-            if (newPosition.bearing === null) {
-                newPosition.bearing = lastPosition.bearing;
-            }
-        }
-
-        // If the MM is disable or the network is not set yet, use the new position as it is.
-        // If the position bearing is null, do not use MM, it is too dangerous.
-        if (!MapMatchingHandler.canUseMapMatching()) {
-            this.notify(newPosition);
-            return true;
-        }
-
-        return MapMatchingHandler.notifyPositionFromAbsolute(newPosition);
-    }
-
-    /**
-     * @returns if input position is used by the system (true = used, false = discarded)
-     */
-    _onRelativePosition(relativeEvent: GeoRelativePosition) {
-
-        if (!this.lastEvent || this._waitUntilNextVpsPosition) {
-            return false;
-        }
-
-        const lastPosition = this.lastEvent;
-
-        const offsetPos = relativeEvent;
-
-        const dist = Math.sqrt(offsetPos.x ** 2 + offsetPos.y ** 2);
-        const bearing = Math.atan2(offsetPos.x, offsetPos.y);
-        const alt = lastPosition.alt !== null ? offsetPos.z : null;
-
-        const newPosition = lastPosition.destinationPoint(dist, bearing, alt);
-        newPosition.bearing = offsetPos.bearing;
-        newPosition.time = offsetPos.time;
-        newPosition.accuracy! += offsetPos.accuracy!;
-
-
-        if (!MapMatchingHandler.canUseMapMatching()) {
-            this.notify(newPosition);
-            return true;
-        }
-
-        return MapMatchingHandler.notifyPositionFromRelative(newPosition);
-    }
-
-
-    feed(data: AbsolutePosition) {
-
-        let newPositionEvent: AbsolutePosition;
-
-        if (data instanceof UserPosition) {
-
-            if (data.time === null) {
-                throw Error('the time of the position is not defined');
-            }
-            if (data.accuracy === null) {
-                throw Error('the accuracy of the position is not defined');
-            }
-
-            newPositionEvent = data;
-
-        } else {
-            throw new Error('data is nor an UserPosition or an AbsolutePositionEvent');
-        }
-
-        // If the MM is disable or the network is not set yet, use the new position as it is.
-        if (!AbsolutePositionProvider.USE_MM_FOR_FEED || !MapMatchingHandler.canUseMapMatching()) {
-            this.notify(newPositionEvent);
-            return;
-        }
-
-        MapMatchingHandler.notifyPositionFromFeed(newPositionEvent);
-    }
-
-    getBestPositionEvent(...absolutePositionEvents: (AbsolutePosition | null)[]) {
-        return absolutePositionEvents.reduce((best, value) => {
-            if (!best) {
-                return value;
-            }
-            if (!value || value.accuracy === null || value.time === null) {
-                return best;
-            }
-            const { accuracy: curAccuracy, time: curTime } = value;
-            const { accuracy: bestAccuracy, time: bestTime } = best;
-            // 1.3888 corresponds to 1.3888 m/s (5 km/h)
-            return curAccuracy < (bestAccuracy! + 1.3888 * (curTime - bestTime!)) ? value : best;
-        }, null as null | AbsolutePosition);
-    }
-}
-
-export default new AbsolutePositionProvider();

package/src/providers/position/absolute/GnssWifiProvider.ts

@@ -1,126 +0,0 @@
-import { UserPosition } from '@wemap/geo';
-import Logger from '@wemap/logger';
-import { deg2rad } from '@wemap/maths';
-import { TimeUtils } from '@wemap/utils';
-
-import GeolocationApiMissingError from '../../../errors/GeolocationApiMissingError.js';
-import Provider from '../../Provider.js';
-import GeolocationPermissionDeniedError from '../../../errors/GeolocationPermissionDeniedError.js';
-import GeolocationPositionUnavailableError from '../../../errors/GeolocationPositionUnavailableError.js';
-import Constants from '../../Constants.js';
-import { AbsolutePosition } from '../../../events/Types.js';
-
-
-/**
- * GnssWifiProvider is a provider based on navigator.geolocation.
- * This API does not allow us to know if the position returned is provided
- *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
- *  "GnssWifi".
- */
-class GnssWifiProvider extends Provider<AbsolutePosition> {
-
-    static DEFAULT_DISCARD_POSITIONS_ABOVE = 50;
-
-    discardPositionsAbove = GnssWifiProvider.DEFAULT_DISCARD_POSITIONS_ABOVE;
-
-    enableHighAccuracy = true;
-
-    geoLocationId?: number;
-
-    getName = () => 'GnssWifi';
-
-    get positionOptions() {
-        return {
-            enableHighAccuracy: this.enableHighAccuracy,
-            timeout: Infinity,
-            maximumAge: 0
-        };
-    }
-
-    availability() {
-        return typeof (navigator) === 'object' && navigator.geolocation
-            ? Promise.resolve()
-            : Promise.resolve(new GeolocationApiMissingError());
-    }
-
-    start() {
-        // Trigger last known position
-        navigator.geolocation.getCurrentPosition(
-            this.onNewPosition,
-            this.onPositionError,
-            this.positionOptions
-        );
-
-        // Note: added timeout for a workaround on Safari/iOS when user disabled geolocation:
-        //  watchPosition does not send the error callback without the "setTimeout"
-        setTimeout(() => {
-            this.geoLocationId = navigator.geolocation.watchPosition(
-                this.onNewPosition,
-                this.onPositionError,
-                this.positionOptions
-            );
-        }, 150);
-    }
-
-    stop() {
-        if (typeof this.geoLocationId !== 'undefined') {
-            navigator.geolocation.clearWatch(this.geoLocationId);
-        }
-    }
-
-    private onNewPosition = (geolocation: GeolocationPosition) => {
-
-        const { coords } = geolocation;
-        if (!coords) {
-            return;
-        }
-
-        let bearing;
-        if (coords.heading) {
-            bearing = deg2rad(coords.heading);
-        }
-
-        const timestamp = TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
-
-        const position = new UserPosition(
-            coords.latitude,
-            coords.longitude,
-            Constants.DEFAULT_ALTITUDE,
-            null,
-            timestamp,
-            coords.accuracy,
-            bearing);
-
-        if (
-            this.enableHighAccuracy &&
-            typeof this.discardPositionsAbove === 'number'
-            && coords.accuracy > this.discardPositionsAbove
-        ) {
-            return;
-        }
-
-        this.notify(position);
-
-    };
-
-    onPositionError = (error: GeolocationPositionError) => {
-
-        Logger.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
-
-        let customError;
-        switch (error.code) {
-            case 1:
-                customError = new GeolocationPermissionDeniedError(error.message);
-                break;
-            case 2:
-                customError = new GeolocationPositionUnavailableError(error.message);
-                break;
-            default:
-                customError = new Error(error.message);
-        }
-
-        this.notifyError(customError);
-    };
-}
-
-export default new GnssWifiProvider();

package/src/providers/position/absolute/GnssWifiProviders.spec.ts

@@ -1,90 +0,0 @@
-import chai from 'chai';
-import sinon from 'sinon';
-
-import GnssWifiProvider from './GnssWifiProvider.js';
-
-const { expect } = chai;
-
-describe('GnssWifiProvider', () => {
-    it('onNewPosition - should notify when accuracy is low', async () => {
-
-        const fakePositionEvent = {
-            coords: {
-                latitude: 43,
-                longitude: 3,
-                accuracy: 10,
-                altitude: 0,
-                altitudeAccuracy: 0,
-                heading: 0,
-                speed: 0
-            },
-            timestamp: Date.now()
-        };
-
-        const notifySpy = sinon.spy();
-
-        const callbackId = GnssWifiProvider.addEventListener(notifySpy);
-
-        (GnssWifiProvider as any).onNewPosition(fakePositionEvent);
-
-        expect(notifySpy.callCount).to.equal(1);
-
-        GnssWifiProvider.removeEventListener(callbackId);
-
-    });
-
-    it('onNewPosition - should not notify when accuracy is greater than options', async () => {
-
-        const fakePositionEvent = {
-            coords: {
-                latitude: 43,
-                longitude: 3,
-                accuracy: 100,
-                altitude: 0,
-                altitudeAccuracy: 0,
-                heading: 0,
-                speed: 0
-            },
-            timestamp: Date.now()
-        };
-
-        const notifySpy = sinon.spy();
-
-        const callbackId = GnssWifiProvider.addEventListener(notifySpy);
-        
-        (GnssWifiProvider as any).onNewPosition(fakePositionEvent);
-        
-        expect(notifySpy.callCount).to.equal(0);
-
-        GnssWifiProvider.removeEventListener(callbackId);
-    });
-
-    it('onNewPosition - should notify when accuracy is high and enableHighAccuracy false', async () => {
-
-        const fakePositionEvent = {
-            coords: {
-                latitude: 43,
-                longitude: 3,
-                accuracy: 100,
-                altitude: 0,
-                altitudeAccuracy: 0,
-                heading: 0,
-                speed: 0
-            },
-            timestamp: Date.now()
-        };
-
-        const notifySpy = sinon.spy();
-        GnssWifiProvider.enableHighAccuracy = false;
-
-        const callbackId = GnssWifiProvider.addEventListener(notifySpy);
-
-        (GnssWifiProvider as any).onNewPosition(fakePositionEvent);
-
-        expect(notifySpy.callCount).to.equal(1);
-
-        // Reset
-        GnssWifiProvider.enableHighAccuracy = true;
-        GnssWifiProvider.removeEventListener(callbackId);
-    });
-});

package/src/providers/position/absolute/IpProvider.ts

@@ -1,47 +0,0 @@
-import { UserPosition } from '@wemap/geo';
-import { TimeUtils } from '@wemap/utils';
-
-import Provider from '../../Provider.js';
-import IpResolveServerError from '../../../errors/IpResolveServerError.js';
-import { AbsolutePosition } from '../../../events/Types.js';
-
-/**
- * GnssWifiProvider is a provider based on navigator.geolocation.
- * This API does not allow us to know if the position returned is provided
- *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
- *  "GnssWifi".
- */
-class IpProvider extends Provider<AbsolutePosition> {
-
-    getName = () => 'Ip';
-
-    availability = () => Promise.resolve();
-
-    async start() {
-
-        const response = await fetch('https://ipinfo.io/geo?token=24a7ca2f3b489d');
-        if (!response) {
-            this.notifyError(new IpResolveServerError());
-            return;
-        }
-
-        const timestamp = TimeUtils.preciseTime() / 1e3;
-
-        const latLngStr = (await response.json()).loc.split(',');
-        const position = new UserPosition(
-            parseFloat(latLngStr[0]),
-            parseFloat(latLngStr[1]),
-            null,
-            null,
-            timestamp,
-            100000
-        );
-
-        this.notify(position);
-    }
-
-    stop() { /* do nothing */ }
-
-}
-
-export default new IpProvider();

package/src/providers/position/absolute/PoleStarProvider.ts

@@ -1,88 +0,0 @@
-import { deg2rad } from '@wemap/maths';
-import { TimeUtils } from '@wemap/utils';
-
-import Provider from '../../Provider.js';
-import MissingPoleStarError from '../../../errors/MissingPoleStarError.js';
-import MissingNativeInterfaceError from '../../../errors/MissingNativeInterfaceError.js';
-import Constants from '../../Constants.js';
-import { AbsolutePosition } from '../../../events/Types.js';
-import { NativePolestarPosition } from '../../NativeProviders.js';
-
-class PoleStarProvider extends Provider<AbsolutePosition> {
-
-    getName = () => 'PoleStar';
-
-    constructor() {
-        super();
-        this.addMethodsToNativeJsProvider();
-    }
-
-    availability() {
-        try {
-            this.nativeProvider.checkAvailability();
-            return Promise.resolve();
-        } catch (e) {
-            return Promise.resolve(e as Error);
-        }
-    }
-
-    setApiKey(apiKey: string) {
-        this.nativeProvider.setApiKey(apiKey);
-    }
-
-    start() {
-        this.nativeProvider.start();
-    }
-
-    stop() {
-        this.nativeProvider.stop();
-    }
-
-    get nativeProvider() {
-
-        if (!this.nativeInterface) {
-            throw new MissingNativeInterfaceError();
-        }
-
-        const nativeProvider = this.nativeInterface.getPoleStarProvider();
-        if (!nativeProvider) {
-            throw new MissingPoleStarError();
-        }
-
-        return nativeProvider;
-    }
-
-
-
-    addMethodsToNativeJsProvider() {
-
-        if (!this.nativeJsInterface) {
-            return;
-        }
-
-        this.nativeJsInterface.polestar = {
-            callbackError: (errorMessage: string) => this.notifyError(new Error(errorMessage)),
-            callbackPosition: (jsonString: string) => {
-
-                const json: NativePolestarPosition = JSON.parse(jsonString);
-
-                const timestamp = TimeUtils.unixTimestampToPreciseTime(json.time) / 1e3;
-
-                const position = new AbsolutePosition(
-                    json.lat,
-                    json.lng,
-                    Constants.DEFAULT_ALTITUDE,
-                    json.alt / 5,
-                    timestamp,
-                    json.accuracy,
-                    deg2rad(json.bearing)
-                );
-
-                this.notify(position);
-            }
-        };
-
-    }
-}
-
-export default new PoleStarProvider();