@neurosity/sdk/dist/esm/timesync/Timesync.js

Neurosity SDK

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { timer, pipe, range } from "rxjs";
import { map, concatWith, filter, take } from "rxjs/operators";
import { bufferCount, concatMap, switchMap } from "rxjs/operators";
import outliers from "outliers";
import { whileOnline } from "../utils/whileOnline";
const defaultOptions = {
    bufferSize: 100,
    updateInterval: 1 * 60 * 1000 // every minute
};
export class Timesync {
    constructor(options) {
        this._offset = 0;
        this.options = Object.assign(Object.assign({}, defaultOptions), options);
        this.start();
    }
    start() {
        const { bufferSize, updateInterval, status$ } = this.options;
        const burst$ = range(0, bufferSize);
        const timer$ = timer(updateInterval, updateInterval).pipe(map((i) => bufferSize + i), whileOnline({
            status$,
            allowWhileOnSleepMode: true
        }));
        const firstTimeDeviceIsOnline$ = status$.pipe(filter((status) => status.state === "online"), take(1));
        firstTimeDeviceIsOnline$
            .pipe(switchMap(() => {
            return burst$.pipe(concatWith(timer$), this.toOffset(), bufferCount(bufferSize, 1), this.filterOutliers(), map((list) => this.average(list)));
        }))
            .subscribe((offset) => {
            this._offset = offset;
        });
    }
    filterOutliers() {
        return pipe(map((offsets) => {
            return offsets.filter(outliers());
        }));
    }
    toOffset() {
        const { getTimesync } = this.options;
        return pipe(concatMap(() => __awaiter(this, void 0, void 0, function* () {
            const requestStartTime = Date.now();
            const [error, serverTime] = yield getTimesync()
                .then((offset) => [null, offset])
                .catch((error) => [error]);
            if (error) {
                return 0;
            }
            const responseEndTime = Date.now();
            const oneWayDuration = (responseEndTime - requestStartTime) / 2;
            const offset = responseEndTime - oneWayDuration - serverTime;
            return offset;
        })));
    }
    average(list) {
        return Math.round(list.reduce((acc, number) => acc + number) / list.length);
    }
    get offset() {
        return this._offset;
    }
    get timestamp() {
        return Date.now() + this._offset;
    }
}