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

package/helpers/getURLSearchParams.d.ts

@@ -0,0 +1,2 @@
+export type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
+export declare const getURLSearchParams: (params: QueryParams) => URLSearchParams;

package/helpers/getURLSearchParams.js

@@ -0,0 +1,9 @@
+export const getURLSearchParams = (params) => {
+    if (params instanceof URLSearchParams)
+        return params;
+    const stringParams = Object.entries(params ?? {}).reduce((acc, [key, value]) => {
+        acc[key] = value.toString();
+        return acc;
+    }, {});
+    return new URLSearchParams(stringParams);
+};

package/helpers/getURLSearchParams.spec.d.ts

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

package/helpers/getURLSearchParams.spec.js

@@ -0,0 +1,19 @@
+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/index.d.ts

@@ -1,3 +1,5 @@
 export * from './average';
 export * from './standardDeviation';
 export * from './generateUUID';
+export * from './getURLSearchParams';
+export * from './websandbox';

package/helpers/index.js

@@ -1,3 +1,5 @@
 export * from './average';
 export * from './standardDeviation';
 export * from './generateUUID';
+export * from './getURLSearchParams';
+export * from './websandbox';

package/helpers/websandbox/connection.d.ts

@@ -0,0 +1,72 @@
+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>);
+    /** Update the local methods available to the remote
+     *
+     * @param methods - methods to expose to the remote
+     */
+    defineMethods(methods: Local): void;
+    /** 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

@@ -0,0 +1,140 @@
+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));
+    }
+    /** Update the local methods available to the remote
+     *
+     * @param methods - methods to expose to the remote
+     */
+    defineMethods(methods) {
+        this.serviceMethods = new Map(Object.entries(methods));
+    }
+    /** 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.d.ts

@@ -0,0 +1,12 @@
+import { Task } from '../types';
+export interface FrameMethods {
+    startTask: (task: Task) => unknown;
+}
+declare class Frame {
+    private connection;
+    private workerManager;
+    constructor();
+    private runCode;
+}
+declare const frame: Frame;
+export default frame;

package/helpers/websandbox/frame/frame.js

@@ -0,0 +1,22 @@
+// 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.d.ts

@@ -0,0 +1,2 @@
+declare const source: string;
+export default source;

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

@@ -0,0 +1,4 @@
+// Auto-generated file
+/* eslint-disable */
+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,o,n={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...r,...n},this.log(\"Created connection w/ allowedOrigin:\",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(s));const[i]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=i,this.postMessageInternal=t,o((e=>this.onMessageListener(e)))}defineMethods(e){this.serviceMethods=new Map(Object.entries(e))}callRemoteMethod(e,...t){return this.log(\"Calling Remote Method\",{name:e,args:t}),new Promise(((r,o)=>{const n=this.registerCallback(r,o);this.postMessage({callId:n,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 o=t=>{this.postMessage({callId:e,type:s.RESPONSE,success:r,result:t})};try{o(t)}catch(e){e instanceof DOMException&&o(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 o=r(s(880)),n=r(s(54)),i=new class{constructor(){const e=!!window?.debugMode;this.connection=new o.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 n.default}async runCode(e){return this.workerManager.execute(e)}};t.default=i},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 o=r(s(420));t.default=o.default},420: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 o=r(s(967));t.default=class{constructor(){this.worker=this.createWorker()}async execute(e){const t={...e,contextVariable:e.contextVariable??\"ctx\"},s=this.runTask(t),r=this.timeout(e.timeout??1e3);return Promise.race([s,r]).finally((()=>{this.removeMessageListener()}))}terminate(){this.removeMessageListener(),this.worker.terminate(),this.worker=this.createWorker()}runTask(e){return new Promise(((t,s)=>{const r=r=>{const{data:o}=r;o.id===e.id&&(this.stopTimer(),o.success?t(o.result):s(o.result))};this.worker.addEventListener(\"message\",r),this.removeMessageListener=()=>this.worker.removeEventListener(\"message\",r),this.worker.postMessage(e)}))}timeout(e){return new Promise(((t,s)=>{this.timerId=window.setTimeout((()=>{this.terminate(),s(new Error(\"maximum execution time exceeded\"))}),e)}))}stopTimer(){clearTimeout(this.timerId)}createWorker(){const e=URL.createObjectURL(new Blob([o.default],{type:\"application/javascript\"}));return new Worker(e)}removeMessageListener(){}}},967:(e,t)=>{Object.defineProperty(t,\"__esModule\",{value:!0}),t.default='(()=>{\"use strict\";(()=>{const e=[\"TEMPORARY\",\"PERSISTENT\",\"console\",\"self\",\"onmessage\",\"postMessage\",\"global\",\"allowed\",\"Array\",\"Boolean\",\"Date\",\"Function\",\"Number\",\"Object\",\"RegExp\",\"String\",\"Error\",\"EvalError\",\"RangeError\",\"ReferenceError\",\"SyntaxError\",\"TypeError\",\"URIError\",\"decodeURI\",\"decodeURIComponent\",\"encodeURI\",\"encodeURIComponent\",\"isFinite\",\"isNaN\",\"parseFloat\",\"parseInt\",\"Infinity\",\"JSON\",\"Math\",\"NaN\",\"undefined\"];[...Object.getOwnPropertyNames(self),...Object.getOwnPropertyNames(self.__proto__)].forEach((r=>{e.includes(r)||Object.defineProperty(self,r,{get:()=>{throw new Error(`Security Exception: cannot access ${r}`)},set:()=>{throw new Error(`Security Exception: cannot set ${r}`)},configurable:!1})})),onmessage=e=>{let r,t=!0;try{r=Function(e.data.contextVariable,`\"use strict\";return (${e.data.code});`)(e.data.context)}catch(e){r=e,t=!1}const o={id:e.data.id,result:r,success:t};postMessage(o)}})()})();'}},t={};!function s(r){var o=t[r];if(void 0!==o)return o.exports;var n=t[r]={exports:{}};return e[r].call(n.exports,n,n.exports,s),n.exports}(306)})();";
+export default source;

package/helpers/websandbox/frame/index.d.ts

@@ -0,0 +1,2 @@
+import source from './frame.source';
+export default source;

package/helpers/websandbox/frame/index.js

@@ -0,0 +1,2 @@
+import source from './frame.source';
+export default source;

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

@@ -0,0 +1,2 @@
+import Manager from './manager';
+export default Manager;

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

@@ -0,0 +1,2 @@
+import Manager from './manager';
+export default Manager;

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

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

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

@@ -0,0 +1,59 @@
+import workerSource from './worker.source';
+export default class Manager {
+    constructor() {
+        this.worker = this.createWorker();
+    }
+    async execute(task) {
+        const workerTask = {
+            ...task,
+            contextVariable: task.contextVariable ?? 'ctx',
+        };
+        const result = this.runTask(workerTask);
+        const timeout = this.timeout(task.timeout ?? 1000);
+        return Promise.race([result, timeout]).finally(() => {
+            this.removeMessageListener();
+        });
+    }
+    terminate() {
+        this.removeMessageListener();
+        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) {
+                    this.stopTimer();
+                    if (data.success) {
+                        resolve(data.result);
+                    }
+                    else {
+                        reject(data.result);
+                    }
+                }
+            };
+            this.worker.addEventListener('message', listener);
+            this.removeMessageListener = () => this.worker.removeEventListener('message', listener);
+            this.worker.postMessage(task);
+        });
+    }
+    timeout(timeoutMs) {
+        return new Promise((_, reject) => {
+            this.timerId = window.setTimeout(() => {
+                this.terminate();
+                reject(new Error('maximum execution time exceeded'));
+            }, timeoutMs);
+        });
+    }
+    stopTimer() {
+        clearTimeout(this.timerId);
+    }
+    createWorker() {
+        const blob = URL.createObjectURL(new Blob([workerSource], { type: 'application/javascript' }));
+        return new Worker(blob);
+    }
+    removeMessageListener() {
+        // replaced by constructor
+    }
+}

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

@@ -0,0 +1,11 @@
+export interface WorkerResult {
+    id: string;
+    result: unknown;
+    success: boolean;
+}
+export interface WorkerTask {
+    id: string;
+    code: string;
+    contextVariable: string;
+    context?: unknown;
+}

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

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

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

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

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

@@ -0,0 +1,74 @@
+const WHITELIST = [
+    'TEMPORARY',
+    'PERSISTENT',
+    'console',
+    'self',
+    'onmessage',
+    'postMessage',
+    'global',
+    'allowed',
+    'Array',
+    'Boolean',
+    'Date',
+    'Function',
+    'Number',
+    'Object',
+    'RegExp',
+    'String',
+    'Error',
+    'EvalError',
+    'RangeError',
+    'ReferenceError',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt',
+    'Infinity',
+    'JSON',
+    'Math',
+    'NaN',
+    'undefined',
+];
+const windowProps = Object.getOwnPropertyNames(self);
+const protoProps = Object.getOwnPropertyNames(self.__proto__);
+const props = [...windowProps, ...protoProps];
+props.forEach((prop) => {
+    if (!WHITELIST.includes(prop)) {
+        Object.defineProperty(self, prop, {
+            get: () => {
+                throw new Error(`Security Exception: cannot access ${prop}`);
+            },
+            set: () => {
+                throw new Error(`Security Exception: cannot set ${prop}`);
+            },
+            configurable: false,
+        });
+    }
+});
+// Parses and calls function string with args
+onmessage = (event) => {
+    let result;
+    let success = true;
+    try {
+        const fn = Function(event.data.contextVariable, `"use strict";return (${event.data.code});`);
+        result = fn(event.data.context);
+    }
+    catch (e) {
+        result = e;
+        success = false;
+    }
+    const message = {
+        id: event.data.id,
+        result,
+        success,
+    };
+    postMessage(message);
+};
+export {};

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

@@ -0,0 +1,2 @@
+declare const source: string;
+export default source;

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

@@ -0,0 +1,4 @@
+// Auto-generated file
+/* eslint-disable */
+const source = "(()=>{\"use strict\";(()=>{const e=[\"TEMPORARY\",\"PERSISTENT\",\"console\",\"self\",\"onmessage\",\"postMessage\",\"global\",\"allowed\",\"Array\",\"Boolean\",\"Date\",\"Function\",\"Number\",\"Object\",\"RegExp\",\"String\",\"Error\",\"EvalError\",\"RangeError\",\"ReferenceError\",\"SyntaxError\",\"TypeError\",\"URIError\",\"decodeURI\",\"decodeURIComponent\",\"encodeURI\",\"encodeURIComponent\",\"isFinite\",\"isNaN\",\"parseFloat\",\"parseInt\",\"Infinity\",\"JSON\",\"Math\",\"NaN\",\"undefined\"];[...Object.getOwnPropertyNames(self),...Object.getOwnPropertyNames(self.__proto__)].forEach((r=>{e.includes(r)||Object.defineProperty(self,r,{get:()=>{throw new Error(`Security Exception: cannot access ${r}`)},set:()=>{throw new Error(`Security Exception: cannot set ${r}`)},configurable:!1})})),onmessage=e=>{let r,t=!0;try{r=Function(e.data.contextVariable,`\"use strict\";return (${e.data.code});`)(e.data.context)}catch(e){r=e,t=!1}const o={id:e.data.id,result:r,success:t};postMessage(o)}})()})();";
+export default source;

package/helpers/websandbox/index.d.ts

@@ -0,0 +1,2 @@
+import WebSandbox from './sandbox';
+export { WebSandbox };

package/helpers/websandbox/index.js

@@ -0,0 +1,2 @@
+import WebSandbox from './sandbox';
+export { WebSandbox };

package/helpers/websandbox/sandbox.d.ts

@@ -0,0 +1,48 @@
+export interface SandboxOptions extends Required<RunCodeOptions> {
+    /** The selector or element to append the iframe to */
+    frameContainer: string | Element;
+    /** Whether to enable verbose logging */
+    debugMode: boolean;
+}
+export interface RunCodeOptions {
+    /** The name of the variable to use for the context object */
+    contextVariable?: string;
+    timeout?: {
+        /** The minimum time to wait for a task to complete
+         *
+         * The worker will attempt to kill the task after this time.
+         */
+        minimumMs: number;
+        /** The maximum time to wait for a task to complete
+         *
+         * The sandbox will be destroyed and rebuilt after this time.
+         */
+        maximumMs: number;
+    };
+}
+export declare const BaseOptions: SandboxOptions;
+export interface SandboxMethods {
+    iframeInitialised: () => void;
+}
+export default class WebSandbox {
+    private options;
+    private frame;
+    private connection?;
+    initialised: Promise<WebSandbox>;
+    static new(options?: Partial<SandboxOptions>): Promise<WebSandbox>;
+    private constructor();
+    /** Runs code in the sandbox. Can be either a string or a function */
+    run<T = unknown>(code: string | (() => T), context?: unknown, options?: RunCodeOptions): Promise<T>;
+    /** Destroys the sandbox.
+     *
+     * This will remove the iframe from the DOM and remove the message listener.
+     */
+    destroy(): void;
+    private initialise;
+    private destroyAndRebuild;
+    private removeMessageListener;
+    private runFunction;
+    private runCode;
+    private createFrame;
+    private prepareFrameContent;
+}

package/helpers/websandbox/sandbox.js

@@ -0,0 +1,116 @@
+import Connection from './connection';
+import frameSource from './frame';
+import { generateUUID } from '../generateUUID';
+export const BaseOptions = {
+    frameContainer: 'body',
+    debugMode: false,
+    contextVariable: 'ctx',
+    timeout: {
+        minimumMs: 500,
+        maximumMs: 1000,
+    },
+};
+export default class WebSandbox {
+    static async new(options = {}) {
+        return new WebSandbox(options).initialised;
+    }
+    constructor(options) {
+        this.options = { ...BaseOptions, ...options };
+        this.frame = this.createFrame();
+        this.initialised = this.initialise().then(() => this);
+    }
+    /** Runs code in the sandbox. Can be either a string or a function */
+    async run(code, context, options) {
+        if (typeof code === 'function') {
+            return this.runFunction(code, context);
+        }
+        return this.runCode(code, context, options);
+    }
+    /** Destroys the sandbox.
+     *
+     * This will remove the iframe from the DOM and remove the message listener.
+     */
+    destroy() {
+        this.frame.remove();
+        this.removeMessageListener();
+    }
+    initialise() {
+        return new Promise((resolve) => {
+            this.connection = new Connection('SANDBOX', this.frame.contentWindow.postMessage.bind(this.frame.contentWindow), {
+                iframeInitialised: () => resolve(),
+            }, (listener) => {
+                const sourceCheckListener = (event) => {
+                    if (event.source !== this.frame.contentWindow) {
+                        return;
+                    }
+                    return listener(event);
+                };
+                window.addEventListener('message', sourceCheckListener);
+                this.removeMessageListener = () => window.removeEventListener('message', sourceCheckListener);
+            }, { allowedSenderOrigin: 'null', debugMode: this.options.debugMode });
+        });
+    }
+    async destroyAndRebuild() {
+        this.destroy();
+        this.frame = this.createFrame();
+        await this.initialise();
+    }
+    removeMessageListener() {
+        // replaced by constructor
+    }
+    async runFunction(fn, context, options) {
+        return this.runCode(`(${fn.toString()})()`, context, options);
+    }
+    async runCode(code, context, options) {
+        if (!this.connection) {
+            throw new Error('sandbox not initialised');
+        }
+        let timerId;
+        const timeout = new Promise((_, reject) => {
+            setTimeout(() => {
+                this.destroyAndRebuild().finally(() => reject(new Error('sandbox timed out')));
+            }, options?.timeout?.maximumMs ?? this.options.timeout.maximumMs);
+        });
+        const taskId = generateUUID();
+        const task = await this.connection.callRemoteMethod('startTask', {
+            id: taskId,
+            code,
+            context,
+            timeout: this.options.timeout.minimumMs,
+            contextVariable: options?.contextVariable ?? this.options.contextVariable,
+        });
+        return Promise.race([task, timeout]).finally(() => {
+            clearTimeout(timerId);
+        });
+    }
+    createFrame() {
+        const containerSelector = this.options.frameContainer;
+        const container = typeof containerSelector === 'string' ? document.querySelector(containerSelector) : containerSelector;
+        if (!container) {
+            throw new Error('unable to find container for sandbox');
+        }
+        const iframe = document.createElement('iframe');
+        iframe.sandbox.add('allow-scripts');
+        iframe.srcdoc = this.prepareFrameContent();
+        iframe.style.display = 'none';
+        container.appendChild(iframe);
+        return iframe;
+    }
+    prepareFrameContent() {
+        let script = frameSource;
+        if (this.options.debugMode) {
+            script = `window.debugMode=true;${script}`;
+        }
+        return `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <script>
+            ${script}
+          </script>
+        </head>
+      </html>
+    `;
+    }
+}

package/helpers/websandbox/types.d.ts

@@ -0,0 +1,13 @@
+type APIMethod = (...args: any[]) => unknown;
+export type API = Map<string, APIMethod>;
+export type APIDeclaration<T> = {
+    [K in keyof T]: T[K] extends APIMethod ? T[K] : never;
+};
+export interface Task {
+    id: string;
+    code: string;
+    context?: unknown;
+    timeout: number;
+    contextVariable?: string;
+}
+export {};

package/helpers/websandbox/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.1-alpha",
   "description": "Javascript SDK for rocos",
   "main": "index.js",
   "types": "index.d.ts",

package/services/AssetStorageService.js

@@ -110,7 +110,7 @@ export class AssetStorageService extends BaseServiceAbstract {
      */
     async listMissionAssets(projectId, assetIdList) {
         const searchParams = new URLSearchParams();
-        assetIdList.forEach((assetId) => searchParams.append('assetId', assetId));
+        assetIdList.forEach((assetId) => searchParams.append('assetID', assetId));
         return this.callGet(formatServiceUrl(API_PROJECT_MISSION_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset for ${projectId}, assetIdList ${assetIdList}.`, searchParams);
     }
     /**

package/services/BaseServiceAbstract.d.ts

@@ -1,6 +1,6 @@
 import { IRocosSDKConfig, RocosError } from '../models';
+import { QueryParams } from '../helpers';
 import { Logger } from 'loglevel';
-type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
 type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
 interface RequestConfig {
     /**

package/services/BaseServiceAbstract.js

@@ -1,4 +1,5 @@
 import { RocosError } from '../models';
+import { getURLSearchParams } from '../helpers';
 import { RocosStore } from '../store/RocosStore';
 class HttpError extends Error {
     constructor(response) {
@@ -26,12 +27,7 @@ export class BaseServiceAbstract {
     async call(url, method, options) {
         const { errorMessage, config, payload, params } = options;
         try {
-            // change all params to string
-            const stringParams = Object.entries(params ?? {}).reduce((acc, [key, value]) => {
-                acc[key] = value.toString();
-                return acc;
-            }, {});
-            const formattedUrl = params ? `${url}?${new URLSearchParams(stringParams)}` : url;
+            const formattedUrl = params ? `${url}?${getURLSearchParams(params)}` : url;
             const defaultHeaders = {};
             if (!config?.public) {
                 const token = await RocosStore.getSDKInstance(this.config).getAuthService().getToken();

package/services/TelemetryService.spec.js

@@ -1,6 +1,6 @@
-import { TelemetryService } from './TelemetryService';
-import { delay, from, lastValueFrom, NEVER, take, throwError } from 'rxjs';
 import { CallsignStatus } from '../models';
+import { NEVER, delay, from, lastValueFrom, take, throwError } from 'rxjs';
+import { TelemetryService } from './TelemetryService';
 describe('TelemetryService', () => {
     describe('getRobotStatusChanges', () => {
         it('should emit unknown to begin with', async () => {