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

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 {};

package/esm/helpers/websandbox/frame/worker/manager.spec.js

@@ -1,127 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import WorkerManager from './manager';
-const WorkerMocks = {
-    postMessage: jest.fn(),
-    terminate: jest.fn(),
-    addEventListener: jest.fn(),
-    removeEventListener: jest.fn(),
-    onerror: jest.fn(),
-    onmessage: jest.fn(),
-    onmessageerror: jest.fn(),
-    dispatchEvent: jest.fn(),
-    clearAllMocks() {
-        this.postMessage.mockClear();
-        this.terminate.mockClear();
-        this.addEventListener.mockClear();
-        this.removeEventListener.mockClear();
-        this.onerror.mockClear();
-        this.onmessage.mockClear();
-        this.onmessageerror.mockClear();
-        this.dispatchEvent.mockClear();
-    },
-};
-class MockWorkerClass {
-    constructor() {
-        this.postMessage = WorkerMocks.postMessage;
-        this.terminate = WorkerMocks.terminate;
-        this.addEventListener = WorkerMocks.addEventListener;
-        this.removeEventListener = WorkerMocks.removeEventListener;
-        this.onerror = WorkerMocks.onerror;
-        this.onmessage = WorkerMocks.onmessage;
-        this.onmessageerror = WorkerMocks.onmessageerror;
-        this.dispatchEvent = WorkerMocks.dispatchEvent;
-    }
-}
-Object.defineProperty(window, 'Worker', {
-    value: MockWorkerClass,
-    writable: true,
-});
-Object.defineProperty(window, 'URL', {
-    value: {
-        createObjectURL: jest.fn(),
-    },
-});
-// add mock to AbortSignal.timeout
-Object.defineProperty(AbortSignal, 'timeout', {
-    value: jest.fn().mockImplementation((timeout) => {
-        return new AbortController().signal;
-    }),
-});
-const task = {
-    id: 'test',
-    code: '1',
-    timeout: 1000,
-};
-const response = {
-    data: {
-        id: 'test',
-        success: true,
-        result: 'test',
-    },
-};
-describe('WorkerManager', () => {
-    beforeEach(() => {
-        WorkerMocks.clearAllMocks();
-    });
-    it('should send a task to the worker', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.postMessage.mockImplementation((msg) => {
-            listeners.forEach((listener) => {
-                listener(response);
-            });
-        });
-        const manager = new WorkerManager();
-        const result = await manager.execute(task);
-        expect(result).toEqual('test');
-    });
-    it('should handle listener for a single task', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.removeEventListener.mockImplementation((_, listener) => {
-            const index = listeners.indexOf(listener);
-            listeners.splice(index, 1);
-        });
-        const manager = new WorkerManager();
-        expect(listeners.length).toEqual(0);
-        const result = manager.execute(task);
-        expect(listeners.length).toEqual(1);
-        listeners[0](response);
-        await result;
-        expect(listeners.length).toEqual(0);
-    });
-    it('should handle listener for multiple simultaneous task', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.removeEventListener.mockImplementation((_, listener) => {
-            const index = listeners.indexOf(listener);
-            listeners.splice(index, 1);
-        });
-        const manager = new WorkerManager();
-        expect(listeners.length).toEqual(0);
-        const result1 = manager.execute(task);
-        const result2 = manager.execute(task);
-        expect(listeners.length).toEqual(2);
-        const result3 = manager.execute(task);
-        expect(listeners.length).toEqual(3);
-        const [listener1, listener2, listener3] = listeners;
-        listener1(response);
-        await result1;
-        expect(listeners.length).toEqual(2);
-        listener3(response);
-        await result3;
-        expect(listeners.length).toEqual(1);
-        listener2(response);
-        await result2;
-        expect(listeners.length).toEqual(0);
-        expect(WorkerMocks.removeEventListener).toHaveBeenCalledTimes(3);
-    });
-});

package/esm/models/CallsignStatus.d.ts

@@ -1,6 +0,0 @@
-export declare enum CallsignStatus {
-    UNKNOWN = "unknown",
-    ONLINE = "online",
-    OFFLINE = "offline",
-    ERROR = "error"
-}

package/esm/models/CallsignStatus.js

@@ -1,7 +0,0 @@
-export var CallsignStatus;
-(function (CallsignStatus) {
-    CallsignStatus["UNKNOWN"] = "unknown";
-    CallsignStatus["ONLINE"] = "online";
-    CallsignStatus["OFFLINE"] = "offline";
-    CallsignStatus["ERROR"] = "error";
-})(CallsignStatus || (CallsignStatus = {}));

package/esm/models/ExternalProject.d.ts

@@ -1,6 +0,0 @@
-export declare class ExternalProject {
-    id?: string;
-    name?: string;
-    createdAt?: number;
-    isLinked?: boolean;
-}

package/esm/models/ExternalProject.js

@@ -1,2 +0,0 @@
-export class ExternalProject {
-}

package/esm/models/Token.spec.d.ts

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

package/esm/models/Token.spec.js

@@ -1,108 +0,0 @@
-import { Token } from './Token';
-const generateToken = (config) => {
-    const defaultPayload = {
-        iat: 1234567890,
-        exp: 9876543210,
-        iss: 'myissuer',
-        aud: 'myaudience',
-        sub: 'mysubject',
-    };
-    const encodedHeader = Buffer.from(JSON.stringify(config?.header ?? { alg: 'HS256', typ: 'JWT' })).toString('base64');
-    const encodedPayload = Buffer.from(JSON.stringify(config?.payload ?? defaultPayload)).toString('base64');
-    if (config?.signature === null) {
-        return `${encodedHeader}.${encodedPayload}`;
-    }
-    return `${encodedHeader}.${encodedPayload}.${config?.signature ?? 'signature'}`;
-};
-describe('Token', () => {
-    describe('constructor', () => {
-        it('can get information from a valid token', () => {
-            const token = new Token(generateToken());
-            expect(token.issuedAt).toEqual(new Date(1234567890000));
-            expect(token.expires).toEqual(new Date(9876543210000));
-            expect(token.issuer).toEqual('myissuer');
-            expect(token.audience).toEqual('myaudience');
-            expect(token.subject).toEqual('mysubject');
-        });
-        it('should throw an error for a non-jwt', () => {
-            // completely invalid string
-            expect(() => new Token('not a jwt')).toThrowError('Invalid token');
-            // invalid header
-            expect(() => {
-                new Token(generateToken({
-                    header: {
-                        alg: 'HS256',
-                        typ: 'Not-a-JWT',
-                    },
-                }));
-            }).toThrowError('Invalid token');
-            // too many parts
-            expect(() => {
-                new Token('a.b.c.d');
-            }).toThrowError('Invalid token');
-        });
-        it('should allow a token with no signature', () => {
-            const token = new Token(generateToken({ signature: null }));
-            expect(token.issuedAt).toEqual(new Date(1234567890000));
-            expect(token.expires).toEqual(new Date(9876543210000));
-            expect(token.issuer).toEqual('myissuer');
-            expect(token.audience).toEqual('myaudience');
-            expect(token.subject).toEqual('mysubject');
-        });
-    });
-    describe('isExpired', () => {
-        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        afterEach(() => {
-            jest.useRealTimers();
-        });
-        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
-        const notExpiredDate = (baseDate.getTime() + 1000 * 60 * 60 * 24) / 1000; // 1 day from now
-        it('should return true if the token is expired', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredDate } }));
-            expect(token.isExpired()).toEqual(true);
-        });
-        it('should return false if the token is not expired', () => {
-            const token = new Token(generateToken({ payload: { exp: notExpiredDate } }));
-            expect(token.isExpired()).toEqual(false);
-        });
-    });
-    describe('isExpiredIn', () => {
-        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        afterEach(() => {
-            jest.useRealTimers();
-        });
-        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
-        const expiredIn5MinsDate = (baseDate.getTime() + 1000 * 60 * 5) / 1000; // 5 minutes from now
-        const expiredIn25MinsDate = (baseDate.getTime() + 1000 * 60 * 25) / 1000; // 25 minutes from now
-        const expiredIn2HoursDate = (baseDate.getTime() + 1000 * 60 * 60 * 2) / 1000; // 2 hours from now
-        it('should return true if the token is expired in the given time', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
-            expect(token.isExpiredIn(5, 'minutes')).toEqual(true);
-            expect(token.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token.isExpiredIn(2, 'hours')).toEqual(true);
-            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
-            expect(token2.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token2.isExpiredIn(2, 'hours')).toEqual(true);
-            const token3 = new Token(generateToken({ payload: { exp: expiredDate } }));
-            expect(token3.isExpiredIn(5, 'minutes')).toEqual(true);
-            expect(token3.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token3.isExpiredIn(2, 'hours')).toEqual(true);
-        });
-        it('should return false if the token is not expired in the given time', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
-            expect(token.isExpiredIn(4, 'minutes')).toEqual(false);
-            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
-            expect(token2.isExpiredIn(24, 'minutes')).toEqual(false);
-            const token3 = new Token(generateToken({ payload: { exp: expiredIn2HoursDate } }));
-            expect(token3.isExpiredIn(1, 'hours')).toEqual(false);
-        });
-    });
-});

package/esm/models/asset-storage/AssetModelItem.js

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

package/esm/services/AuthService.spec.d.ts

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