@wemap/providers 12.10.8 → 12.10.9

package/dist/src/providers/vision/vps/VpsMetadata.d.ts

@@ -0,0 +1,33 @@
+import { Calibration } from '@wemap/camera';
+import { Attitude, AttitudeJson, UserPosition, UserPositionJson } from '@wemap/geo';
+import { Device } from '@wemap/utils';
+export type CoarsePoseJson = {
+    attitude?: AttitudeJson;
+    position?: UserPositionJson;
+};
+export type CoarsePose = {
+    attitude?: Attitude;
+    position?: UserPosition;
+};
+export type VpsMetadataJson = {
+    size: [number, number];
+    calibration?: Calibration;
+    coarse?: CoarsePoseJson;
+    device?: Device;
+};
+declare class VpsMetadata {
+    size: {
+        width: number;
+        height: number;
+    };
+    calibration: Calibration | null;
+    coarse: CoarsePose | null;
+    device: Device | null;
+    constructor(size: {
+        width: number;
+        height: number;
+    }, calibration?: Calibration | null, coarse?: CoarsePose | null, device?: Device | null);
+    toJson(): VpsMetadataJson;
+    static fromJson(json: VpsMetadataJson): VpsMetadata;
+}
+export default VpsMetadata;

package/dist/src/providers/vision/vps/VpsProvider.d.ts

@@ -0,0 +1,45 @@
+import { Camera } from '@wemap/camera';
+import { default as Provider } from '../../Provider.js';
+import { default as RelativeRotationCalc } from './RelativeRotationCalc.js';
+import { AbsoluteAttitude, AbsolutePosition } from '../../../events/Types.js';
+export type VpsEvent = {
+    absoluteAttitude: AbsoluteAttitude;
+    absolutePosition: AbsolutePosition;
+};
+declare class VpsProvider extends Provider<VpsEvent> {
+    static MIN_TIME_BETWEEN_TWO_REQUESTS: number;
+    static DEFAULT_MIN_INCLINATION_FOR_REQUEST: number;
+    static DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST: number;
+    static DEFAULT_USE_COARSE_POSE: boolean;
+    static CAMERA_TO_SMARTPHONE_ROT: import('@wemap/maths').Quaternion_t;
+    _relativeRotationCalc?: RelativeRotationCalc;
+    _serverError: boolean;
+    _cameraError: boolean;
+    _camera: Camera | null;
+    _endpoint: string | null;
+    _inclinationProviderId?: number;
+    _minInclinationForRequest: number;
+    _waitTimeMinInclinationForRequest: number;
+    _useCoarsePose: boolean;
+    getName: () => string;
+    availability: () => Promise<void>;
+    start(): void;
+    stop(): void;
+    _onCameraDetected: ({ camera }: {
+        camera: Camera;
+    }) => void;
+    _onCameraRemoved: () => void;
+    _useCamera(camera: Camera): void;
+    _internalStart: () => Promise<void>;
+    _internalStop: () => void;
+    get endpoint(): string | null;
+    set endpoint(endpoint: string | null);
+    get minInclinationForRequest(): number;
+    set minInclinationForRequest(minInclinationForRequest: number);
+    get waitTimeMinInclinationForRequest(): number;
+    set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest: number);
+    get useCoarsePose(): boolean;
+    set useCoarsePose(useCoarsePose: boolean);
+}
+declare const _default: VpsProvider;
+export default _default;

package/dist/src/providers/vision/vps/VpsRequest.d.ts

@@ -0,0 +1,18 @@
+import { default as VpsMetadata, VpsMetadataJson } from './VpsMetadata.js';
+export type VpsRequestJson = VpsMetadataJson & {
+    image: string;
+};
+declare class VpsRequest {
+    metadata: VpsMetadata;
+    image: HTMLCanvasElement;
+    constructor(metadata: VpsMetadata, image: HTMLCanvasElement);
+    toJson(): {
+        size: [number, number];
+        calibration?: import('@wemap/camera').Calibration | undefined;
+        coarse?: import('./VpsMetadata.js').CoarsePoseJson | undefined;
+        device?: import('@wemap/utils').Device | undefined;
+        image: string;
+    };
+    static fromJson(json: VpsRequestJson): VpsRequest;
+}
+export default VpsRequest;

package/dist/src/providers/vision/vps/VpsResponse.d.ts

@@ -0,0 +1,15 @@
+import { Attitude, AttitudeJson, UserPosition, UserPositionJson } from '@wemap/geo';
+export type VpsResponseJson = {
+    success: boolean;
+    attitude?: AttitudeJson;
+    position?: UserPositionJson;
+};
+declare class VpsResponse {
+    success: boolean;
+    attitude: Attitude | null;
+    position: UserPosition | null;
+    constructor(success: boolean, attitude?: Attitude | null, position?: UserPosition | null);
+    toJson(): VpsResponseJson;
+    static fromJson(json: VpsResponseJson, imageRecordTime?: number | null): VpsResponse;
+}
+export default VpsResponse;

package/dist/src/smoothers/AttitudeSmoother.d.ts

@@ -0,0 +1,23 @@
+import { Attitude } from '@wemap/geo';
+declare class AttitudeSmoother {
+    callback: (attitude: Attitude) => void;
+    static ROTATION_SPEED_JUMP_THRESHOLD: number;
+    static ROTATION_SPEED_CONVERGENCE: number;
+    static HIGH_JUMP_THRESHOLD: number;
+    static ROTATION_SPEED_HIGH_JUMP_CONVERGENCE: number;
+    static PITCH_UNCERTAINITY_HEADING_THRESHOLD: number;
+    _previousAttitude?: Attitude;
+    _smoothing: null | {
+        interpAttitude(attitude: Attitude): Attitude;
+        toTime: number;
+    };
+    constructor(callback: (attitude: Attitude) => void);
+    feed(newAttitude: Attitude): void;
+    /**
+     * @param {Attitude} previousAttitude
+     * @param {Attitude} newAttitude
+     * @returns {boolean}
+     */
+    static isJump(previousAttitude: Attitude, newAttitude: Attitude): boolean;
+}
+export default AttitudeSmoother;

package/dist/src/smoothers/PositionSmoother.d.ts

@@ -0,0 +1,21 @@
+import { UserPosition } from '@wemap/geo';
+declare class PositionSmoother {
+    callback?: ((position: UserPosition) => void) | undefined;
+    frequency: number;
+    static DEFAULT_FREQUENCY: number;
+    static DEFAULT_FLYBY_TIME: number;
+    positionsQueue: UserPosition[];
+    previousPosition: UserPosition | null;
+    timeoutNotify?: any;
+    /**
+     * @param frequency in Hz
+     */
+    constructor(callback?: ((position: UserPosition) => void) | undefined, frequency?: number);
+    /**
+     * @param flybyTime in seconds
+     */
+    feed(newPosition: UserPosition, flybyTime?: number): void;
+    _notifyNext: () => void;
+    clear(): void;
+}
+export default PositionSmoother;

package/package.json

@@ -6,13 +6,13 @@
     ],
     "description": "A package using different geoloc systems",
     "main": "dist/index.js",
-    "types": "index.ts",
+    "types": "./dist/index.d.ts",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/wemap/wemap-modules-js.git"
     },
     "name": "@wemap/providers",
-    "version": "12.10.8",
+    "version": "12.10.9",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -22,14 +22,14 @@
         "build": "vite build"
     },
     "dependencies": {
-        "@wemap/camera": "^12.10.6",
-        "@wemap/geo": "^12.10.4",
-        "@wemap/logger": "^12.10.0",
-        "@wemap/map": "^12.10.4",
-        "@wemap/maths": "^12.10.0",
-        "@wemap/osm": "^12.10.4",
-        "@wemap/routers": "^12.10.8",
-        "@wemap/utils": "^12.10.0",
+        "@wemap/camera": "^12.10.9",
+        "@wemap/geo": "^12.10.9",
+        "@wemap/logger": "^12.10.9",
+        "@wemap/map": "^12.10.9",
+        "@wemap/maths": "^12.10.9",
+        "@wemap/osm": "^12.10.9",
+        "@wemap/routers": "^12.10.9",
+        "@wemap/utils": "^12.10.9",
         "geomag": "^1.0.0"
     },
     "devDependencies": {
@@ -48,13 +48,17 @@
     ],
     "license": "ISC",
     "type": "module",
+    "files": [
+        "dist",
+        "helpers"
+    ],
     "exports": {
         ".": {
-            "types": "./index.ts",
+            "types": "./dist/index.d.ts",
             "import": "./dist/index.mjs",
             "require": "./dist/index.js"
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "f9403da66a9608b96175565a9090fbf9dbb234a1"
+    "gitHead": "80eb531e0d704bc01cc93469b62cf0d6a83dcfd1"
 }

package/src/errors/AskImuOnDesktopError.ts

@@ -1,10 +0,0 @@
-class AskImuOnDesktopError extends Error {
-
-    static DEFAULT_MESSAGE = 'It seems that you ask for IMU events on a desktop browser';
-
-    constructor(message?: string) {
-        super(message || AskImuOnDesktopError.DEFAULT_MESSAGE);
-    }
-}
-
-export default AskImuOnDesktopError;

package/src/errors/ContainsIgnoredProviderError.ts

@@ -1,10 +0,0 @@
-class ContainsIgnoredProviderError extends Error {
-
-    static DEFAULT_MESSAGE = 'Contains ignored provider';
-
-    constructor(message?: string) {
-        super(message || ContainsIgnoredProviderError.DEFAULT_MESSAGE);
-    }
-}
-
-export default ContainsIgnoredProviderError;

package/src/errors/GeolocationApiMissingError.ts

@@ -1,10 +0,0 @@
-class GeolocationApiMissingError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation api is missing';
-
-    constructor(message?: string) {
-        super(message || GeolocationApiMissingError.DEFAULT_MESSAGE);
-    }
-}
-
-export default GeolocationApiMissingError;

package/src/errors/GeolocationPermissionDeniedError.ts

@@ -1,10 +0,0 @@
-class GeolocationPermissionDeniedError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation permission denied';
-
-    constructor(message?: string) {
-        super(message || GeolocationPermissionDeniedError.DEFAULT_MESSAGE);
-    }
-}
-
-export default GeolocationPermissionDeniedError;

package/src/errors/GeolocationPositionUnavailableError.ts

@@ -1,10 +0,0 @@
-class GeolocationPositionUnavailableError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation position unavailable';
-
-    constructor(message?: string) {
-        super(message || GeolocationPositionUnavailableError.DEFAULT_MESSAGE);
-    }
-}
-
-export default GeolocationPositionUnavailableError;

package/src/errors/IpResolveServerError.ts

@@ -1,10 +0,0 @@
-class IpResolveServerError extends Error {
-
-    static DEFAULT_MESSAGE = 'IP Resolver failed';
-
-    constructor(message?: string) {
-        super(message || IpResolveServerError.DEFAULT_MESSAGE);
-    }
-}
-
-export default IpResolveServerError;

package/src/errors/MissingAccelerometerError.ts

@@ -1,11 +0,0 @@
-import MissingSensorError from './MissingSensorError.js';
-class MissingAccelerometerError extends MissingSensorError {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve Acceleration data';
-
-    constructor(message?: string) {
-        super(message || MissingAccelerometerError.DEFAULT_MESSAGE);
-    }
-}
-
-export default MissingAccelerometerError;

package/src/errors/MissingArCoreError.ts

@@ -1,10 +0,0 @@
-class MissingArCoreError extends Error {
-
-    static DEFAULT_MESSAGE = 'ARCore is missing';
-
-    constructor(message?: string) {
-        super(message || MissingArCoreError.DEFAULT_MESSAGE);
-    }
-}
-
-export default MissingArCoreError;

package/src/errors/MissingGyroscopeError.ts

@@ -1,11 +0,0 @@
-import MissingSensorError from './MissingSensorError.js';
-class MissingGyroscopeError extends MissingSensorError {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve Angular Rate data';
-
-    constructor(message?: string) {
-        super(message || MissingSensorError.DEFAULT_MESSAGE);
-    }
-}
-
-export default MissingGyroscopeError;

package/src/errors/MissingMagnetometerError.ts

@@ -1,9 +0,0 @@
-import MissingSensorError from './MissingSensorError.js';
-
-class MissingMagnetometerError extends MissingSensorError {
-    constructor(message?: string) {
-        super(message);
-    }
-}
-
-export default MissingMagnetometerError;

package/src/errors/MissingNativeInterfaceError.ts

@@ -1,11 +0,0 @@
-class MissingNativeInterfaceError extends Error {
-
-    static DEFAULT_MESSAGE = 'Native interface is missing. You are maybe trying to '
-        + 'execute a code which is not available in a web browser';
-
-    constructor(message?: string) {
-        super(message || MissingNativeInterfaceError.DEFAULT_MESSAGE);
-    }
-}
-
-export default MissingNativeInterfaceError;

package/src/errors/MissingPoleStarError.ts

@@ -1,10 +0,0 @@
-class MissingPoleStarError extends Error {
-
-    static DEFAULT_MESSAGE = 'PoleStar is missing';
-
-    constructor(message?: string) {
-        super(message || MissingPoleStarError.DEFAULT_MESSAGE);
-    }
-}
-
-export default MissingPoleStarError;

package/src/errors/MissingSensorError.ts

@@ -1,15 +0,0 @@
-class MissingSensorError extends Error {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
-
-    constructor(message?: string) {
-        super(message || MissingSensorError.DEFAULT_MESSAGE);
-    }
-
-    from(fromMessage: string) {
-        this.message += ' from ' + fromMessage;
-        return this;
-    }
-}
-
-export default MissingSensorError;

package/src/errors/NoProviderFoundError.ts

@@ -1,10 +0,0 @@
-class NoProviderFoundError extends Error {
-
-    static DEFAULT_MESSAGE = 'Unable to find a provider with your given parameters';
-
-    constructor(message?: string) {
-        super(message || NoProviderFoundError.DEFAULT_MESSAGE);
-    }
-}
-
-export default NoProviderFoundError;

package/src/events/AvailabilityHelper.spec.ts

@@ -1,30 +0,0 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-
-import AvailabilityHelper from './AvailabilityHelper.js';
-
-chai.use(chaiAsPromised);
-const { expect } = chai;
-
-const availabilityOk = Promise.resolve();
-const availabilityFail1 = Promise.resolve(new Error('Reason 1.'));
-const availabilityFail2 = Promise.resolve(new Error('Reason 2.'));
-
-describe('AvailabilityHelper', () => {
-
-    it('every', async () => {
-        expect(await AvailabilityHelper.every([availabilityOk, availabilityOk])).is.equal(null);
-        expect((await AvailabilityHelper.every([availabilityOk, availabilityFail1]))!.message).is.equal('Reason 1.');
-        expect((await AvailabilityHelper.every([availabilityFail1, availabilityOk]))!.message).is.equal('Reason 1.');
-        expect((await AvailabilityHelper.every([availabilityFail1, availabilityFail2]))!.message).is.equal('Reason 1.');
-        expect((await AvailabilityHelper.every([availabilityFail2, availabilityFail1]))!.message).is.equal('Reason 2.');
-    });
-
-    it('some', async () => {
-        expect(await AvailabilityHelper.some([availabilityOk, availabilityOk])).is.equal(null);
-        expect(await AvailabilityHelper.some([availabilityOk, availabilityFail1])).is.equal(null);
-        expect(await AvailabilityHelper.some([availabilityFail1, availabilityOk])).is.equal(null);
-        expect((await AvailabilityHelper.some([availabilityFail1, availabilityFail2]))!.message).is.equal('Reason 1.');
-        expect((await AvailabilityHelper.some([availabilityFail2, availabilityFail1]))!.message).is.equal('Reason 2.');
-    });
-});

package/src/events/AvailabilityHelper.ts

@@ -1,28 +0,0 @@
-export type AvailabilityPromise = Promise<Error | null | void>;
-
-export default class AvailabilityHelper {
-
-    static async every(availabilityPromises: AvailabilityPromise[]): AvailabilityPromise {
-        for (const aPr of availabilityPromises) {
-            const error = await aPr;
-            if (error) {
-                return error;
-            }
-        }
-        return null;
-    }
-
-    static async some(availabilityPromises: AvailabilityPromise[]): AvailabilityPromise {
-        let firstError;
-        for (const aPr of availabilityPromises) {
-            const error = await aPr;
-            if (!error) {
-                return null;
-            } else if (!firstError) {
-                firstError = error;
-            }
-        }
-        return firstError || null;
-    }
-
-}

package/src/events/ProvidersLoggerOld.ts

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

package/src/events/Types.ts

@@ -1,18 +0,0 @@
-import { Attitude, UserPosition } from "@wemap/geo";
-import { Vector16_t, Vector3_t } from "@wemap/maths";
-
-export type Acceleration = Readonly<{ readonly timestamp: number; readonly values: Vector3_t; }>
-export type AngularRate = Readonly<{ readonly timestamp: number; readonly values: Vector3_t; }>
-export type HighRotation = Readonly<{ readonly timestamp: number; }>
-export type MagnetometerNeedCalibration = Readonly<{ readonly angle: number; }>
-export class RelativeAttitude extends Attitude { }
-export class AbsoluteAttitude extends Attitude { }
-export class AbsolutePosition extends UserPosition { }
-export type Inclination = number;
-export type Barcode = string;
-export type Step = { readonly size: number; readonly number: number; }
-export type Turn = { readonly timestamp: number; }
-export type StraightLine = boolean;
-export type CameraProjectionMatrix = Vector16_t;
-export type CameraNativeState = 'started' | 'stopped';
-