@wemap/providers 12.10.8 → 12.10.9

package/src/providers/FakeProvider.spec.ts

@@ -1,49 +0,0 @@
-import { UserPosition } from '@wemap/geo';
-
-import Provider from './Provider.js';
-
-class FakeProvider1Clazz extends Provider<void> {
-    getName = () => 'FakeProvider1';
-    availability = () => Promise.resolve();
-    start() { this.notifyError(new Error()); }
-    stop() { /* do nothing */ }
-}
-const FakeProvider1 = new FakeProvider1Clazz();
-export { FakeProvider1 };
-
-class FakeProvider2Clazz extends Provider<void> {
-    getName = () => 'FakeProvider2';
-    availability = () => Promise.resolve(new Error());
-    start() { /* do nothing */ }
-    stop() { /* do nothing */ }
-}
-const FakeProvider2 = new FakeProvider2Clazz();
-export { FakeProvider2 };
-
-class FakeProvider3Clazz extends Provider<UserPosition> {
-    intervalId?: NodeJS.Timer;
-    getName = () => 'FakeProvider3';
-    availability = () => Promise.resolve();
-    start() {
-        this.intervalId = setInterval(() => {
-            this.notify(new UserPosition(Math.random() * 45, Math.random() * 180));
-        }, 1);
-    }
-    stop() { clearInterval(this.intervalId); }
-}
-const FakeProvider3 = new FakeProvider3Clazz();
-export { FakeProvider3 };
-
-class FakeProvider4Clazz extends Provider<UserPosition> {
-    fp3id?: number;
-    getName = () => 'FakeProvider4';
-    availability = () => FakeProvider3.getAvailability();
-    start() {
-        this.fp3id = FakeProvider3.addEventListener(this.notify, this.notifyError);
-    }
-    stop() {
-        FakeProvider3.removeEventListener(this.fp3id);
-    }
-}
-const FakeProvider4 = new FakeProvider4Clazz();
-export { FakeProvider4 };

package/src/providers/Provider.spec.ts

@@ -1,113 +0,0 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-
-import Logger from '@wemap/logger';
-
-import Provider from './Provider.js';
-import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError.js';
-import {
-    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4
-} from './FakeProvider.spec.js';
-import ProvidersOptions from '../ProvidersOptions.js';
-
-chai.use(chaiAsPromised);
-Logger.enable(false);
-
-const { expect } = chai;
-
-const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-
-describe('Provider', () => {
-
-    it('default getter', () => {
-        const provider = FakeProvider1;
-        expect(provider.getName()).equals(FakeProvider1.getName());
-        expect(provider.useCameraNatively).is.false;
-    });
-
-    it('availability', async () => {
-
-        expect(FakeProvider1.getAvailability()).to.be.fulfilled;
-        ProvidersOptions.ignoreProviders.push(FakeProvider1.getName());
-        expect(await FakeProvider1.getAvailability()).is.instanceOf(ContainsIgnoredProviderError);
-        ProvidersOptions.ignoreProviders = [];
-
-        expect(await FakeProvider2.getAvailability()).is.instanceOf(Error);
-
-        expect(FakeProvider3.getAvailability()).to.be.fulfilled;
-        expect(FakeProvider4.getAvailability()).to.be.fulfilled;
-    });
-
-    it('checkAvailability on start', async () => {
-
-        /**
-         * checkAvailabilityOnStart = true
-         */
-        let errored = false;
-        FakeProvider2.addEventListener(null, () => (errored = true));
-
-        await sleep(2);
-
-        expect(errored).is.true;
-        expect(FakeProvider2.state).equals('stopped');
-        expect(FakeProvider2._eventsCallbacks.length).equals(0);
-
-        /**
-         * checkAvailabilityOnStart = false
-         */
-        ProvidersOptions.checkAvailabilityOnStart = false;
-
-        errored = false;
-        const id = FakeProvider2.addEventListener(null, () => (errored = true));
-
-        await sleep(2);
-
-        expect(errored).is.false;
-        expect(FakeProvider2.state).equals('started');
-
-        FakeProvider2.removeEventListener(id);
-        expect(FakeProvider2.state).equals('stopped');
-        expect(FakeProvider2._eventsCallbacks.length).equals(0);
-
-        ProvidersOptions.checkAvailabilityOnStart = true;
-    });
-
-    const startStop = <T>(provider: Provider<T>) => {
-        return new Promise<void>((resolve, reject) => {
-            let isStopped = false;
-            let fail = false;
-
-            const listenerId = provider.addEventListener(() => {
-                if (isStopped) {
-                    fail = true;
-                }
-            });
-
-            setTimeout(() => {
-                isStopped = true;
-                provider.removeEventListener(listenerId);
-
-                setTimeout(() => {
-                    if (fail) {
-                        reject('Provider did not stop');
-                    } else {
-                        resolve();
-                    }
-                }, 5);
-            }, 7);
-        });
-    };
-
-
-    it('start/stop', async () => {
-        let errored = false;
-        FakeProvider1.addEventListener(null, () => (errored = true));
-        await sleep(2);
-        expect(errored).is.true;
-
-        await expect(startStop(FakeProvider2)).to.be.fulfilled;
-        await expect(startStop(FakeProvider3)).to.be.fulfilled;
-        await expect(startStop(FakeProvider4)).to.be.fulfilled;
-
-    });
-});

package/src/providers/Provider.ts

@@ -1,244 +0,0 @@
-import ProvidersLoggerOld from '../events/ProvidersLoggerOld.js';
-import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError.js';
-import ProvidersOptions from '../ProvidersOptions.js';
-import { ProviderState } from './ProviderState.js';
-import { AvailabilityPromise } from '../events/AvailabilityHelper.js';
-import { NativeCallbackInterface, NativeInterface } from './NativeProviders.js';
-
-declare global {
-    interface Window {
-        __nativeProviders?: NativeInterface;
-        __nativeJsProviders?: NativeCallbackInterface;
-    }
-}
-
-/**
- * A provider is a meta class to define an entity which can be
- * started / stopped and provides a data of <E>
- */
-abstract class Provider<E> {
-
-    static _callbackUniqueId = 0;
-    static _uniqueId = 1;
-
-    id: number;
-    state: ProviderState = 'stopped';
-
-    _lastEvent: E | null = null;
-
-    _eventsCallbacks: {
-        id: number,
-        onEvent: ((event: E) => void) | null,
-        onError: ((error: Error) => void) | null,
-        optional: boolean
-    }[] = [];
-
-    _monitoringCallbacks: {
-        id: number,
-        onStarted: (() => void) | null,
-        onStopped: (() => void) | null
-    }[] = [];
-
-    /**
-     * Provider constructor
-     */
-    constructor() {
-        this.id = Provider._uniqueId++;
-        ProvidersLoggerOld.addEvent(this, 'constructor');
-    }
-
-    /**
-     * Get the provider name
-     */
-    abstract getName(): string;
-
-
-    /**
-     * Resolve with an error if the provider is not available
-     */
-    getAvailability() {
-        if (ProvidersOptions.ignoreProviders.includes(this.getName())) {
-            return Promise.resolve(new ContainsIgnoredProviderError());
-        }
-
-        return this.availability();
-    }
-
-    protected abstract availability(): AvailabilityPromise;
-
-
-    protected get hasNativeInterface() {
-        return Boolean(this.nativeInterface);
-    }
-
-    protected get nativeInterface() {
-        return typeof window !== 'undefined' && window.__nativeProviders as NativeInterface || null;
-    }
-
-    protected get nativeJsInterface(): NativeCallbackInterface | null {
-        if (typeof window === 'undefined') {
-            return null;
-        }
-        if (!window.__nativeJsProviders) {
-            window.__nativeJsProviders = {};
-        }
-        return window.__nativeJsProviders;
-    }
-
-
-    get useCameraNatively() {
-        return false;
-    }
-
-
-    addEventListener(
-        onEvent: ((events: E) => void) | null = null,
-        onError: ((error: Error) => void) | null = null,
-        startIfNecessary = true
-    ) {
-        const id = ++Provider._callbackUniqueId;
-
-        /**
-         * Build callback
-         */
-        this._eventsCallbacks.push({
-            id,
-            onEvent: onEvent || (() => { /* do nothing */ }),
-            onError: onError || (() => { /* do nothing */ }),
-            optional: !startIfNecessary
-        });
-
-
-        // The caller just want to have callbacks without starting the provider,
-        // the routine can be stopped here
-        if (!startIfNecessary) {
-            return id;
-        }
-
-
-        // If the provider is already started do not go further
-        if (this.state !== 'stopped') {
-            return id;
-        }
-        this.state = 'starting';
-
-        // Check availability on start if defined in options
-        let availabilityPromise: AvailabilityPromise = Promise.resolve();
-        if (ProvidersOptions.checkAvailabilityOnStart) {
-            availabilityPromise = this.getAvailability();
-        }
-
-        (async () => {
-            const error = await availabilityPromise;
-            if (error) {
-                this.state = 'stopped';
-                this.notifyError(error);
-                return;
-            }
-
-            ProvidersLoggerOld.addEvent(this, 'start');
-
-            // Call the child start function
-            this.start();
-
-            this.state = 'started';
-
-            this._monitoringCallbacks.forEach(cb => cb.onStarted?.());
-        })();
-
-        return id;
-    }
-
-    removeEventListener(callbackUniqueId?: number) {
-
-        // Search the caller object in callbacks list
-        const callback = this._eventsCallbacks.find(_callback => _callback.id === callbackUniqueId);
-        if (!callback) {
-            // The callback object is not found. Maybe it is already stopped.
-            return;
-        }
-
-        // Remove the current callback from the list of the callbacks
-        this._eventsCallbacks = this._eventsCallbacks.filter(_callback => _callback !== callback);
-
-        // If this callback was optional, do not go further to stop the provider
-        if (callback.optional) {
-            return;
-        }
-
-        // If there is callbacks that are not optionals for start, do not stop the provider
-        if (this._eventsCallbacks.find(_callback => !_callback.optional)) {
-            return;
-        }
-
-        // If the provider is already stopped, do not stop it again.
-        // This condition can be true if checkAvailabilityOnStart is true and returns an error
-        if (this.state === 'stopped') {
-            return;
-        }
-
-        ProvidersLoggerOld.addEvent(this, 'stop');
-        // Call the child stop function
-        this.stop();
-
-        this.state = 'stopped';
-
-        this._monitoringCallbacks.forEach(cb => cb.onStopped?.());
-    }
-
-
-    addMonitoringListener(onStarted?: (() => void) | null, onStopped?: (() => void) | null) {
-        const id = Provider._callbackUniqueId++;
-        this._monitoringCallbacks.push({
-            id,
-            onStarted: onStarted || null,
-            onStopped: onStopped || null
-        });
-        return id;
-    }
-
-    removeMonitoringListener(callbackUniqueId?: number) {
-        this._monitoringCallbacks = this._monitoringCallbacks.filter(
-            _callback => _callback.id !== callbackUniqueId
-        );
-    }
-
-
-    protected abstract start(): void
-    protected abstract stop(): void
-
-
-    /**
-     * Notify the subscriber defined in {@link addEventListener}
-     */
-    notify = (event: E) => {
-        // Logging
-        ProvidersLoggerOld.incrementNotifications(this);
-
-        // Notify callbacks
-        this._eventsCallbacks.forEach(cb => cb.onEvent?.(event));
-
-        // Keep a trace of the last events.
-        this._lastEvent = event;
-    }
-
-    /**
-     * Notify the subscriber defined in {@link addEventListener}
-     */
-    notifyError = (error: Error) => {
-        this._eventsCallbacks.forEach(({
-            id, onError
-        }) => {
-            if (ProvidersOptions.stopOnError) {
-                this.removeEventListener(id);
-            }
-            onError?.(error);
-        });
-    }
-
-    get lastEvent() {
-        return this._lastEvent;
-    }
-}
-
-export default Provider;

package/src/providers/attitude/EkfAttitude.spec.ts

@@ -1,115 +0,0 @@
-import chai from 'chai';
-
-import { Quaternion, Quaternion_t, Vector3_t } from '@wemap/maths';
-
-import EkfAttitude from './EkfAttitude.js';
-
-
-const expect = chai.expect;
-
-const dt = [
-    0.02, 0.02, 0.02, 0.02, 0.02
-];
-const accData: Vector3_t[] = [
-    [-0.034561157, 3.81073, 8.860977],
-    [-0.030700684, 3.814499, 8.818954],
-    [-0.018234253, 3.8023376, 8.85762],
-    [-0.020080566, 3.8205414, 8.8676605],
-    [-0.054519653, 3.8456726, 8.810287]
-];
-
-const gyrData: Vector3_t[] = [
-    [0.0047454834, 0.0028076172, 0.0022888184],
-    [0.005218506, 0.0020446777, 0.0012207031],
-    [0.0044555664, 0.0023040771, 4.4250488E-4],
-    [0.0044555664, 0.0027618408, 0.0011444092],
-    [0.0040893555, 0.0020446777, 0.0025787354]
-];
-
-const magData: Vector3_t[] = [
-    [-7.260132, -29.21753, -30.532837],
-    [-8.378601, -29.589844, -29.684448],
-    [-8.784485, -29.97284, -29.86145],
-    [-8.784485, -30.06134, -30.036926],
-    [-8.917236, -29.666138, -28.616333]
-];
-
-const expectationsAbsolute: Quaternion_t[] = [
-    [0.22501367907095468, 0.048112975227173178, -0.19586497565981961, -0.95325279813673824],
-    [0.22521836492577899, 0.048187611771482071, -0.19604062637627487, -0.953164579168738],
-    [0.22546875479675244, 0.048146964451479861, -0.19603487950732199, -0.95310861733648156],
-    [0.22571872218138991, 0.04816067876157637, -0.19609909097002176, -0.95303554708035731],
-    [0.22598409746972753, 0.048415228863568645, -0.1963289784536566, -0.95291242279877153]
-];
-
-const expectationsRelative: Quaternion_t[] = [
-    [0.979449872594084, 0.201679452107589, 0.001829118097573, 0],
-    [0.979412310855378, 0.201861876976980, 0.001818648953412, 0.000022005516141],
-    [0.979416707676713, 0.201841237873455, 0.001739180982152, 0.000051642340567],
-    [0.979405268570585, 0.201897124314688, 0.001692389320913, 0.000083114532679],
-    [0.979351148979101, 0.202158360999907, 0.001821014027950, 0.000089325563504]
-];
-
-describe('initAbsolute', () => {
-    it('Should return the good value', () => {
-        const ekf = new EkfAttitude();
-        ekf.setAbsoluteNoises({
-            acc: 0.5,
-            gyr: 0.3,
-            yc: 2
-        });
-        const result = ekf.update(dt[0], accData[0], gyrData[0], magData[0]);
-        const distance = Quaternion.distance(result, expectationsAbsolute[0]);
-        expect(distance).to.below(0.000001);
-    });
-});
-
-describe('updateAbsolute', () => {
-    it('Should return the good value', () => {
-        const ekf = new EkfAttitude();
-        ekf.setAbsoluteNoises({
-            acc: 0.5,
-            gyr: 0.3,
-            yc: 2
-        });
-        let result;
-        let distance;
-
-        for (let i = 0; i < accData.length; i++) {
-            result = ekf.update(dt[i], accData[i], gyrData[i], magData[i]);
-            distance = Quaternion.distance(result, expectationsAbsolute[i]);
-            expect(distance).to.below(0.000001);
-        }
-    });
-});
-
-describe('initRelative', () => {
-    it('Should return the good value', () => {
-        const ekf = new EkfAttitude();
-        ekf.setRelativeNoises({
-            acc: 0.5,
-            gyr: 0.3
-        });
-        const result = ekf.update(dt[0], accData[0], gyrData[0]);
-        const distance = Quaternion.distance(result, expectationsRelative[0]);
-        expect(distance).to.below(0.000001);
-    });
-});
-
-describe('updateRelative', () => {
-    it('Should return the good value', () => {
-        const ekf = new EkfAttitude();
-        ekf.setRelativeNoises({
-            acc: 0.5,
-            gyr: 0.3
-        });
-        let result;
-        let distance;
-
-        for (let i = 0; i < accData.length; i++) {
-            result = ekf.update(dt[i], accData[i], gyrData[i]);
-            distance = Quaternion.distance(result, expectationsRelative[i]);
-            expect(distance).to.below(0.000001);
-        }
-    });
-});