@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.20

package/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/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/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/helpers/getUniqueConfigKey.d.ts

@@ -1,7 +0,0 @@
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
-/**
- * Flattens and orders the sdk config props to make a unique key
- *
- * @param config - SDK config {@link IRocosSDKConfig}
- */
-export declare const getUniqueConfigKey: (config: IRocosSDKConfig) => string;

package/helpers/getUniqueConfigKey.js

@@ -1,14 +0,0 @@
-/**
- * Flattens and orders the sdk config props to make a unique key
- *
- * @param config - SDK config {@link IRocosSDKConfig}
- */
-export const getUniqueConfigKey = (config) => {
-    return Object.keys(config)
-        .sort()
-        .map((item) => {
-        return item !== 'token' ? `${item}:${config[item]}` : false;
-    })
-        .filter(Boolean)
-        .join();
-};

package/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/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/helpers/websandbox/connection.d.ts

@@ -1,67 +0,0 @@
-import { APIDeclaration } from './types';
-export interface ConnectionOptions {
-    allowedSenderOrigin?: string;
-    debugMode: boolean;
-}
-type ListenerCallback = (e: MessageEvent<Message>) => void;
-declare enum MessageType {
-    RESPONSE = "response",
-    MESSAGE = "message"
-}
-interface BaseMessageData {
-    type: MessageType;
-    callId: string;
-}
-interface ResponseData extends BaseMessageData {
-    type: MessageType.RESPONSE;
-    success: boolean;
-    result: unknown;
-}
-interface MessageData extends BaseMessageData {
-    type: MessageType.MESSAGE;
-    methodName: string;
-    arguments: unknown[];
-}
-type Message = MessageData | ResponseData;
-export default class Connection<Local extends APIDeclaration<Local>, Remote extends APIDeclaration<Remote>> {
-    private readonly name;
-    private incrementalID;
-    private readonly options;
-    private readonly postMessageInternal;
-    private callbacks;
-    private serviceMethods;
-    constructor(name: string, postMessage: typeof window.postMessage, methods: Local, registerOnMessageListener: (listener: ListenerCallback) => void, options?: Partial<ConnectionOptions>);
-    /** Call a remote method
-     *
-     * returns a promise that resolves when the remote responds
-     *
-     * @param name - name of remote method to call
-     * @param args - arguments to pass to remote method
-     */
-    callRemoteMethod<Method extends keyof Remote>(name: Method, ...args: Parameters<Remote[Method]>): Promise<ReturnType<Remote[Method]>>;
-    private onMessageListener;
-    private callLocalMethod;
-    /** Respond to remote call
-     *
-     * @param id - remote call ID
-     * @param result - result to pass to calling function
-     * @param success - whether the call was successful
-     */
-    private responseOtherSide;
-    /** Store a callback to be called when the remote responds
-     *
-     * @param success - callback to be called on success
-     * @param failure - callback to be called on failure
-     */
-    private registerCallback;
-    /** Calls and deletes stored callback
-     *
-     * @param callId - ID of callback to call
-     * @param success - whether the call was successful
-     * @param result - result of remote call
-     */
-    private popCallback;
-    private postMessage;
-    private log;
-}
-export {};

package/helpers/websandbox/connection.js

@@ -1,133 +0,0 @@
-var MessageType;
-(function (MessageType) {
-    MessageType["RESPONSE"] = "response";
-    MessageType["MESSAGE"] = "message";
-})(MessageType || (MessageType = {}));
-const defaultOptions = {
-    allowedSenderOrigin: undefined,
-    debugMode: false,
-};
-export default class Connection {
-    constructor(name, postMessage, methods, registerOnMessageListener, options = {}) {
-        this.callbacks = new Map();
-        this.serviceMethods = new Map();
-        this.name = name;
-        this.options = { ...defaultOptions, ...options };
-        this.log('Created connection w/ allowedOrigin:', this.options.allowedSenderOrigin);
-        this.serviceMethods = new Map(Object.entries(methods));
-        // Assign a random starting ID to this connection
-        const [id] = crypto.getRandomValues(new Uint32Array(1));
-        this.incrementalID = id;
-        this.postMessageInternal = postMessage;
-        registerOnMessageListener((e) => this.onMessageListener(e));
-    }
-    /** Call a remote method
-     *
-     * returns a promise that resolves when the remote responds
-     *
-     * @param name - name of remote method to call
-     * @param args - arguments to pass to remote method
-     */
-    callRemoteMethod(name, ...args) {
-        this.log('Calling Remote Method', {
-            name,
-            args,
-        });
-        return new Promise((resolve, reject) => {
-            const id = this.registerCallback(resolve, reject);
-            this.postMessage({
-                callId: id,
-                type: MessageType.MESSAGE,
-                methodName: name,
-                arguments: args,
-            });
-        });
-    }
-    onMessageListener(e) {
-        this.log('Received message', e);
-        const { data } = e;
-        const { allowedSenderOrigin } = this.options;
-        if (allowedSenderOrigin && e.origin !== allowedSenderOrigin) {
-            console.warn(`Received message from invalid origin: ${e.origin}`);
-        }
-        switch (data.type) {
-            case MessageType.RESPONSE:
-                this.popCallback(data.callId, data.success, data.result);
-                return;
-            case MessageType.MESSAGE:
-                this.callLocalMethod(data.methodName, data.arguments)
-                    .then((res) => this.responseOtherSide(data.callId, res))
-                    .catch((err) => this.responseOtherSide(data.callId, err, false));
-        }
-    }
-    async callLocalMethod(methodName, args) {
-        this.log('calling local method', methodName, args);
-        const method = this.serviceMethods.get(methodName);
-        if (!method) {
-            throw new Error(`service method ${methodName} not found`);
-        }
-        return method(...args);
-    }
-    /** Respond to remote call
-     *
-     * @param id - remote call ID
-     * @param result - result to pass to calling function
-     * @param success - whether the call was successful
-     */
-    responseOtherSide(id, result, success = true) {
-        this.log('responding to remote call', { id, result, success });
-        const doPost = (result) => {
-            this.postMessage({
-                callId: id,
-                type: MessageType.RESPONSE,
-                success,
-                result,
-            });
-        };
-        try {
-            doPost(result);
-        }
-        catch (err) {
-            if (err instanceof DOMException) {
-                doPost(JSON.parse(JSON.stringify(result)));
-            }
-        }
-    }
-    /** Store a callback to be called when the remote responds
-     *
-     * @param success - callback to be called on success
-     * @param failure - callback to be called on failure
-     */
-    registerCallback(success, failure) {
-        const id = (++this.incrementalID).toString();
-        this.log('registering callback for id', id);
-        this.callbacks.set(id, { success, failure });
-        return id;
-    }
-    /** Calls and deletes stored callback
-     *
-     * @param callId - ID of callback to call
-     * @param success - whether the call was successful
-     * @param result - result of remote call
-     */
-    popCallback(callId, success, result) {
-        this.log('calling callback for id', callId, { success, result });
-        const callbacks = this.callbacks.get(callId);
-        if (success) {
-            callbacks?.success(result);
-        }
-        else {
-            callbacks?.failure(result);
-        }
-        this.callbacks.delete(callId);
-    }
-    postMessage(data, targetOrigin = '*') {
-        this.log('sending message', { data, targetOrigin });
-        this.postMessageInternal(data, targetOrigin);
-    }
-    log(...args) {
-        if (this.options.debugMode) {
-            console.debug(`[${this.name}]`, ...args);
-        }
-    }
-}

package/helpers/websandbox/frame/frame.js

@@ -1,22 +0,0 @@
-// this file is bundled via webpack and included in the iframe source
-import Connection from '../connection';
-import WorkerManager from './worker';
-class Frame {
-    constructor() {
-        const isDebugMode = !!window?.debugMode;
-        this.connection = new Connection('FRAME', window.parent.postMessage.bind(window.parent), {
-            startTask: this.runCode.bind(this),
-        }, (listener) => {
-            window.addEventListener('message', listener);
-        }, {
-            debugMode: isDebugMode,
-        });
-        void this.connection.callRemoteMethod('iframeInitialised');
-        this.workerManager = new WorkerManager();
-    }
-    async runCode(task) {
-        return this.workerManager.execute(task);
-    }
-}
-const frame = new Frame();
-export default frame;

package/helpers/websandbox/frame/frame.source.js

@@ -1,5 +0,0 @@
-// Auto-generated file
-/* eslint-disable */
-import __WORKER_SOURCE__ from './worker/worker.source';
-const source = `(()=>{"use strict";var e={880:(e,t)=>{var s;Object.defineProperty(t,"__esModule",{value:!0}),function(e){e.RESPONSE="response",e.MESSAGE="message"}(s||(s={}));const r={allowedSenderOrigin:void 0,debugMode:!1};t.default=class{constructor(e,t,s,i,o={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...r,...o},this.log("Created connection w/ allowedOrigin:",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(s));const[n]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=n,this.postMessageInternal=t,i((e=>this.onMessageListener(e)))}callRemoteMethod(e,...t){return this.log("Calling Remote Method",{name:e,args:t}),new Promise(((r,i)=>{const o=this.registerCallback(r,i);this.postMessage({callId:o,type:s.MESSAGE,methodName:e,arguments:t})}))}onMessageListener(e){this.log("Received message",e);const{data:t}=e,{allowedSenderOrigin:r}=this.options;switch(r&&e.origin!==r&&console.warn(\`Received message from invalid origin: \${e.origin}\`),t.type){case s.RESPONSE:return void this.popCallback(t.callId,t.success,t.result);case s.MESSAGE:this.callLocalMethod(t.methodName,t.arguments).then((e=>this.responseOtherSide(t.callId,e))).catch((e=>this.responseOtherSide(t.callId,e,!1)))}}async callLocalMethod(e,t){this.log("calling local method",e,t);const s=this.serviceMethods.get(e);if(!s)throw new Error(\`service method \${e} not found\`);return s(...t)}responseOtherSide(e,t,r=!0){this.log("responding to remote call",{id:e,result:t,success:r});const i=t=>{this.postMessage({callId:e,type:s.RESPONSE,success:r,result:t})};try{i(t)}catch(e){e instanceof DOMException&&i(JSON.parse(JSON.stringify(t)))}}registerCallback(e,t){const s=(++this.incrementalID).toString();return this.log("registering callback for id",s),this.callbacks.set(s,{success:e,failure:t}),s}popCallback(e,t,s){this.log("calling callback for id",e,{success:t,result:s});const r=this.callbacks.get(e);t?r?.success(s):r?.failure(s),this.callbacks.delete(e)}postMessage(e,t="*"){this.log("sending message",{data:e,targetOrigin:t}),this.postMessageInternal(e,t)}log(...e){this.options.debugMode&&console.debug(\`[\${this.name}]\`,...e)}}},306:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(880)),o=r(s(54)),n=new class{constructor(){const e=!!window?.debugMode;this.connection=new i.default("FRAME",window.parent.postMessage.bind(window.parent),{startTask:this.runCode.bind(this)},(e=>{window.addEventListener("message",e)}),{debugMode:e}),this.connection.callRemoteMethod("iframeInitialised"),this.workerManager=new o.default}async runCode(e){return this.workerManager.execute(e)}};t.default=n},54:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(420));t.default=i.default},420:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.default=class{constructor(){this.messageListeners=new Map,this.worker=this.createWorker()}async execute(e){const t={...e,contextVariable:e.contextVariable??"ctx"},s=this.runTask(t);let r;const i=new Promise(((t,s)=>{r=setTimeout((()=>{console.warn("sandbox level timeout exceeded, destroying and rebuilding"),this.terminate(),s(new Error("maximum execution time exceeded"))}),e.timeout)}));return Promise.race([s,i]).finally((()=>{this.removeMessageListener(e.id),clearTimeout(r)}))}terminate(){for(const e of this.messageListeners.values())this.worker.removeEventListener("message",e);this.worker.terminate(),this.worker=this.createWorker()}runTask(e){return new Promise(((t,s)=>{const r=r=>{const{data:i}=r;i.id===e.id&&(i.success?t(i.result):s(i.result))};this.messageListeners.set(e.id,r),this.worker.addEventListener("message",r),this.worker.postMessage(e)}))}createWorker(){const e=URL.createObjectURL(new Blob(["${__WORKER_SOURCE__.replace(/(['`"$])/g, '\\$1')}"],{type:"application/javascript"}));return new Worker(e)}removeMessageListener(e){const t=this.messageListeners.get(e);t&&this.worker.removeEventListener("message",t)}}}},t={};!function s(r){var i=t[r];if(void 0!==i)return i.exports;var o=t[r]={exports:{}};return e[r].call(o.exports,o,o.exports,s),o.exports}(306)})();`;
-export default source;

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

@@ -1,11 +0,0 @@
-import { Task } from '../../types';
-export default class Manager {
-    private worker;
-    private messageListeners;
-    constructor();
-    execute(task: Task): Promise<unknown>;
-    terminate(): void;
-    private runTask;
-    private createWorker;
-    private removeMessageListener;
-}

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

@@ -1,62 +0,0 @@
-// this token (__WORKER_SOURCE__) is replaced by webpack with the source of the worker
-const WORKER_SOURCE = '__WORKER_SOURCE__';
-export default class Manager {
-    constructor() {
-        this.messageListeners = new Map();
-        this.worker = this.createWorker();
-    }
-    async execute(task) {
-        const workerTask = {
-            ...task,
-            contextVariable: task.contextVariable ?? 'ctx',
-        };
-        const result = this.runTask(workerTask);
-        let timerId;
-        const timeout = new Promise((_, reject) => {
-            timerId = setTimeout(() => {
-                this.terminate();
-                reject(new Error('maximum execution time exceeded'));
-            }, task.timeout);
-        });
-        return Promise.race([result, timeout]).finally(() => {
-            this.removeMessageListener(task.id);
-            clearTimeout(timerId);
-        });
-    }
-    terminate() {
-        for (const listener of this.messageListeners.values()) {
-            this.worker.removeEventListener('message', listener);
-        }
-        this.worker.terminate();
-        this.worker = this.createWorker();
-    }
-    runTask(task) {
-        return new Promise((resolve, reject) => {
-            const listener = (event) => {
-                const { data } = event;
-                if (data.id === task.id) {
-                    if (data.success) {
-                        resolve(data.result);
-                    }
-                    else {
-                        reject(data.result);
-                    }
-                }
-            };
-            this.messageListeners.set(task.id, listener);
-            this.worker.addEventListener('message', listener);
-            this.worker.postMessage(task);
-        });
-    }
-    createWorker() {
-        const blob = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: 'application/javascript' }));
-        return new Worker(blob);
-    }
-    removeMessageListener(id) {
-        const listener = this.messageListeners.get(id);
-        if (!listener) {
-            return;
-        }
-        this.worker.removeEventListener('message', listener);
-    }
-}

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

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