@dronedeploy/rocos-js-sdk 3.0.1-alpha.9 → 3.0.1

package/cjs/services/RTPWebRTCService.spec.js

@@ -1,171 +0,0 @@
-"use strict";
-/**
- * @jest-environment jsdom
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const rxjs_1 = require("rxjs");
-const RTPWebRTCService_1 = require("./RTPWebRTCService");
-class WebRTCMockHelper {
-    constructor() {
-        this.dataChannel = {
-            label: 'submanager',
-            onopen: () => void 0,
-            onclose: () => void 0,
-            onmessage: (e) => void 0,
-            send: this.sendMessage.bind(this),
-            close: this.close.bind(this),
-        };
-        this.connection = {
-            ontrack: (event) => void 0,
-            oniceconnectionstatechange: () => void 0,
-            onicecandidate: async (event) => void 0,
-            setRemoteDescription: jest.fn(),
-            iceConnectionState: 'new',
-            localDescription: null,
-            createDataChannel: jest.fn().mockReturnValue(this.dataChannel),
-            addTransceiver: jest.fn(),
-            createOffer: this.createOffer.bind(this),
-            setLocalDescription: jest.fn(),
-            close: this.close.bind(this),
-        };
-        this.streams = [];
-    }
-    installMocks() {
-        ;
-        global.RTCPeerConnection = jest.fn().mockReturnValue(this.connection);
-        global.RTCSessionDescription = jest.fn();
-        this.mockFetch();
-    }
-    async createOffer() {
-        await this.connection.onicecandidate({
-            candidate: null,
-        });
-        this.connection.iceConnectionState = 'checking';
-        this.connection.oniceconnectionstatechange();
-        this.addTrack('my-stream-1');
-        this.addTrack('my-stream-2');
-        this.connection.iceConnectionState = 'connected';
-        this.connection.oniceconnectionstatechange();
-        this.dataChannel.onopen();
-        return {
-            sdp: 'my-sdp',
-            type: 'offer',
-        };
-    }
-    addTrack(name) {
-        const stream = { name, active: true };
-        this.streams.push(stream);
-        this.connection.ontrack({
-            streams: [stream],
-        });
-    }
-    close() {
-        this.streams.forEach((stream) => {
-            stream.active = false;
-        });
-        this.dataChannel.onclose();
-        this.connection.iceConnectionState = 'closed';
-        this.connection.oniceconnectionstatechange();
-    }
-    sendMessage(message) {
-        const { logLevel } = JSON.parse(message);
-        if (logLevel === 'trace') {
-            this.dataChannel.onmessage({
-                data: message,
-            });
-        }
-    }
-    mockFetch() {
-        global.fetch = jest.fn().mockImplementation((url) => {
-            switch (url) {
-                case 'https://localhost:0/sdp/configs':
-                    return Promise.resolve({
-                        json: () => ({
-                            iceServers: [
-                                {
-                                    urls: ['stun:turn.localhost:443'],
-                                },
-                            ],
-                        }),
-                    });
-                case 'https://localhost:0/sdp':
-                    return Promise.resolve({
-                        json: () => ({
-                            answer: btoa('null'),
-                        }),
-                    });
-                default:
-                    throw new Error(`Unexpected URL: ${url}`);
-            }
-        });
-    }
-}
-describe('RTPWebRTCService', () => {
-    let service;
-    beforeEach(() => {
-        service = new RTPWebRTCService_1.RTPWebRTCService({
-            url: 'localhost',
-            port: 0,
-            token: 'test',
-        });
-    });
-    describe('streams$', () => {
-        it('should emit a stream when a new stream is added', async () => {
-            // Arrange
-            new WebRTCMockHelper().installMocks();
-            const connection = service.createPeerConnection({
-                projectId: 'my-project',
-                callsign: 'my-callsign',
-                logLevel: 'trace',
-            });
-            // Act
-            const streams = await (0, rxjs_1.lastValueFrom)(connection.streams$.pipe((0, rxjs_1.takeUntil)(connection.connect()), (0, rxjs_1.toArray)()));
-            // Assert
-            expect(streams).toEqual([
-                [
-                    {
-                        name: 'my-stream-1',
-                        active: true,
-                    },
-                ],
-                [
-                    {
-                        name: 'my-stream-1',
-                        active: true,
-                    },
-                    {
-                        name: 'my-stream-2',
-                        active: true,
-                    },
-                ],
-            ]);
-        });
-        it('should reset the streams when the connection is disconnected and the streams become inactive', async () => {
-            // Arrange
-            new WebRTCMockHelper().installMocks();
-            const connection = service.createPeerConnection({
-                projectId: 'my-project',
-                callsign: 'my-callsign',
-                logLevel: 'trace',
-            });
-            // Act
-            const streams = await (0, rxjs_1.lastValueFrom)(connection.streams$.pipe((0, rxjs_1.takeUntil)((async () => {
-                await connection.connect();
-                connection.disconnect();
-                await connection.connect();
-            })()), (0, rxjs_1.toArray)()));
-            expect(streams).toEqual([
-                [{ name: 'my-stream-1', active: false }],
-                [
-                    { name: 'my-stream-1', active: false },
-                    { name: 'my-stream-2', active: false },
-                ],
-                [{ name: 'my-stream-1', active: true }],
-                [
-                    { name: 'my-stream-1', active: true },
-                    { name: 'my-stream-2', active: true },
-                ],
-            ]);
-        });
-    });
-});

package/cjs/services/TelemetryService.spec.d.ts

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

package/cjs/services/TelemetryService.spec.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const models_1 = require("../models");
-const rxjs_1 = require("rxjs");
-const TelemetryService_1 = require("./TelemetryService");
-describe('TelemetryService', () => {
-    describe('getRobotStatusChanges', () => {
-        it('should emit unknown to begin with', async () => {
-            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue(rxjs_1.NEVER);
-            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign').pipe((0, rxjs_1.take)(1)));
-            expect(lastValue).toEqual(models_1.CallsignStatus.UNKNOWN);
-        });
-        it('should emit online if the robot emits a heartbeat', async () => {
-            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest
-                .spyOn(service, 'subscribe')
-                .mockReturnValue((0, rxjs_1.from)([0, 1, 2, 3, 4]).pipe((0, rxjs_1.delay)(100)));
-            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 1000, 10).pipe((0, rxjs_1.take)(2)));
-            expect(lastValue).toEqual(models_1.CallsignStatus.ONLINE);
-        }, 10000);
-        it('should emit offline if the robot never emits', async () => {
-            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue(rxjs_1.NEVER);
-            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe((0, rxjs_1.take)(2)));
-            expect(lastValue).toEqual(models_1.CallsignStatus.OFFLINE);
-        });
-        it('should emit an error if the telemetry errors', async () => {
-            const service = new TelemetryService_1.TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue((0, rxjs_1.throwError)(() => new Error('test')));
-            const lastValue = await (0, rxjs_1.lastValueFrom)(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe((0, rxjs_1.take)(2)));
-            expect(lastValue).toEqual(models_1.CallsignStatus.ERROR);
-        });
-    });
-});

package/esm/helpers/cleanObject.spec.d.ts

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

package/esm/helpers/cleanObject.spec.js

@@ -1,53 +0,0 @@
-import { cleanObject } from "./cleanObject";
-describe('cleanObject', () => {
-    const testObject = {
-        test1: 'test1',
-        test2: 'test2',
-        test3: () => 'test3',
-        test4: {
-            test1: 'test1.1',
-            test5: 'test5',
-            test6: {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            test8: () => 'test8',
-        },
-        test9: ['test9.1', 'test9.2', () => 'test8'],
-        test10: [
-            {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            {
-                test8: () => 'test8',
-            },
-        ],
-    };
-    it('should clean object to values only', () => {
-        const newObject = cleanObject(testObject);
-        expect(newObject?.test3).toBeUndefined();
-        expect(newObject?.test4?.test8).toBeUndefined();
-        expect(newObject?.test4?.test6?.test8).toBeUndefined();
-        expect(newObject?.test4?.test5).toEqual('test5');
-        expect(newObject?.test5).toBeUndefined();
-        expect(newObject?.test4?.test6?.test1).toEqual('test1.2');
-        expect(newObject?.test4?.test6?.test2).toEqual('test2.1');
-        expect(newObject?.test1).toEqual('test1');
-        expect(newObject?.test2).toEqual('test2');
-        expect(newObject?.test9).toEqual(expect.arrayContaining(['test9.1', 'test9.2']));
-        expect(newObject?.test9).toEqual(expect.not.arrayContaining([() => 'test8']));
-        expect(newObject?.test10).toEqual(expect.arrayContaining([
-            {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-            },
-            {},
-        ]));
-    });
-});

package/esm/helpers/flattenObject.spec.d.ts

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

package/esm/helpers/flattenObject.spec.js

@@ -1,29 +0,0 @@
-import { flattenObject } from './flattenObject';
-describe('flattenObject', () => {
-    const testObject = {
-        test1: 'test1',
-        test2: 'test2',
-        test3: () => 'test3',
-        test4: {
-            test1: 'test1.1',
-            test5: 'test5',
-            test6: {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            test8: () => 'test8',
-        },
-    };
-    it('should flatten object to a single level', () => {
-        const newObject = flattenObject(testObject);
-        expect(newObject?.test3).toBeUndefined();
-        expect(newObject?.test4?.test8).toBeUndefined();
-        expect(newObject?.test4?.test6?.test8).toBeUndefined();
-        expect(newObject?.test4?.test5).toBeUndefined();
-        expect(newObject?.test5).toEqual('test5');
-        expect(newObject?.test1).toEqual('test1.2');
-        expect(newObject?.test2).toEqual('test2.1');
-    });
-});

package/esm/helpers/flattenOneOf.spec.d.ts

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

package/esm/helpers/flattenOneOf.spec.js

@@ -1,157 +0,0 @@
-import { flattenOneOf, hasOneOfField } from './flattenOneOf';
-describe('flattenOneOf', () => {
-    describe('hasOneOfField', () => {
-        it('should return false for non-object', () => {
-            expect(hasOneOfField(null)).toBe(false);
-            expect(hasOneOfField(undefined)).toBe(false);
-            expect(hasOneOfField(1)).toBe(false);
-            expect(hasOneOfField('')).toBe(false);
-            expect(hasOneOfField(true)).toBe(false);
-        });
-        it('should return false for null content', () => {
-            expect(hasOneOfField({ content: null })).toBe(false);
-        });
-        it('should return false for non-object content', () => {
-            expect(hasOneOfField({ content: 1 })).toBe(false);
-            expect(hasOneOfField({ content: '' })).toBe(false);
-            expect(hasOneOfField({ content: true })).toBe(false);
-        });
-        it('should return false for non-string oneofKind', () => {
-            expect(hasOneOfField({ content: { oneofKind: 1 } })).toBe(false);
-            expect(hasOneOfField({ content: { oneofKind: null } })).toBe(false);
-            expect(hasOneOfField({ content: { oneofKind: true } })).toBe(false);
-            expect(hasOneOfField({ content: { oneofKind: {} } })).toBe(false);
-        });
-        it('should return true for valid oneOfField', () => {
-            expect(hasOneOfField({ content: { oneofKind: 'test' } })).toBe(true);
-        });
-    });
-    describe('flattenOneOf', () => {
-        it('should flatten a simple oneof type', () => {
-            const a = {
-                a: 'a',
-                content: {
-                    oneofKind: 'b',
-                    b: true,
-                },
-            };
-            expect(flattenOneOf(a)).toEqual({
-                a: 'a',
-                b: true,
-            });
-        });
-        it('should flatten a nested oneof type, one level only', () => {
-            const a = {
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                content: {
-                    oneofKind: 'd',
-                    d: {
-                        content: {
-                            oneofKind: 'e',
-                            e: 5,
-                        },
-                    },
-                },
-            };
-            expect(flattenOneOf(a)).toEqual({
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                d: {
-                    content: {
-                        oneofKind: 'e',
-                        e: 5,
-                    },
-                },
-            });
-        });
-        it('should flatten to undefined if the referenced property does not exist', () => {
-            const a = {
-                content: {
-                    oneofKind: 'b',
-                    c: true,
-                },
-            };
-            expect(flattenOneOf(a)).toEqual({
-                b: undefined,
-            });
-        });
-        it('should return the original object if it does not have a oneof field', () => {
-            const a = {
-                a: 'a',
-                b: 'b',
-            };
-            expect(flattenOneOf(a)).toEqual(a);
-        });
-    });
-    describe('flattenOneOf - deep', () => {
-        it('should flatten a simple oneof type', () => {
-            const a = {
-                a: 'a',
-                content: {
-                    oneofKind: 'b',
-                    b: {
-                        d: 4,
-                    },
-                },
-            };
-            expect(flattenOneOf(a, true)).toEqual({
-                a: 'a',
-                b: { d: 4 },
-            });
-        });
-        it('should flatten a nested oneof type, all levels', () => {
-            const a = {
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                content: {
-                    oneofKind: 'd',
-                    d: {
-                        content: {
-                            oneofKind: 'e',
-                            e: 5,
-                        },
-                    },
-                },
-            };
-            expect(flattenOneOf(a, true)).toEqual({
-                b: {
-                    c: true,
-                },
-                d: {
-                    e: 5,
-                },
-            });
-        });
-        it('should flatten to undefined if the referenced property does not exist', () => {
-            const a = {
-                content: {
-                    oneofKind: 'b',
-                    c: true,
-                },
-            };
-            expect(flattenOneOf(a, true)).toEqual({
-                b: undefined,
-            });
-        });
-        it('should return the original object if it does not have a oneof field', () => {
-            const a = {
-                a: 'a',
-                b: 'b',
-            };
-            expect(flattenOneOf(a, true)).toEqual(a);
-        });
-    });
-});

package/esm/helpers/formatServiceUrl.spec.d.ts

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

package/esm/helpers/formatServiceUrl.spec.js

@@ -1,16 +0,0 @@
-import { formatServiceUrl } from './formatServiceUrl';
-describe('formatServiceUrl', () => {
-    const url = 'https://{url}/admin/users/{test}/invitations';
-    it('should format url', () => {
-        let newUrl = formatServiceUrl(url, { url: 'test.com', test: 'me' });
-        expect(newUrl).toEqual('https://test.com/admin/users/me/invitations');
-        newUrl = formatServiceUrl(url, { url: 'test2.com', test: 'me2' });
-        expect(newUrl).toEqual('https://test2.com/admin/users/me2/invitations');
-    });
-    it('should format insecure url', () => {
-        let newUrl = formatServiceUrl(url, { url: 'test.com', test: 'me' }, true);
-        expect(newUrl).toEqual('http://test.com/admin/users/me/invitations');
-        newUrl = formatServiceUrl(url, { url: 'test2.com', test: 'me2' }, true);
-        expect(newUrl).toEqual('http://test2.com/admin/users/me2/invitations');
-    });
-});

package/esm/helpers/getSha256Hex.spec.d.ts

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

package/esm/helpers/getSha256Hex.spec.js

@@ -1,14 +0,0 @@
-import crypto from 'crypto';
-import { getSha256Hex } from './getSha256Hex';
-Object.defineProperty(globalThis, 'crypto', {
-    value: {
-        subtle: crypto.webcrypto.subtle,
-    },
-});
-describe('getSha256Hex', () => {
-    it('should return the correct SHA-256 hash', async () => {
-        const buffer = new TextEncoder().encode('Hello, World!');
-        const hash = await getSha256Hex(buffer);
-        expect(hash).toBe('dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f');
-    });
-});

package/esm/helpers/getSha256HexNode.spec.d.ts

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

package/esm/helpers/getSha256HexNode.spec.js

@@ -1,8 +0,0 @@
-import { getSha256HexNode } from './getSha256HexNode';
-describe('getSha256HexNode', () => {
-    it('should return the correct SHA-256 hash', async () => {
-        const buffer = new TextEncoder().encode('Hello, World!');
-        const hash = await getSha256HexNode(buffer);
-        expect(hash).toBe('dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f');
-    });
-});

package/esm/helpers/getURLSearchParams.spec.d.ts

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

package/esm/helpers/getURLSearchParams.spec.js

@@ -1,19 +0,0 @@
-import { getURLSearchParams } from './getURLSearchParams';
-describe('getURLSearchParams', () => {
-    it('Should return the original param if URLSearchParams', () => {
-        const param = new URLSearchParams();
-        const searchParam = getURLSearchParams(param);
-        expect(searchParam).toBe(param);
-    });
-    it('Should a new URLSearchParams ', () => {
-        const param = {
-            foo: 'bar',
-            bar: true,
-            foobar: 123,
-        };
-        const searchParam = getURLSearchParams(param);
-        expect(searchParam.get('foo')).toBe('bar');
-        expect(searchParam.get('bar')).toBe('true');
-        expect(searchParam.get('foobar')).toBe('123');
-    });
-});

package/esm/helpers/nanosecondToMillisecond.spec.d.ts

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

package/esm/helpers/nanosecondToMillisecond.spec.js

@@ -1,20 +0,0 @@
-import { nanosecondToMillisecond } from './nanosecondToMillisecond';
-describe('nanosecondToMillisecond', () => {
-    it.each `
-    input                    | expected
-    ${'0.0001'}              | ${0.0000000001}
-    ${'1'}                   | ${0.000001}
-    ${'1000000'}             | ${1}
-    ${'10000000'}            | ${10}
-    ${'-100000006'}           | ${-100.000006}
-    ${'1000000000000000000'} | ${1000000000000}
-    ${'1234567891011100001'} | ${1234567891011.100001}
-    ${'1234567891011100000'} | ${1234567891011.1}
-    ${0.0001}                | ${0.0000000001}
-    ${1}                     | ${0.000001}
-    ${1000000}               | ${1}
-    ${1000000000000001}      | ${1000000000.000001}
-  `('should convert $input to $expected', ({ input, expected }) => {
-        expect(nanosecondToMillisecond(input)).toBe(expected);
-    });
-});

package/esm/helpers/splitRobotTopic.spec.d.ts

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

package/esm/helpers/splitRobotTopic.spec.js

@@ -1,51 +0,0 @@
-import { splitRobotTopic } from './splitRobotTopic';
-describe('splitRobotTopic', () => {
-    it('should split a path with a single topic', () => {
-        expect(splitRobotTopic('/component/topic')).toEqual({
-            component: 'component',
-            topic: 'topic',
-        });
-    });
-    it('should split a path with multiple topics', () => {
-        expect(splitRobotTopic('/component/topic/with/multiple/topics')).toEqual({
-            component: 'component',
-            topic: 'topic/with/multiple/topics',
-        });
-    });
-    it('should split a path with no topics', () => {
-        expect(splitRobotTopic('/component')).toEqual({
-            component: 'component',
-            topic: '',
-        });
-    });
-    it('should split a path with no forward slash', () => {
-        expect(splitRobotTopic('component/topic')).toEqual({
-            component: 'component',
-            topic: 'topic',
-        });
-    });
-    it('should split a path with no forward slash and no topics', () => {
-        expect(splitRobotTopic('component')).toEqual({
-            component: 'component',
-            topic: '',
-        });
-    });
-    it('should split a path with no forward slash and multiple topics', () => {
-        expect(splitRobotTopic('component/topic/with/multiple/topics')).toEqual({
-            component: 'component',
-            topic: 'topic/with/multiple/topics',
-        });
-    });
-    it('should handle a path with multiple forward slashes', () => {
-        expect(splitRobotTopic('///component/topic/with/multiple/topics')).toEqual({
-            component: 'component',
-            topic: 'topic/with/multiple/topics',
-        });
-    });
-    it('should handle a path with multiple forward slashes and no topics', () => {
-        expect(splitRobotTopic('///component')).toEqual({
-            component: 'component',
-            topic: '',
-        });
-    });
-});

package/esm/helpers/standardDeviation.spec.d.ts

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

package/esm/helpers/standardDeviation.spec.js

@@ -1,11 +0,0 @@
-import { standardDeviation } from './standardDeviation';
-describe('standardDeviation', () => {
-    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);
-    });
-});

package/esm/helpers/websandbox/frame/worker/manager.spec.d.ts

@@ -1,4 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-export {};