@dronedeploy/rocos-js-sdk 2.6.1 → 3.0.0-alpha.20

package/services/MapService.d.ts

@@ -1,5 +1,6 @@
 import { IBaseService, IRocosSDKConfig, Map, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Observation } from '../models/maps/Panorama';
 /**
  * Integrations to retrieve data from the linked project in DroneDeploy
  */
@@ -17,24 +18,17 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
     /**
      * List maps from the robot and the cloud
      *
-     * if onlyRobot is true, only the maps from the robot will be returned
-     *
      * @param projectId Project ID
      * @param callsign Robot callsign
-     * @param options Options to filter the maps
      * @returns All maps in the cloud
      */
-    list(projectId: string, callsign: string, options?: {
-        onlyRobot: boolean;
-    }): Promise<Map[]>;
-    /**
-     * Creates a new DB for the project if it's missing
-     *
-     * has no effect if the DB already exists
+    list(projectId: string, callsign: string): Promise<Map[]>;
+    /** List maps to be deployed to a callsign
      *
-     * @param projectId Project ID
+     * @param projectId
+     * @param callsign
      */
-    initDB(projectId: string): Promise<void>;
+    listDeployedMaps(projectId: string, callsign: string): Promise<Map[]>;
     /**
      * Creates a new map by merging two existing maps
      * @param projectId Project ID
@@ -46,6 +40,12 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
         description?: string;
         callsign: string;
     }): Promise<void>;
+    /** Returns a map in its canonical form
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    get(projectId: string, mapId: string): Promise<Map>;
     /**
      * Updates a maps metadata
      * @param projectId Project ID
@@ -53,44 +53,90 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
      * @param options New metadata
      */
     update(projectId: string, mapId: string, options: {
-        name: string;
         description?: string;
         callsign?: string;
     }): Promise<void>;
     /**
-     * Copies a map from a robot to the cloud
-     *
-     * @see copyFromCloud
+     * Begins uploading a map from the agent
      *
      * @param projectId Project ID
      * @param mapId Map ID
      * @param callsign Robot callsign
+     * @param hash Map hash
      */
-    copyFromRobot(projectId: string, mapId: string, callsign: string): Promise<void>;
+    sendToCloud(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
     /**
-     * Deletes a map from the cloud
+     * Deletes a map from the cloud and all agents
      * @param projectId
      * @param mapId
      */
     delete(projectId: string, mapId: string): Promise<void>;
     /**
-     * Deletes a map from the cloud and attempts to delete it from the robot
+     * Deletes a map from a single agent.
+     *
+     * If the callsign does not have the map deployed, any local copy of the map will be deleted.
+     *
      * @param projectId
      * @param mapId
      * @param callsign
+     * @param hash
      */
-    delete(projectId: string, mapId: string, callsign: string): Promise<void>;
+    delete(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
     /**
-     * Makes a copy of a map stored in the cloud
-     *
-     * @see copyFromRobot
+     * Makes a copy of an uploaded map
      *
      * @param projectId Project ID
      * @param mapId Map ID
      * @param options Options to create the new map
      */
-    copyFromCloud(projectId: string, mapId: string, options: {
-        name: string;
+    copy(projectId: string, mapId: string, options: {
         description?: string;
     }): Promise<void>;
+    /** Deploy a map from the cloud to a robot
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     */
+    deploy(projectId: string, mapId: string, callsign: string): Promise<void>;
+    /** Get a GeoJSON representation of a map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param frameId Frame ID (optional)
+     */
+    getGeoJSON(projectId: string, mapId: string, frameId?: string): Promise<unknown>;
+    /**
+     * Returns a Promise that resolves to an array of Observation objects for the given panorama ID.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to retrieve observations for.
+     * @returns A Promise that resolves to an array of Observation objects.
+     */
+    listObservations(projectId: string, panoramaId: string): Promise<Observation[]>;
+    /**
+     * Creates new observations on a panorama.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to create observations for.
+     * @param observations An array of Observation objects to create.
+     * @returns A Promise that resolves when the observations have been created.
+     */
+    createObservations(projectId: string, panoramaId: string, observations: Observation[]): Promise<void>;
+    /**
+     * Gets observations for a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @param key (optional) Filters on a key defined on the observation
+     * @param frameID (optional) Transforms on a seed frame
+     * @returns A list of observations
+     */
+    getObservations(projectId: string, key?: string, frameID?: string): Promise<Observation[]>;
+    /**
+     * Lists available keys for all observations in a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @returns A list of observations
+     */
+    getObservationsKeys(projectId: string): Promise<string[]>;
 }

package/services/MapService.js

@@ -1,45 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapService = void 0;
-const api_1 = require("../constants/api");
-const models_1 = require("../models");
-const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+import { API_MAPS_COPY_URL, API_MAPS_DEPLOYED_URL, API_MAPS_DEPLOY_URL, API_MAPS_GEOJSON_URL, API_MAPS_MERGE_URL, API_MAPS_PANORAMA_OBSERVATIONS_URL, API_MAPS_URL, API_MAP_ID_URL, API_OBSERVATIONS_URL, API_OBSERVATION_KEYS_URL, } from '../constants/api';
+import { RocosError, errorCodes } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
 /**
  * Integrations to retrieve data from the linked project in DroneDeploy
  */
-class MapService extends BaseServiceAbstract_1.BaseServiceAbstract {
+export class MapService extends BaseServiceAbstract {
     constructor(config) {
         super(config);
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`MapService(${this.config.url})`);
+        this.logger = RocosLogger.getInstance(`MapService(${this.config.url})`);
     }
     getStatus() {
         return true;
     }
     getError(e) {
-        return new models_1.RocosError(e, models_1.errorCodes.MAPS_SERVICE_ERROR);
+        return new RocosError(e, errorCodes.MAPS_SERVICE_ERROR);
     }
-    async list(projectId, callsign, options) {
-        var _a;
-        const resp = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_MAPS_URL, {
+    async list(projectId, callsign) {
+        const resp = await this.callGet(formatServiceUrl(API_MAPS_URL, {
             url: this.config.url,
             projectId,
-        }, this.config.insecure), 'Failed to get maps.', callsign ? { callsign, onlyRobot: (_a = options === null || options === void 0 ? void 0 : options.onlyRobot) !== null && _a !== void 0 ? _a : false } : undefined);
+        }, this.config.insecure), 'Failed to get maps.', callsign ? { callsign } : undefined);
         return resp.maps;
     }
-    /**
-     * Creates a new DB for the project if it's missing
-     *
-     * has no effect if the DB already exists
+    /** List maps to be deployed to a callsign
      *
-     * @param projectId Project ID
+     * @param projectId
+     * @param callsign
      */
-    async initDB(projectId) {
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_MAPS_INIT_DB_URL, {
+    async listDeployedMaps(projectId, callsign) {
+        const safeCallsign = encodeURIComponent(callsign);
+        const resp = await this.callGet(formatServiceUrl(API_MAPS_DEPLOYED_URL, {
             url: this.config.url,
             projectId,
-        }, this.config.insecure), undefined, 'Failed to init DB.');
+            callsign: safeCallsign,
+        }, this.config.insecure), 'Failed to get deployed maps.');
+        return resp.maps;
     }
     /**
      * Creates a new map by merging two existing maps
@@ -58,11 +55,23 @@ class MapService extends BaseServiceAbstract_1.BaseServiceAbstract {
             description: options.description,
             callsign: options.callsign,
         };
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_MAPS_MERGE_URL, {
+        return this.callPost(formatServiceUrl(API_MAPS_MERGE_URL, {
             url: this.config.url,
             projectId,
         }, this.config.insecure), payload, 'Failed to merge maps.');
     }
+    /** Returns a map in its canonical form
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    async get(projectId, mapId) {
+        return this.callGet(formatServiceUrl(API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to get map.');
+    }
     /**
      * Updates a maps metadata
      * @param projectId Project ID
@@ -70,50 +79,114 @@ class MapService extends BaseServiceAbstract_1.BaseServiceAbstract {
      * @param options New metadata
      */
     async update(projectId, mapId, options) {
-        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_MAP_ID_URL, {
+        return this.callPut(formatServiceUrl(API_MAP_ID_URL, {
             url: this.config.url,
             projectId,
             mapId,
         }, this.config.insecure), options, 'Failed to update map.');
     }
     /**
-     * Copies a map from a robot to the cloud
-     *
-     * @see copyFromCloud
+     * Begins uploading a map from the agent
      *
      * @param projectId Project ID
      * @param mapId Map ID
      * @param callsign Robot callsign
+     * @param hash Map hash
      */
-    async copyFromRobot(projectId, mapId, callsign) {
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_MAP_ID_URL, {
+    async sendToCloud(projectId, mapId, callsign, hash) {
+        return this.callPost(formatServiceUrl(API_MAP_ID_URL, {
             url: this.config.url,
             projectId,
             mapId,
-        }, this.config.insecure), { callsign }, 'Failed to copy map from robot.');
+        }, this.config.insecure), { callsign, hash }, 'Failed to start map upload.');
     }
-    async delete(projectId, mapId, callsign) {
-        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_MAP_ID_URL, {
+    async delete(projectId, mapId, callsign, hash) {
+        return this.callDelete(formatServiceUrl(API_MAP_ID_URL, {
             url: this.config.url,
             projectId,
             mapId,
-        }, this.config.insecure), 'Failed to delete map.', callsign ? { callsign } : {});
+        }, this.config.insecure), 'Failed to delete map.', callsign ? { callsign, hash } : {});
     }
     /**
-     * Makes a copy of a map stored in the cloud
-     *
-     * @see copyFromRobot
+     * Makes a copy of an uploaded map
      *
      * @param projectId Project ID
      * @param mapId Map ID
      * @param options Options to create the new map
      */
-    async copyFromCloud(projectId, mapId, options) {
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_MAPS_COPY_URL, {
+    async copy(projectId, mapId, options) {
+        return this.callPost(formatServiceUrl(API_MAPS_COPY_URL, {
             url: this.config.url,
             projectId,
             mapId,
         }, this.config.insecure), options, 'Failed to copy map.');
     }
+    /** Deploy a map from the cloud to a robot
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     */
+    async deploy(projectId, mapId, callsign) {
+        return this.callPost(formatServiceUrl(API_MAPS_DEPLOY_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), { callsign }, 'Failed to deploy map.');
+    }
+    /** Get a GeoJSON representation of a map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param frameId Frame ID (optional)
+     */
+    async getGeoJSON(projectId, mapId, frameId) {
+        const params = {
+            url: this.config.url,
+            projectId,
+            mapId,
+        };
+        return this.callGet(formatServiceUrl(API_MAPS_GEOJSON_URL, params, this.config.insecure), 'Failed to get map GeoJSON.', frameId ? { frameID: frameId } : undefined);
+    }
+    /**
+     * Returns a Promise that resolves to an array of Observation objects for the given panorama ID.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to retrieve observations for.
+     * @returns A Promise that resolves to an array of Observation objects.
+     */
+    listObservations(projectId, panoramaId) {
+        return this.callGet(formatServiceUrl(API_MAPS_PANORAMA_OBSERVATIONS_URL, { url: this.config.url, projectId, panoramaId }, this.config.insecure), 'Failed to list observations.');
+    }
+    /**
+     * Creates new observations on a panorama.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to create observations for.
+     * @param observations An array of Observation objects to create.
+     * @returns A Promise that resolves when the observations have been created.
+     */
+    createObservations(projectId, panoramaId, observations) {
+        return this.callPut(formatServiceUrl(API_MAPS_PANORAMA_OBSERVATIONS_URL, { url: this.config.url, projectId, panoramaId }, this.config.insecure), observations, 'Failed to update observations.');
+    }
+    /**
+     * Gets observations for a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @param key (optional) Filters on a key defined on the observation
+     * @param frameID (optional) Transforms on a seed frame
+     * @returns A list of observations
+     */
+    getObservations(projectId, key = '', frameID = '') {
+        return this.callGet(formatServiceUrl(API_OBSERVATIONS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get observations.', { key, frameID });
+    }
+    /**
+     * Lists available keys for all observations in a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @returns A list of observations
+     */
+    getObservationsKeys(projectId) {
+        return this.callGet(formatServiceUrl(API_OBSERVATION_KEYS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get observation keys.');
+    }
 }
-exports.MapService = MapService;

package/services/PlatformTimeService.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatFormTimeService = void 0;
-const RocosLogger_1 = require("../logger/RocosLogger");
-const standardDeviation_1 = require("../helpers/standardDeviation");
+import { RocosLogger } from '../logger/RocosLogger';
+import { standardDeviation } from '../helpers/standardDeviation';
 const NUMBER_OF_SERVER_TIME_USED_TO_CALIBRATE = 5;
 const MAX_CLIENT_WAITING_TIME_STANDARD_DEVIATION_ALLOWED = 100; // 100 miliseconds
 const KEY_GR_PLATFORM_TIME_OFFSET = 'gr_platformTimeOffset';
 const KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT = 'gr_lastPlatformTimeSyncedAt';
 const GR_PLATFORM_TIME_TTL = 30 * 60 * 1000; // 30 minutes
-class PlatFormTimeService {
+export class PlatFormTimeService {
     // Make this a singleton, so that we don't have multi platform time
     constructor(timeSyncerService) {
         this.backoffTimeouts = [5 * 1000, 30 * 1000, 60 * 1000, 300 * 1000]; // in miliseconds
@@ -16,8 +13,8 @@ class PlatFormTimeService {
         this.backoffFailCount = 0;
         this.serverTimeOffset = 0;
         this.lastPlatformTimeSyncedAt = 0;
-        this.logger = RocosLogger_1.RocosLogger.getInstance('PlatformTimeService');
-        if (window === null || window === void 0 ? void 0 : window.localStorage) {
+        this.logger = RocosLogger.getInstance('PlatformTimeService');
+        if (window?.localStorage) {
             this.lastPlatformTimeSyncedAt = Number(window.localStorage.getItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT)) || 0;
             this.serverTimeOffset = Number(window.localStorage.getItem(KEY_GR_PLATFORM_TIME_OFFSET)) || 0;
         }
@@ -101,7 +98,7 @@ class PlatFormTimeService {
         }, delay);
     }
     isReliableServerTime(platformTimeMeasurements) {
-        const stdDeviation = standardDeviation_1.standardDeviation(
+        const stdDeviation = standardDeviation(
         // get the standardDeviation of the client waiting time
         platformTimeMeasurements.map((x) => x.clientTimeStampEnd - x.clientTimeStampStart));
         this.logger.debug('standard deviation', stdDeviation);
@@ -117,7 +114,7 @@ class PlatFormTimeService {
     calculateOffset(platformTimeMeasurements) {
         //  Timestamp when Received the Response - Time Request Duration / 2 - Timestamp within the Response .
         let totalServerTimeOffset = 0;
-        const measurementsWithValues = platformTimeMeasurements.filter((x) => !!(x === null || x === void 0 ? void 0 : x.serverTime));
+        const measurementsWithValues = platformTimeMeasurements.filter((x) => !!x?.serverTime);
         measurementsWithValues.forEach((x) => {
             // eslint-disable-next-line operator-linebreak
             totalServerTimeOffset +=
@@ -132,7 +129,7 @@ class PlatFormTimeService {
         this.isSyncing = false;
         this.serverTimeOffset = timeOffset;
         this.lastPlatformTimeSyncedAt = Date.now();
-        if (window === null || window === void 0 ? void 0 : window.localStorage) {
+        if (window?.localStorage) {
             window.localStorage.setItem(KEY_GR_PLATFORM_TIME_OFFSET, String(this.serverTimeOffset));
             window.localStorage.setItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT, String(this.lastPlatformTimeSyncedAt));
         }
@@ -157,4 +154,3 @@ class PlatFormTimeService {
         return this.timeSyncerService.getServerTime();
     }
 }
-exports.PlatFormTimeService = PlatFormTimeService;

package/services/PlatformTimeService.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/services/PlatformTimeService.spec.js

@@ -0,0 +1,180 @@
+import { PlatFormTimeService } from "./PlatformTimeService";
+import { TimeSyncerService } from "./TimeSyncerService";
+import { standardDeviation } from "../helpers";
+// Subclass PlatformTimeService so that we can test the protected methods
+class PlatformtimeServicePublic extends PlatFormTimeService {
+    constructor(timeSyncerService) {
+        super(timeSyncerService);
+    }
+    isReliableServerTime(platformTimeMeasurement) {
+        return super.isReliableServerTime(platformTimeMeasurement);
+    }
+    calculateOffset(platformTimeMeasurement) {
+        return super.calculateOffset(platformTimeMeasurement);
+    }
+    removeLongestAndShortest(platformTimeMeasurement) {
+        return super.removeLongestAndShortest(platformTimeMeasurement);
+    }
+    static getInstance(timeSyncerService) {
+        const instance = super.getInstance(timeSyncerService);
+        return instance;
+    }
+}
+describe('platformTimeService', () => {
+    it('should calculate standard deviation correctly', () => {
+        let numbers = [10, 12, 23, 23, 16, 23, 21, 16];
+        let stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 4.8989794855664)).toBeLessThan(0.000001);
+        numbers = [100, 12, 23, 23, 116, 23, 21, 162];
+        stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 53.702886328394)).toBeLessThan(0.000001);
+    });
+    it('should be able to tell reliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 20,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        mocks.push(mock);
+        let isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 4; i++) {
+            mocks.push({ ...mock });
+            isReliableServerTime = p.isReliableServerTime(mocks);
+            expect(isReliableServerTime).toBeTruthy();
+        }
+    });
+    it('should be able to tell unreliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let isReliableServerTime = false;
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 60;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 70;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 80;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        // std dev = 113.13708498985
+        expect(isReliableServerTime).toBeFalsy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 100;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeFalsy();
+    });
+    it('should be able to remove shortest and longest correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 100;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 300;
+        mocks.push(mockClone);
+        const platformTimeMeasurement = p.removeLongestAndShortest(mocks);
+        platformTimeMeasurement.forEach((p) => {
+            expect(p.clientTimeStampEnd).not.toEqual(100);
+            expect(p.clientTimeStampEnd).not.toEqual(500);
+        });
+    });
+    it('should be able to calculate the offset correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (200-(200)/2 + 500 - (500)/2 + 400 - (400)/2)/3 = 183.333333333, round to 183
+        expect(offset).toEqual(183);
+    });
+    it('should be able to filter where service time is not provided', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mockClone.serverTime = undefined;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (500 - (500)/2 + 400 - (400)/2)/2 = 225
+        expect(offset).toEqual(225);
+    });
+});