@wemap/providers 4.0.0 → 4.0.1

package/debug/src/AbsoluteAttitudeComponent.jsx

@@ -8,7 +8,10 @@ import { TimeUtils } from '@wemap/utils';
 
 import ProvidersLoggerOld from '../../src/events/ProvidersLoggerOld.js';
 import {
-    AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFromRelAtt, AbsoluteAttitude, AbsolutePosition
+    AbsoluteAttitudeFromBrowser,
+    AbsoluteAttitudeFromRelAtt,
+    AbsoluteAttitude,
+    AbsolutePosition
 } from '../../src/Providers.js';
 import Utils from './Utils.js';
 

package/package.json

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

package/src/Providers.js

@@ -1,91 +1,35 @@
 /* eslint-disable max-len */
-/* eslint-disable id-length */
 
-import ImuProvider from './providers/imu/ImuProvider.js';
-import AccelerometerProvider from './providers/imu/AccelerometerProvider.js';
-import GyroscopeProvider from './providers/imu/GyroscopeProvider.js';
-const Imu = ImuProvider.instance;
-const Accelerometer = AccelerometerProvider.instance;
-const Gyroscope = GyroscopeProvider.instance;
+export { default as Imu } from './providers/imu/Imu.js';
+export { default as Accelerometer } from './providers/imu/Accelerometer.js';
+export { default as Gyroscope } from './providers/imu/Gyroscope.js';
 
-import RelativeAttitudeFromBrowserProvider from './providers/attitude/relative/RelativeAttitudeFromBrowserProvider.js';
-import RelativeAttitudeFromEkfProvider from './providers/attitude/relative/RelativeAttitudeFromEkfProvider.js';
-import RelativeAttitudeFromInertialProvider from './providers/attitude/relative/RelativeAttitudeFromInertialProvider.js';
-import RelativeAttitudeProvider from './providers/attitude/relative/RelativeAttitudeProvider.js';
-const RelativeAttitudeFromBrowser = RelativeAttitudeFromBrowserProvider.instance;
-const RelativeAttitudeFromEkf = RelativeAttitudeFromEkfProvider.instance;
-const RelativeAttitudeFromInertial = RelativeAttitudeFromInertialProvider.instance;
-const RelativeAttitude = RelativeAttitudeProvider.instance;
+export { default as RelativeAttitudeFromBrowser } from './providers/attitude/relative/RelativeAttitudeFromBrowser.js';
+export { default as RelativeAttitudeFromEkf } from './providers/attitude/relative/RelativeAttitudeFromEkf.js';
+export { default as RelativeAttitudeFromInertial } from './providers/attitude/relative/RelativeAttitudeFromInertial.js';
+export { default as RelativeAttitude } from './providers/attitude/relative/RelativeAttitude.js';
 
-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;
+export { default as AbsoluteAttitudeFromBrowser } from './providers/attitude/absolute/AbsoluteAttitudeFromBrowser.js';
+export { default as AbsoluteAttitudeFromRelAtt } from './providers/attitude/absolute/AbsoluteAttitudeFromRelAtt.js';
+export { default as AbsoluteAttitudeFused } from './providers/attitude/absolute/AbsoluteAttitudeFused.js';
+export { default as AbsoluteAttitude } from './providers/attitude/absolute/AbsoluteAttitude.js';
 
-import InclinationFromAccProvider from './providers/inclination/InclinationFromAccProvider.js';
-import InclinationFromRelativeAttitudeProvider from './providers/inclination/InclinationFromRelativeAttitudeProvider.js';
-import InclinationProvider from './providers/inclination/InclinationProvider.js';
-const InclinationFromAcc = InclinationFromAccProvider.instance;
-const InclinationFromRelativeAttitude = InclinationFromRelativeAttitudeProvider.instance;
-const Inclination = InclinationProvider.instance;
+export { default as InclinationFromAcc } from './providers/inclination/InclinationFromAcc.js';
+export { default as InclinationFromRelativeAttitude } from './providers/inclination/InclinationFromRelativeAttitude.js';
+export { default as Inclination } from './providers/inclination/Inclination.js';
 
-import StepDetectionProvider from './providers/steps/StepDetectionProvider.js';
-const StepDetection = StepDetectionProvider.instance;
+export { default as StepDetection } from './providers/steps/StepDetection.js';
 
-import ArCoreProvider from './providers/position/relative/ArCoreProvider.js';
-import PdrProvider from './providers/position/relative/PdrProvider.js';
-import GeoRelativePositionFromArCoreProvider from './providers/position/relative/GeoRelativePositionFromArCoreProvider.js';
-import GeoRelativePositionProvider from './providers/position/relative/GeoRelativePositionProvider.js';
-const ArCore = ArCoreProvider.instance;
-const Pdr = PdrProvider.instance;
-const GeoRelativePositionFromArCore = GeoRelativePositionFromArCoreProvider.instance;
-const GeoRelativePosition = GeoRelativePositionProvider.instance;
+export { default as ArCore } from './providers/position/relative/ArCore.js';
+export { default as Pdr } from './providers/position/relative/Pdr.js';
+export { default as GeoRelativePositionFromArCore } from './providers/position/relative/GeoRelativePositionFromArCore.js';
+export { default as GeoRelativePosition } from './providers/position/relative/GeoRelativePosition.js';
 
-import AbsolutePositionFromRelProvider from './providers/position/absolute/AbsolutePositionFromRelProvider.js';
-import GnssWifiProvider from './providers/position/absolute/GnssWifiProvider.js';
-import IpProvider from './providers/position/absolute/IpProvider.js';
-import AbsolutePositionProvider from './providers/position/absolute/AbsolutePositionProvider.js';
-const AbsolutePositionFromRel = AbsolutePositionFromRelProvider.instance;
-const GnssWifi = GnssWifiProvider.instance;
-const Ip = IpProvider.instance;
-const AbsolutePosition = AbsolutePositionProvider.instance;
+export { default as AbsolutePositionFromRel } from './providers/position/absolute/AbsolutePositionFromRel.js';
+export { default as GnssWifi } from './providers/position/absolute/GnssWifi.js';
+export { default as Ip } from './providers/position/absolute/Ip.js';
+export { default as AbsolutePosition } from './providers/position/absolute/AbsolutePosition.js';
 
-import BarcodeProvider from './providers/others/BarcodeProvider.js';
-import CameraNativeProvider from './providers/others/CameraNativeProvider.js';
-import CameraProjectionMatrixProvider from './providers/others/CameraProjectionMatrixProvider.js';
-const Barcode = BarcodeProvider.instance;
-const CameraNative = CameraNativeProvider.instance;
-const CameraProjectionMatrix = CameraProjectionMatrixProvider.instance;
-
-export {
-    AbsoluteAttitude,
-    AbsoluteAttitudeFromBrowser,
-    AbsoluteAttitudeFromRelAtt,
-    AbsoluteAttitudeFused,
-    AbsolutePosition,
-    AbsolutePositionFromRel,
-    Accelerometer,
-    ArCore,
-    Barcode,
-    CameraNative,
-    CameraProjectionMatrix,
-    GeoRelativePosition,
-    GeoRelativePositionFromArCore,
-    GnssWifi,
-    Gyroscope,
-    Imu,
-    Inclination,
-    InclinationFromAcc,
-    InclinationFromRelativeAttitude,
-    Ip,
-    Pdr,
-    RelativeAttitude,
-    RelativeAttitudeFromBrowser,
-    RelativeAttitudeFromEkf,
-    RelativeAttitudeFromInertial,
-    StepDetection
-};
+export { default as Barcode } from './providers/others/Barcode.js';
+export { default as CameraNative } from './providers/others/CameraNative.js';
+export { default as CameraProjectionMatrix } from './providers/others/CameraProjectionMatrix.js';

package/src/errors/AskImuOnDesktopError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'It seems that you ask for IMU events on a desktop browser';
-
 class AskImuOnDesktopError extends Error {
+
+    static DEFAULT_MESSAGE = 'It seems that you ask for IMU events on a desktop browser';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || AskImuOnDesktopError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/ContainsIgnoredProviderError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Contains ignored provider';
-
 class ContainsIgnoredProviderError extends Error {
+
+    static DEFAULT_MESSAGE = 'Contains ignored provider';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || ContainsIgnoredProviderError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/GeolocationApiMissingError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Geolocation api is missing';
-
 class GeolocationApiMissingError extends Error {
+
+    static DEFAULT_MESSAGE = 'Geolocation api is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || GeolocationApiMissingError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/GeolocationPermissionDeniedError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Geolocation permission denied';
-
 class GeolocationPermissionDeniedError extends Error {
+
+    static DEFAULT_MESSAGE = 'Geolocation permission denied';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || GeolocationPermissionDeniedError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/GeolocationPositionUnavailableError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Geolocation position unavailable';
-
 class GeolocationPositionUnavailableError extends Error {
+
+    static DEFAULT_MESSAGE = 'Geolocation position unavailable';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || GeolocationPositionUnavailableError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/IpResolveServerError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'IP Resolver failed';
-
 class IpResolveServerError extends Error {
+
+    static DEFAULT_MESSAGE = 'IP Resolver failed';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || IpResolveServerError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingAccelerometerError.js

@@ -1,10 +1,10 @@
 import MissingSensorError from './MissingSensorError.js';
+class MissingAccelerometerError extends MissingSensorError {
 
-const DEFAULT_MESSAGE = 'Impossible to retrieve Acceleration data';
+    static DEFAULT_MESSAGE = 'Impossible to retrieve Acceleration data';
 
-class MissingAccelerometerError extends MissingSensorError {
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingAccelerometerError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingArCoreError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'ARCore is missing';
-
 class MissingArCoreError extends Error {
+
+    static DEFAULT_MESSAGE = 'ARCore is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingArCoreError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingGyroscopeError.js

@@ -1,10 +1,10 @@
 import MissingSensorError from './MissingSensorError.js';
+class MissingGyroscopeError extends MissingSensorError {
 
-const DEFAULT_MESSAGE = 'Impossible to retrieve Angular Rate data';
+    static DEFAULT_MESSAGE = 'Impossible to retrieve Angular Rate data';
 
-class MissingGyroscopeError extends MissingSensorError {
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingSensorError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingNativeInterfaceError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Native interface is missing';
-
 class MissingNativeInterfaceError extends Error {
+
+    static DEFAULT_MESSAGE = 'Native interface is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingNativeInterfaceError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingSensorError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
-
 class MissingSensorError extends Error {
+
+    static DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingSensorError.DEFAULT_MESSAGE);
     }
 
     from(fromMessage) {

package/src/errors/NoProviderFoundError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Unable to find a provider with your given parameters';
-
 class NoProviderFoundError extends Error {
+
+    static DEFAULT_MESSAGE = 'Unable to find a provider with your given parameters';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || NoProviderFoundError.DEFAULT_MESSAGE);
     }
 }
 

package/src/events/ProvidersLoggerOld.js

@@ -1,83 +1,84 @@
 import Logger from '@wemap/logger';
 
-let currentId = 0;
-const objectsIdMap = new WeakMap();
+class ProvidersLoggerOld {
 
-let pushEvents = {};
-let pushEventsRef = {};
+    _enabled = false;
 
-let interval;
-let initDate;
+    currentId = 0;
+    objectsIdMap = new WeakMap();
 
-class ProvidersLoggerOld {
+    pushEvents = {};
+    pushEventsRef = {};
+
+    interval;
+    initDate;
 
-    static _enabled = false;
 
-    static get enabled() {
+    get enabled() {
         return this._enabled;
     }
 
-    static set enabled(_newVal) {
+    set enabled(_newVal) {
         this._enabled = _newVal;
     }
 
-    static initializeInterval() {
+    initializeInterval() {
 
-        if (interval) {
+        if (this.interval) {
             return;
         }
 
-        interval = setInterval(() => {
+        this.interval = setInterval(() => {
 
-            for (const [key, value] of Object.entries(pushEvents)) {
-                Logger.debug('Received ' + value + ' notifications from ' + pushEventsRef[key].pname + ' last second');
+            for (const [key, value] of Object.entries(this.pushEvents)) {
+                Logger.debug('Received ' + value + ' notifications from ' + this.pushEventsRef[key].pname + ' last second');
             }
 
-            pushEvents = {};
-            pushEventsRef = {};
+            this.pushEvents = {};
+            this.pushEventsRef = {};
         }, 1000);
     }
 
-    static getObjectId(object) {
-        if (!objectsIdMap.has(object)) {
-            objectsIdMap.set(object, ++currentId);
+    getObjectId(object) {
+        if (!this.objectsIdMap.has(object)) {
+            this.objectsIdMap.set(object, ++this.currentId);
         }
-        return objectsIdMap.get(object);
+        return this.objectsIdMap.get(object);
     }
 
-    static addEvent(object, method) {
+    addEvent(object, method) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        if (!initDate) {
-            initDate = Date.now();
+        if (!this.initDate) {
+            this.initDate = Date.now();
         }
 
-        ProvidersLoggerOld.initializeInterval();
+        this.initializeInterval();
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
         const objectClassName = object.pname;
 
         Logger.debug(objectClassName + '[' + objectId + '].' + method);
     }
 
-    static incrementNotifications(object) {
+    incrementNotifications(object) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
 
-        let counter = pushEvents[objectId];
+        let counter = this.pushEvents[objectId];
         if (!counter) {
             counter = 0;
-            pushEventsRef[objectId] = object;
+            this.pushEventsRef[objectId] = object;
         }
-        pushEvents[objectId] = counter + 1;
+        this.pushEvents[objectId] = counter + 1;
     }
 
 }
-export default ProvidersLoggerOld;
+export default new ProvidersLoggerOld();

package/src/mapmatching/MapMatchingHandler.js

@@ -1,36 +1,24 @@
-import { UserPosition } from '@wemap/geo';
 import {
-    MapMatching, Network
+    MapMatching, Network, UserPosition
 } from '@wemap/geo';
 import { deg2rad } from '@wemap/maths';
 
-import {
-    AbsolutePosition, AbsoluteAttitudeFused
-} from '../Providers.js';
+import AbsoluteAttitudeFused from '../providers/attitude/absolute/AbsoluteAttitudeFused.js';
+import AbsolutePosition from '../providers/position/absolute/AbsolutePosition.js';
 import ProvidersOptions from '../ProvidersOptions.js';
 
-const MM_MAX_ANGLE = deg2rad(20);
-const MM_MAX_DIST = 30;
-const MM_MIN_DIST = 0;
-
 class MapMatchingHandler {
 
+    static MM_MAX_ANGLE = deg2rad(20);
+    static MM_MAX_DIST = 30;
+    static MM_MIN_DIST = 0;
+
     /** @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() {
 
@@ -39,9 +27,9 @@ class MapMatchingHandler {
         }
 
         this._mapMatching = new MapMatching();
-        this._mapMatching.maxDistance = MM_MAX_DIST;
-        this._mapMatching.maxAngleBearing = MM_MAX_ANGLE;
-        this._mapMatchingMinDistance = MM_MIN_DIST;
+        this._mapMatching.maxDistance = MapMatchingHandler.MM_MAX_DIST;
+        this._mapMatching.maxAngleBearing = MapMatchingHandler.MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
     }
 
     get enabled() {
@@ -103,16 +91,16 @@ class MapMatchingHandler {
             return null;
         }
 
+        if (bearingUsedForProjection) {
+            AbsoluteAttitudeFused.mapMatching(projection);
+        }
+
         // 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;
@@ -147,4 +135,4 @@ class MapMatchingHandler {
     }
 }
 
-export default MapMatchingHandler.instance;
+export default new MapMatchingHandler();

package/src/providers/FakeProvider.spec.js

@@ -3,13 +3,15 @@ import { UserPosition } from '@wemap/geo';
 import Provider from './Provider.js';
 import EventType from '../events/EventType.js';
 
-class FakeProvider1 extends Provider {
+class FakeProvider1Clazz extends Provider {
     static get pname() {
         return 'FakeProvider1';
     }
 }
+const FakeProvider1 = new FakeProvider1Clazz();
+export { FakeProvider1 };
 
-class FakeProvider2 extends Provider {
+class FakeProvider2Clazz extends Provider {
     static get pname() {
         return 'FakeProvider2';
     }
@@ -19,8 +21,10 @@ class FakeProvider2 extends Provider {
     start() { }
     stop() { }
 }
+const FakeProvider2 = new FakeProvider2Clazz();
+export { FakeProvider2 };
 
-class FakeProvider3 extends Provider {
+class FakeProvider3Clazz extends Provider {
     static get pname() {
         return 'FakeProvider3';
     }
@@ -34,31 +38,27 @@ class FakeProvider3 extends Provider {
         clearInterval(this.intervalId);
     }
 }
+const FakeProvider3 = new FakeProvider3Clazz();
+export { FakeProvider3 };
 
-class FakeProvider4 extends Provider {
+class FakeProvider4Clazz extends Provider {
 
     static get pname() {
         return 'FakeProvider4';
     }
 
-    constructor() {
-        super();
-        this.fp3 = FakeProvider3.instance;
-    }
     get _availability() {
-        return this.fp3.availability;
+        return FakeProvider3.availability;
     }
     start() {
-        this.fp3id = this.fp3.addEventListener(
+        this.fp3id = FakeProvider3.addEventListener(
             events => this.notify(events[0].clone()),
             this.notifyError.bind(this)
         );
     }
     stop() {
-        this.fp3.removeEventListener(this.fp3id);
+        FakeProvider3.removeEventListener(this.fp3id);
     }
 }
-
-export {
-    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4
-};
+const FakeProvider4 = new FakeProvider4Clazz();
+export { FakeProvider4 };

package/src/providers/Provider.js

@@ -7,7 +7,6 @@ import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError
 import ProvidersOptions from '../ProvidersOptions.js';
 import ProviderState from './ProviderState.js';
 
-let uniqueId = 1;
 
 /**
  * A provider is a meta class to define an entity which can be
@@ -16,25 +15,13 @@ let uniqueId = 1;
 class Provider {
 
     static _callbackUniqueId = 0;
+    static _uniqueId = 1;
 
     state = ProviderState.STOPPPED;
 
     _eventsCallbacks = [];
     _monitoringCallbacks = [];
 
-
-    /**
-     * Singleton pattern using reflection.
-     * @returns {Provider}
-     */
-    static get instance() {
-        if (!this._instance) {
-            this._instance = Reflect.construct(this, []);
-        }
-        return this._instance;
-    }
-
-
     /**
      * Provider constructor
      */
@@ -44,11 +31,7 @@ class Provider {
             throw new Error('Can\'t instantiate Provider directly');
         }
 
-        if (this._instance) {
-            throw new Error(`Cannot instantiate ${this.pname} twice`);
-        }
-
-        this.id = uniqueId++;
+        this.id = Provider._uniqueId++;
 
         ProvidersLoggerOld.addEvent(this, 'constructor');
     }