@wemap/providers 3.2.18 → 4.0.0

package/debug/src/AbsoluteAttitudeComponent.jsx

@@ -80,14 +80,14 @@ class AbsoluteAttitudeComponent extends React.Component {
         const heading = Number(this.inputHeading);
         if (!isNaN(heading)) {
             AbsoluteAttitude.feed(
-                new AbsoluteHeading(deg2rad(heading), TimeUtils.preciseTime / 1e3, 0)
+                new AbsoluteHeading(deg2rad(heading), TimeUtils.preciseTime() / 1e3, 0)
             );
         }
     }
 
     handlePosSubmit() {
         AbsolutePosition.feed(
-            new UserPosition(43.61, 3.8, null, null, TimeUtils.preciseTime / 1e3, 1000)
+            new UserPosition(43.61, 3.8, null, null, TimeUtils.preciseTime() / 1e3, 1000)
         );
     }
 
@@ -101,11 +101,12 @@ class AbsoluteAttitudeComponent extends React.Component {
             const gamma = this.state.deviceorientation.gamma;
             const webkitCompassHeading = this.state.deviceorientation.webkitCompassHeading;
 
-            if (alpha && beta && gamma && webkitCompassHeading) {
-                rawRender = <p>alpha: {alpha.toFixed(2)}, <br />
+            if (typeof alpha === 'number' && typeof beta === 'number'
+                && typeof gamma === 'number' && typeof webkitCompassHeading === 'number') {
+                rawRender = <pre>alpha: {alpha.toFixed(2)}, <br />
                     beta: {beta.toFixed(2)}, <br />
                     gamma: {gamma.toFixed(2)}, <br />
-                    webkitCompassHeading: {webkitCompassHeading.toFixed(2)}</p>;
+                    webkitCompassHeading: {webkitCompassHeading.toFixed(2)}</pre>;
             }
 
         } else if (this.state.deviceorientationabsolute) {
@@ -114,9 +115,9 @@ class AbsoluteAttitudeComponent extends React.Component {
             const gamma = this.state.deviceorientationabsolute.gamma;
 
             if (typeof alpha === 'number' && typeof beta === 'number' && typeof gamma === 'number') {
-                rawRender = <p>alpha: {alpha.toFixed(2)}, <br />
+                rawRender = <pre>alpha: {alpha.toFixed(2)}, <br />
                     beta: {beta.toFixed(2)}, <br />
-                    gamma: {gamma.toFixed(2)}</p>;
+                    gamma: {gamma.toFixed(2)}</pre>;
             }
         }
 

package/debug/src/NavigationConfig.js

@@ -1,9 +1,8 @@
 import React from 'react'; // eslint-disable-line no-unused-vars
 
 import {
-    AbsoluteHeading, UserPosition, Level
+    AbsoluteHeading, UserPosition, Level, Itinerary
 } from '@wemap/geo';
-import { Itinerary } from '@wemap/graph';
 import { deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
@@ -12,10 +11,10 @@ const datasets = {};
 // Wemap Office
 const wemapOffice = {
     get initialPosition() {
-        return new UserPosition(43.6091955, 3.8841255, 1.5, null, TimeUtils.preciseTime / 1e3, 0);
+        return new UserPosition(43.6091955, 3.8841255, 1.5, null, TimeUtils.preciseTime() / 1e3, 0);
     },
     get initialHeading() {
-        return new AbsoluteHeading(deg2rad(191.9), TimeUtils.preciseTime / 1e3, 0);
+        return new AbsoluteHeading(deg2rad(191.9), TimeUtils.preciseTime() / 1e3, 0);
     }
 };
 wemapOffice.itinerary = Itinerary.fromOrderedPointsArray(
@@ -33,10 +32,10 @@ wemapOffice.itinerary = Itinerary.fromOrderedPointsArray(
 // Wemap Office Multi-level
 const wemapOfficeMulti = {
     get initialPosition() {
-        return new UserPosition(43.6091965, 3.8841285, 1.5, new Level(2), TimeUtils.preciseTime / 1e3, 0);
+        return new UserPosition(43.6091965, 3.8841285, 1.5, new Level(2), TimeUtils.preciseTime() / 1e3, 0);
     },
     get initialHeading() {
-        return new AbsoluteHeading(deg2rad(191.9), TimeUtils.preciseTime / 1e3, 0);
+        return new AbsoluteHeading(deg2rad(191.9), TimeUtils.preciseTime() / 1e3, 0);
     }
 };
 wemapOfficeMulti.itinerary = Itinerary.fromOrderedPointsArray(
@@ -60,10 +59,10 @@ wemapOfficeMulti.itinerary = Itinerary.fromOrderedPointsArray(
 // Gare de Lyon RER A
 const gareDeLyonRerA = {
     get initialPosition() {
-        return new UserPosition(48.8442365, 2.3728267, 1.5, new Level(-2), TimeUtils.preciseTime / 1e3, 0);
+        return new UserPosition(48.8442365, 2.3728267, 1.5, new Level(-2), TimeUtils.preciseTime() / 1e3, 0);
     },
     get initialHeading() {
-        return new AbsoluteHeading(deg2rad(41.6), TimeUtils.preciseTime / 1e3, 0);
+        return new AbsoluteHeading(deg2rad(41.6), TimeUtils.preciseTime() / 1e3, 0);
     }
 };
 gareDeLyonRerA.itinerary = Itinerary.fromOrderedPointsArray(

package/debug/src/RelativeAttitudeComponent.jsx

@@ -59,10 +59,10 @@ class RelativeAttitudeComponent extends React.Component {
             const beta = this.state.deviceorientation.beta;
             const gamma = this.state.deviceorientation.gamma;
 
-            if (alpha && beta && gamma) {
-                rawRender = <p>alpha: {alpha.toFixed(2)}, <br />
+            if (typeof alpha === 'number' && typeof beta === 'number' && typeof gamma === 'number') {
+                rawRender = <pre>alpha: {alpha.toFixed(2)}, <br />
                     beta: {beta.toFixed(2)}, <br />
-                    gamma: {gamma.toFixed(2)}</p>;
+                    gamma: {gamma.toFixed(2)}</pre>;
             }
         }
 

package/debug/src/Utils.js

@@ -40,14 +40,14 @@ class Utils {
 
         return (
             <div>
-                <p>
+                <pre>
                     Quat: [{w}, {x}, {y}, {z}]<br />
                     Eulers: [{yaw}, {pitch}, {roll}]<br />
                     Heading: {heading}<br />
                     Time: {attitude.time.toFixed(2)}<br />
                     Accuracy: {accuracyString}
-                </p>
-                {(event instanceof ProviderEvent) ? Utils.renderTimeAndFromStack(event) : ''}
+                </pre>
+                {(event instanceof ProviderEvent) ? Utils.renderFromStack(event) : ''}
             </div>
         );
     }
@@ -62,14 +62,17 @@ class Utils {
             return Utils.renderError(event);
         }
 
-        const { data } = event;
-
+        const { values } = event.data;
         return (
             <div>
-                <p style={{ margin: 0 }}>
-                    [{data[0].toFixed(2)}, {data[1].toFixed(2)}, {data[2].toFixed(2)}]
-                </p>
-                {Utils.renderTimeAndFromStack(event)}
+                <pre>
+                    [
+                    {values[0].toFixed(2).padStart(6, ' ')},
+                    {values[1].toFixed(2).padStart(6, ' ')},
+                    {values[2].toFixed(2).padStart(6, ' ')}
+                    ]
+                </pre>
+                {Utils.renderFromStack(event)}
             </div>
         );
     }
@@ -85,7 +88,7 @@ class Utils {
         const position = event instanceof ProviderEvent ? event.data : event;
         return (
             <div>
-                <p>
+                <pre>
                     Latitude: {position.lat.toFixed(7)}<br />
                     Longitude: {position.lng.toFixed(7)}<br />
                     Altitude: {position.alt ? position.alt.toFixed(2) : NOT_AVAILABLE_STR}<br />
@@ -93,8 +96,8 @@ class Utils {
                     Bearing: {position.bearing !== null ? rad2deg(position.bearing).toFixed(2) : NOT_AVAILABLE_STR}<br />
                     Accuracy: {position.accuracy.toFixed(2)}<br />
                     Time: {position.time.toFixed(2)}
-                </p>
-                {(event instanceof ProviderEvent) ? Utils.renderTimeAndFromStack(event) : ''}
+                </pre>
+                {(event instanceof ProviderEvent) ? Utils.renderFromStack(event) : ''}
             </div>
         );
 
@@ -109,11 +112,11 @@ class Utils {
             return Utils.renderError(position);
         }
         return (
-            <p>
+            <pre>
                 x: {position[0].toFixed(2)}<br />
                 y: {position[1].toFixed(2)}<br />
                 z: {position[2].toFixed(2)}
-            </p>
+            </pre>
         );
 
     }
@@ -137,13 +140,13 @@ class Utils {
 
 
         return (
-            <p>
+            <pre>
                 projection: {info.projection.nearestElement.constructor.name}<br />
                 distanceOfProjection: {info.projection.distanceFromNearestElement.toFixed(1)}m<br />
                 traveledDistance: {info.traveledDistance.toFixed(1)}m ({(info.traveledPercentage * 100).toFixed(1)}%)<br />
                 remainingDistance: {info.remainingDistance.toFixed(1)}m ({(info.remainingPercentage * 100).toFixed(1)}%)<br />
                 nextStep: {nextStepStr}
-            </p>
+            </pre>
         );
 
     }
@@ -157,10 +160,10 @@ class Utils {
         }
         return (
             <div>
-                <p style={{ margin: 0 }}>
+                <pre>
                     Inclination: {rad2deg(event.data).toFixed(2)} deg
-                </p>
-                {Utils.renderTimeAndFromStack(event)}
+                </pre>
+                {Utils.renderFromStack(event)}
             </div>
         );
     }
@@ -177,11 +180,11 @@ class Utils {
         }
         return (
             <div>
-                <p style={{ margin: 0 }}>
+                <pre style={{ margin: 0 }}>
                     Number: {event.data.number}<br />
                     Size: {event.data.size.toFixed(2)}m
-                </p>
-                {Utils.renderTimeAndFromStack(event)}
+                </pre>
+                {Utils.renderFromStack(event)}
             </div>
         );
     }
@@ -190,26 +193,14 @@ class Utils {
         return (<div style={{ maxWidth: '180px' }}><strong>[{error.constructor.name}]</strong><br />{error.message}</div>);
     }
 
-    static renderFromStack(providersStack) {
-        return <span style={{}}>Provider: {providersStack.join(', ')}</span>;
-    }
-
-    static renderTime(timestamp) {
-        return `Time: ${timestamp.toFixed(2)} s`;
-    }
-
-    static renderTimeAndFromStack(event) {
-        return (
-            <p style={{
-                margin: 0,
-                fontSize: 'small'
-            }}>
-                {this.renderTime(event.timestamp)}<br />
-                {this.renderFromStack(event.providersStack)}
-            </p>
-        );
+    static renderFromStack({providersStack}) {
+        return <pre style={{
+            margin: 0,
+            fontSize: 'small'
+        }}>
+            Providers Stack: {providersStack.join(', ')}
+        </pre>;
     }
-
 }
 
 export default Utils;

package/index.js

@@ -1,9 +1,7 @@
-import EventType from './src/events/EventType.js';
-import PositionSmoother from './src/smoothers/PositionSmoother.js';
-import * as Providers from './src/Providers.js';
-import ProvidersInterface from './src/ProvidersInterface.js';
-import ProvidersOptions from './src/ProvidersOptions.js';
+export { default as EventType } from './src/events/EventType.js';
+export * as Providers from './src/Providers.js';
+export { default as ProvidersInterface } from './src/ProvidersInterface.js';
+export { default as ProvidersOptions } from './src/ProvidersOptions.js';
 
-export {
-    EventType, PositionSmoother, Providers, ProvidersInterface, ProvidersOptions
-};
+export { default as PositionSmoother } from './src/smoothers/PositionSmoother.js';
+export { default as AttitudeSmoother } from './src/smoothers/AttitudeSmoother.js';

package/package.json

@@ -8,19 +8,18 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^3.2.17",
+    "@wemap/geo": "^4.0.0",
     "@wemap/geomagnetism": "^0.1.1",
-    "@wemap/graph": "^3.2.17",
-    "@wemap/logger": "^3.2.17",
-    "@wemap/map": "^3.2.17",
-    "@wemap/maths": "^3.2.17",
-    "@wemap/utils": "^3.2.16",
+    "@wemap/logger": "^4.0.0",
+    "@wemap/map": "^4.0.0",
+    "@wemap/maths": "^4.0.0",
+    "@wemap/utils": "^4.0.0",
     "lodash.isempty": "^4.4.0",
     "lodash.noop": "^3.0.1"
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
-    "@wemap/osm": "^3.2.17",
+    "@wemap/osm": "^4.0.0",
     "mapbox-gl": "^1.11.1"
   },
   "homepage": "https://github.com/wemap/wemap-modules-js#readme",
@@ -42,6 +41,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "3.2.18",
-  "gitHead": "5b5342754059b05298d7961f78c13b8198685a85"
+  "version": "4.0.0",
+  "gitHead": "8b72858590fc2ff33fbea4f090de8cd353a7445f"
 }

package/src/Providers.js

@@ -19,9 +19,11 @@ const RelativeAttitude = RelativeAttitudeProvider.instance;
 
 import AbsoluteAttitudeFromBrowserProvider from './providers/attitude/absolute/AbsoluteAttitudeFromBrowserProvider.js';
 import AbsoluteAttitudeFromRelAttProvider from './providers/attitude/absolute/AbsoluteAttitudeFromRelAttProvider.js';
+import AbsoluteAttitudeFusedProvider from './providers/attitude/absolute/AbsoluteAttitudeFusedProvider.js';
 import AbsoluteAttitudeProvider from './providers/attitude/absolute/AbsoluteAttitudeProvider.js';
 const AbsoluteAttitudeFromBrowser = AbsoluteAttitudeFromBrowserProvider.instance;
 const AbsoluteAttitudeFromRelAtt = AbsoluteAttitudeFromRelAttProvider.instance;
+const AbsoluteAttitudeFused = AbsoluteAttitudeFusedProvider.instance;
 const AbsoluteAttitude = AbsoluteAttitudeProvider.instance;
 
 import InclinationFromAccProvider from './providers/inclination/InclinationFromAccProvider.js';
@@ -63,6 +65,7 @@ export {
     AbsoluteAttitude,
     AbsoluteAttitudeFromBrowser,
     AbsoluteAttitudeFromRelAtt,
+    AbsoluteAttitudeFused,
     AbsolutePosition,
     AbsolutePositionFromRel,
     Accelerometer,

package/src/ProvidersInterface.js

@@ -1,15 +1,15 @@
 
 import {
-    Attitude, AbsoluteHeading, UserPosition
+    Attitude, AbsoluteHeading, UserPosition, Network
 } from '@wemap/geo';
-import { Network } from '@wemap/graph';
 
 import EventType from './events/EventType.js';
 import MetaProvider from './providers/MetaProvider.js';
 import {
-    AbsoluteAttitude, AbsolutePosition, Barcode, CameraNative, CameraProjectionMatrix, Inclination
+    AbsoluteAttitude, AbsolutePosition, Barcode, CameraNative, CameraProjectionMatrix, Inclination, RelativeAttitude
 } from './Providers.js';
 import ProvidersLoggerOld from './events/ProvidersLoggerOld.js';
+import MapMatchingHandler from './mapmatching/MapMatchingHandler.js';
 
 class ProvidersInterface {
 
@@ -48,6 +48,10 @@ class ProvidersInterface {
      */
     static feed(eventType, data) {
         this._checkEventTypeDataConsistency(eventType, data);
+        if (eventType === EventType.Network) {
+            MapMatchingHandler.network = data;
+            return;
+        }
         this._getMetaProviderFromEventType(eventType).feed(data, eventType);
     }
 
@@ -71,9 +75,11 @@ class ProvidersInterface {
             return AbsoluteAttitude;
 
         case EventType.AbsolutePosition:
-        case EventType.Network:
             return AbsolutePosition;
 
+        case EventType.RelativeAttitude:
+            return RelativeAttitude;
+
         case EventType.Inclination:
             return Inclination;
 
@@ -129,27 +135,27 @@ class ProvidersInterface {
     }
 
     static get mapMatchingMaxDistance() {
-        return AbsolutePosition.mapMatchingMaxDistance;
+        return MapMatchingHandler.maxDistance;
     }
 
     static set mapMatchingMaxDistance(maxDistance) {
-        AbsolutePosition.mapMatchingMaxDistance = maxDistance;
+        MapMatchingHandler.maxDistance = maxDistance;
     }
 
     static get mapMatchingMinDistance() {
-        return AbsolutePosition.mapMatchingMinDistance;
+        return MapMatchingHandler.minDistance;
     }
 
     static set mapMatchingMinDistance(minDistance) {
-        AbsolutePosition.mapMatchingMinDistance = minDistance;
+        MapMatchingHandler.minDistance = minDistance;
     }
 
     static get mapMatchingMaxAngleBearing() {
-        return AbsolutePosition.mapMatchingMaxAngleBearing;
+        return MapMatchingHandler.maxAngleBearing;
     }
 
     static set mapMatchingMaxAngleBearing(maxAngleBearing) {
-        AbsolutePosition.mapMatchingMaxAngleBearing = maxAngleBearing;
+        MapMatchingHandler.maxAngleBearing = maxAngleBearing;
     }
 }
 

package/src/events/ProviderEvent.js

@@ -6,7 +6,6 @@ import EventType from './EventType.js';
  */
 class ProviderEvent {
 
-    timestamp = -1;
     dataType = EventType.Unknown;
     providersStack = [];
     data = null;
@@ -23,7 +22,6 @@ class ProviderEvent {
 
     clone() {
         const evt = new ProviderEvent(this.dataType, this.data);
-        evt.timestamp = this.timestamp;
         evt.providersStack = this.providersStack.slice(0);
         return evt;
     }

package/src/mapmatching/MapMatchingHandler.js

@@ -0,0 +1,150 @@
+import { UserPosition } from '@wemap/geo';
+import {
+    MapMatching, Network
+} from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+
+import {
+    AbsolutePosition, AbsoluteAttitudeFused
+} from '../Providers.js';
+import ProvidersOptions from '../ProvidersOptions.js';
+
+const MM_MAX_ANGLE = deg2rad(20);
+const MM_MAX_DIST = 30;
+const MM_MIN_DIST = 0;
+
+class MapMatchingHandler {
+
+    /** @type {MapMatching} */
+    _mapMatching;
+
+    /** @type {number} */
+    _mapMatchingMinDistance;
+
+    /**
+     * Singleton pattern using reflection.
+     * @returns {MapMatchingHandler}
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = Reflect.construct(this, []);
+        }
+        return this._instance;
+    }
+
+    constructor() {
+
+        if (this.constructor._instance) {
+            throw new Error(`Cannot instantiate ${this.name} twice`);
+        }
+
+        this._mapMatching = new MapMatching();
+        this._mapMatching.maxDistance = MM_MAX_DIST;
+        this._mapMatching.maxAngleBearing = MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MM_MIN_DIST;
+    }
+
+    get enabled() {
+        return ProvidersOptions.useMapMatching;
+    }
+
+    /**
+     * @param {Network} network
+     */
+    set network(network) {
+        this._mapMatching.network = network;
+
+        if (!this.enabled) {
+            return;
+        }
+
+        const lastEvent = AbsolutePosition.lastEvent;
+        if (network !== null && lastEvent) {
+            const projectedPosition = this.calcProjection(lastEvent.data, true);
+            if (projectedPosition) {
+                const newEvent = lastEvent.clone();
+                newEvent.data = projectedPosition;
+                AbsolutePosition.notify(newEvent);
+            }
+        }
+    }
+
+    /**
+     * @param {UserPosition} position
+     * @param {boolean} shouldTryMmOnNodes
+     * @returns {UserPosition}
+     */
+    calcProjection(position, shouldTryMmOnNodes = false) {
+
+        let projection = null;
+        let bearingUsedForProjection = false;
+
+        if (!this.enabled || !this._mapMatching.network) {
+            return null;
+        }
+
+        // Firstly, if new position bearing is known, try to use map-matching with bearing
+        // That is not always the case, for e.g. the first position returned by the GnssWifi provider.
+        if (position.bearing !== null) {
+            projection = this._mapMatching.getProjection(position, true, true);
+            bearingUsedForProjection = true;
+        }
+
+        // Secondly, if map-matching with bearing did not work, try MM on nodes (without bearing).
+        // Note: this is not allowed for positions from AbsolutePositionFromRel to allow
+        //       user to leave the network.
+        if (!projection && shouldTryMmOnNodes) {
+            projection = this._mapMatching.getProjection(position, true, false);
+            bearingUsedForProjection = false;
+        }
+
+        // No projection found
+        if (!projection) {
+            return null;
+        }
+
+        // Do not use projection if it too close from itinerary,
+        //  this allows left/right movements (ie with ArCore)
+        if (projection.distanceFromNearestElement < this._mapMatchingMinDistance) {
+            return null;
+        }
+
+        if (bearingUsedForProjection) {
+            AbsoluteAttitudeFused.mapMatching(projection);
+        }
+
+        // Do not use projection.projection directly, because position has some specific properties like time, bearing and altitude
+        const projectedPosition = position.clone();
+        projectedPosition.lat = projection.projection.lat;
+        projectedPosition.lng = projection.projection.lng;
+        projectedPosition.level = projection.projection.level;
+
+        return projectedPosition;
+    }
+
+    get maxDistance() {
+        return this._mapMatching.maxDistance;
+    }
+
+    set maxDistance(maxDistance) {
+        this._mapMatching.maxDistance = maxDistance;
+    }
+
+    get minDistance() {
+        return this._mapMatchingMinDistance;
+    }
+
+    set minDistance(minDistance) {
+        this._mapMatchingMinDistance = minDistance;
+    }
+
+    get maxAngleBearing() {
+        return this._mapMatching.maxAngleBearing;
+    }
+
+    set maxAngleBearing(maxAngleBearing) {
+        this._mapMatching.maxAngleBearing = maxAngleBearing;
+    }
+}
+
+export default MapMatchingHandler.instance;

package/src/providers/FakeProvider.spec.js

@@ -1,5 +1,4 @@
 import { UserPosition } from '@wemap/geo';
-import { TimeUtils } from '@wemap/utils';
 
 import Provider from './Provider.js';
 import EventType from '../events/EventType.js';
@@ -29,7 +28,6 @@ class FakeProvider3 extends Provider {
         this.intervalId = setInterval(() => {
             const fakePosition = new UserPosition(Math.random() * 45, Math.random() * 180);
             this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition));
-            this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition, TimeUtils.preciseTime));
         }, 1);
     }
     stop() {

package/src/providers/Provider.js

@@ -1,7 +1,5 @@
 import noop from 'lodash.noop';
 
-import { TimeUtils } from '@wemap/utils';
-
 import EventType from '../events/EventType.js';
 import ProviderEvent from '../events/ProviderEvent.js';
 import ProvidersLoggerOld from '../events/ProvidersLoggerOld.js';
@@ -96,13 +94,11 @@ class Provider {
      * Create an event from current provider
      * @param {ProviderEvent#DataType} dataType type of ProviderEvent
      * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
      * @returns {ProviderEvent}
      * @protected
      */
-    static createEvent(dataType, data, timestamp, fromEvents = []) {
+    static createEvent(dataType, data, fromEvents = []) {
         const event = new ProviderEvent(dataType, data);
-        event.timestamp = typeof timestamp === 'number' ? timestamp : TimeUtils.preciseTime / 1e3;
         const newStack = fromEvents.reduce((acc, _event) => acc.concat(_event.providersStack), []);
         // Remove duplicates and keep lasts
         event.providersStack = [...new Set(newStack.reverse())].reverse();
@@ -113,13 +109,12 @@ class Provider {
      * Create an event from current provider
      * @param {EventType} dataType type of ProviderEvent
      * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
      * @param {ProviderEvent[]} fromEvents events used for the creation of the new one
      * @returns {ProviderEvent}
      * @protected
      */
-    createEvent(dataType, data, timestamp, fromEvents) {
-        return this.constructor.createEvent(dataType, data, timestamp, fromEvents);
+    createEvent(dataType, data, fromEvents) {
+        return this.constructor.createEvent(dataType, data, fromEvents);
     }
 
     get hasNativeInterface() {

package/src/providers/attitude/absolute/AbsoluteAttitudeFromBrowserProvider.js

@@ -229,7 +229,6 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
         this.notify(this.createEvent(
             EventType.AbsoluteAttitude,
             attitude,
-            this.magQuaternionTimestamp,
             [this.absolutePositionEvent]
         ));
     }

package/src/providers/attitude/absolute/AbsoluteAttitudeFromRelAttProvider.js

@@ -4,7 +4,7 @@ import { Attitude } from '@wemap/geo';
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import {
-    RelativeAttitude, AbsoluteAttitude, AbsoluteAttitudeFromBrowser
+    RelativeAttitude, AbsoluteAttitude, AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFused
 } from '../../../Providers.js';
 
 /**
@@ -91,7 +91,8 @@ class AbsoluteAttitudeFromRelAttProvider extends Provider {
          * Use absolute attitude events only when they are not from this provider
          */
         if (absoluteAttitudeEvent.providersStack.includes(this.pname)
-            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFromBrowser.pname)) {
+            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFromBrowser.pname)
+            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFused.pname)) {
             return;
         }
         this.absoluteAttitudeEvent = absoluteAttitudeEvent;
@@ -121,7 +122,6 @@ class AbsoluteAttitudeFromRelAttProvider extends Provider {
         this.notify(this.createEvent(
             EventType.AbsoluteAttitude,
             attitude,
-            time,
             [this.relativeAttitudeEvent, this.absoluteAttitudeEvent]
         ));