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

package/IRocosSDK.d.ts

@@ -1,29 +1,5 @@
-import { MapService, SpotProvisioningServiceNode } from './services';
-import { AssetStorageService } from './services/AssetStorageService';
-import { AuthService } from './services/AuthService';
-import { CallerService } from './services/CallerService';
-import { CommandService } from './services/CommandService';
-import { ConfigGroupService } from './services/ConfigGroupService';
-import { ControlService } from './services/ControlService';
-import { DashboardService } from './services/DashboardService';
-import { EventService } from './services/EventService';
-import { FileAccessorService } from './services/FileAccessorService';
-import { FunctionService } from './services/FunctionService';
-import { IBaseService } from './models/IBaseService';
-import { IDebugLevel } from './models/IDebugLevel';
-import { IntegrationService } from './services/IntegrationService';
-import { ProfileService } from './services/ProfileService';
-import { ProjectService } from './services/ProjectService';
-import { RobotService } from './services/RobotService';
-import { SearchService } from './services/SearchService';
-import { ServiceEnum } from './models/ServiceEnum';
-import { SpotProvisioningService } from './services/SpotProvisioningService';
-import { StreamService } from './services/StreamService';
-import { TelemetryService } from './services/TelemetryService';
-import { TimeSyncerService } from './services/TimeSyncerService';
-import { UserService } from './services/UserService';
-import { WebRTCSignallingService } from './services/WebRTCSignallingService';
-import { WorkflowService } from './services/WorkflowService';
+import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EvaluatorService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, ProfileService, ProjectService, RobotService, SearchService, SpotProvisioningService, SpotProvisioningServiceNode, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService } from './services';
+import { IBaseService, IDebugLevel, ServiceEnum } from './models';
 export declare abstract class IRocosSDK {
     abstract getService<T extends IBaseService>(name: ServiceEnum): T;
     abstract getAuthService(): AuthService;
@@ -49,6 +25,7 @@ export declare abstract class IRocosSDK {
     abstract getFileAccessorService(): FileAccessorService;
     abstract getSpotProvisionerService(): SpotProvisioningService | SpotProvisioningServiceNode;
     abstract getIntegrationService(): IntegrationService;
+    abstract getEvaluatorService(): EvaluatorService;
     abstract cleanup(): Promise<boolean>;
     abstract enableDebugMode(on: boolean): void;
     abstract setDebugLevel(level: IDebugLevel): void;

package/RocosSDK.d.ts

@@ -1,4 +1,4 @@
-import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService } from './services';
+import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EvaluatorService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService } from './services';
 import { IBaseService, IDebugLevel, IRocosSDKConfig, ServiceEnum } from './models';
 import { IRocosSDK } from './IRocosSDK';
 import { Logger } from 'loglevel';
@@ -120,6 +120,11 @@ export declare class RocosSDK implements IRocosSDK {
      * @returns MapService
      */
     getMapService(): MapService;
+    /**
+     * Gets the evaluator service
+     * @returns EvaluatorService
+     */
+    getEvaluatorService(): EvaluatorService;
     get platformTimeOffset(): number;
     get platformTime(): number;
     /**

package/RocosSDK.js

@@ -1,4 +1,4 @@
-import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, PlatFormTimeService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService, } from './services';
+import { AssetStorageService, AuthService, CallerService, CommandService, ConfigGroupService, ControlService, DashboardService, EvaluatorService, EventService, FileAccessorService, FunctionService, IntegrationService, MapService, PlatFormTimeService, ProfileService, ProjectService, RobotService, ScheduleService, SearchService, SpotProvisioningService, StreamService, TelemetryService, TimeSyncerService, UserService, WebRTCSignallingService, WorkflowService, } from './services';
 import { ServiceEnum } from './models';
 import { RocosLogger } from './logger/RocosLogger';
 import { RocosStore } from './store/RocosStore';
@@ -97,6 +97,9 @@ export class RocosSDK {
                 case ServiceEnum.MAP:
                     this.services[name] = new MapService(this.config);
                     break;
+                case ServiceEnum.EVALUATOR:
+                    this.services[name] = new EvaluatorService(this.config);
+                    break;
             }
         }
         this.logger.debug(`Found service ${name}.`);
@@ -252,6 +255,13 @@ export class RocosSDK {
     getMapService() {
         return this.getService(ServiceEnum.MAP);
     }
+    /**
+     * Gets the evaluator service
+     * @returns EvaluatorService
+     */
+    getEvaluatorService() {
+        return this.getService(ServiceEnum.EVALUATOR);
+    }
     get platformTimeOffset() {
         return PlatFormTimeService.getInstance(this.getTimeSyncerService())?.platformTimeOffset;
     }

package/helpers/websandbox/connection.d.ts

@@ -31,11 +31,6 @@ export default class Connection<Local extends APIDeclaration<Local>, Remote exte
     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

package/helpers/websandbox/connection.js

@@ -21,13 +21,6 @@ export default class Connection {
         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

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

@@ -1,4 +1,5 @@
 // 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)})();";
+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,13 +1,11 @@
 import { Task } from '../../types';
 export default class Manager {
     private worker;
-    private timerId?;
+    private messageListeners;
     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

@@ -1,6 +1,8 @@
-import workerSource from './worker.source';
+// 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) {
@@ -9,13 +11,22 @@ export default class Manager {
             contextVariable: task.contextVariable ?? 'ctx',
         };
         const result = this.runTask(workerTask);
-        const timeout = this.timeout(task.timeout ?? 1000);
+        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();
+            this.removeMessageListener(task.id);
+            clearTimeout(timerId);
         });
     }
     terminate() {
-        this.removeMessageListener();
+        for (const listener of this.messageListeners.values()) {
+            this.worker.removeEventListener('message', listener);
+        }
         this.worker.terminate();
         this.worker = this.createWorker();
     }
@@ -24,7 +35,6 @@ export default class Manager {
             const listener = (event) => {
                 const { data } = event;
                 if (data.id === task.id) {
-                    this.stopTimer();
                     if (data.success) {
                         resolve(data.result);
                     }
@@ -33,27 +43,20 @@ export default class Manager {
                     }
                 }
             };
+            this.messageListeners.set(task.id, listener);
             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' }));
+        const blob = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: 'application/javascript' }));
         return new Worker(blob);
     }
-    removeMessageListener() {
-        // replaced by constructor
+    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

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

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

@@ -0,0 +1,121 @@
+/**
+ * @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(),
+    },
+});
+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/helpers/websandbox/frame/worker/worker.source.js

@@ -1,4 +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)}})()})();";
+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/sandbox.d.ts

@@ -24,11 +24,16 @@ export declare const BaseOptions: SandboxOptions;
 export interface SandboxMethods {
     iframeInitialised: () => void;
 }
+/** A sandbox for running untrusted code in an iframe & embedded web worker.
+ *
+ * This is a wrapper around the iframe and web worker that provides a simple API for running code in the sandbox.
+ * It also provides a context object that can be used to pass data into the sandbox.
+ */
 export default class WebSandbox {
-    private options;
+    private readonly options;
     private frame;
     private connection?;
-    initialised: Promise<WebSandbox>;
+    private initialised;
     static new(options?: Partial<SandboxOptions>): Promise<WebSandbox>;
     private constructor();
     /** Runs code in the sandbox. Can be either a string or a function */
@@ -39,6 +44,7 @@ export default class WebSandbox {
      */
     destroy(): void;
     private initialise;
+    private validateOptions;
     private destroyAndRebuild;
     private removeMessageListener;
     private runFunction;

package/helpers/websandbox/sandbox.js

@@ -6,18 +6,26 @@ export const BaseOptions = {
     debugMode: false,
     contextVariable: 'ctx',
     timeout: {
-        minimumMs: 500,
-        maximumMs: 1000,
+        minimumMs: 1000,
+        maximumMs: 1500,
     },
 };
+/** A sandbox for running untrusted code in an iframe & embedded web worker.
+ *
+ * This is a wrapper around the iframe and web worker that provides a simple API for running code in the sandbox.
+ * It also provides a context object that can be used to pass data into the sandbox.
+ */
 export default class WebSandbox {
     static async new(options = {}) {
-        return new WebSandbox(options).initialised;
+        const sandbox = new WebSandbox(options);
+        await sandbox.initialised;
+        return sandbox;
     }
     constructor(options) {
         this.options = { ...BaseOptions, ...options };
         this.frame = this.createFrame();
-        this.initialised = this.initialise().then(() => this);
+        this.validateOptions(this.options);
+        this.initialised = this.initialise();
     }
     /** Runs code in the sandbox. Can be either a string or a function */
     async run(code, context, options) {
@@ -50,6 +58,19 @@ export default class WebSandbox {
             }, { allowedSenderOrigin: 'null', debugMode: this.options.debugMode });
         });
     }
+    validateOptions(options) {
+        const minimumTimeout = options.timeout.minimumMs;
+        const maximumTimeout = options.timeout.maximumMs;
+        if (maximumTimeout < minimumTimeout) {
+            throw new Error(`maximum timeout (${maximumTimeout}ms) must be greater than or equal to minimum timeout (${minimumTimeout}ms)`);
+        }
+        if (minimumTimeout <= 0 || maximumTimeout <= 0) {
+            throw new Error('timeout values must be greater than 0');
+        }
+        if (maximumTimeout > 5000) {
+            throw new Error('maximum timeout must be less than or equal to 5000ms');
+        }
+    }
     async destroyAndRebuild() {
         this.destroy();
         this.frame = this.createFrame();
@@ -65,9 +86,13 @@ export default class WebSandbox {
         if (!this.connection) {
             throw new Error('sandbox not initialised');
         }
+        this.validateOptions({
+            ...this.options,
+            ...options,
+        });
         let timerId;
         const timeout = new Promise((_, reject) => {
-            setTimeout(() => {
+            timerId = setTimeout(() => {
                 this.destroyAndRebuild().finally(() => reject(new Error('sandbox timed out')));
             }, options?.timeout?.maximumMs ?? this.options.timeout.maximumMs);
         });
@@ -90,7 +115,12 @@ export default class WebSandbox {
             throw new Error('unable to find container for sandbox');
         }
         const iframe = document.createElement('iframe');
-        iframe.sandbox.add('allow-scripts');
+        if (iframe.sandbox) {
+            iframe.sandbox.add('allow-scripts');
+        }
+        else {
+            iframe.setAttribute('sandbox', 'allow-scripts');
+        }
         iframe.srcdoc = this.prepareFrameContent();
         iframe.style.display = 'none';
         container.appendChild(iframe);

package/models/RocosError.d.ts

@@ -22,6 +22,7 @@ export declare const errorCodes: {
     SCHEDULE_SERVICE_ERROR: string;
     INTEGRATIONS_SERVICE_ERROR: string;
     MAPS_SERVICE_ERROR: string;
+    EVALUATOR_SERVICE_ERROR: string;
 };
 export declare class RocosError extends Error {
     code?: string;

package/models/RocosError.js

@@ -22,6 +22,7 @@ export const errorCodes = {
     SCHEDULE_SERVICE_ERROR: 'SCHEDULE_SERVICE_ERROR',
     INTEGRATIONS_SERVICE_ERROR: 'INTEGRATIONS_SERVICE_ERROR',
     MAPS_SERVICE_ERROR: 'MAPS_SERVICE_ERROR',
+    EVALUATOR_SERVICE_ERROR: 'EVALUATOR_SERVICE_ERROR',
 };
 export class RocosError extends Error {
     constructor(err, code, statusCode) {

package/models/ServiceEnum.d.ts

@@ -22,5 +22,6 @@ export declare enum ServiceEnum {
     SCHEDULE = "schedule",
     SPOT_PROVISIONER = "spot_provisioner",
     INTEGRATION = "integration",
-    MAP = "map"
+    MAP = "map",
+    EVALUATOR = "evaluator"
 }

package/models/ServiceEnum.js

@@ -24,4 +24,5 @@ export var ServiceEnum;
     ServiceEnum["SPOT_PROVISIONER"] = "spot_provisioner";
     ServiceEnum["INTEGRATION"] = "integration";
     ServiceEnum["MAP"] = "map";
+    ServiceEnum["EVALUATOR"] = "evaluator";
 })(ServiceEnum || (ServiceEnum = {}));

package/node/RocosSDKNode.d.ts

@@ -1,4 +1,4 @@
-import { ScheduleService } from '../services';
+import { EvaluatorService, ScheduleService } from '../services';
 import { CallerServiceNode } from '../services/CallerServiceNode';
 import { CommandServiceNode } from '../services/CommandServiceNode';
 import { ControlServiceNode } from '../services/ControlServiceNode';
@@ -39,4 +39,9 @@ export declare class RocosSDKNode extends RocosSDK {
      * @returns FileAccessorServiceNode
      */
     getFileAccessorService(): FileAccessorServiceNode;
+    /**
+     * Gets the evaluator service
+     * @returns EvaluatorServiceNode
+     */
+    getEvaluatorService(): EvaluatorService;
 }

package/node/RocosSDKNode.js

@@ -140,4 +140,11 @@ export class RocosSDKNode extends RocosSDK {
     getFileAccessorService() {
         return this.getService(ServiceEnum.FILE_ACCESSOR);
     }
+    /**
+     * Gets the evaluator service
+     * @returns EvaluatorServiceNode
+     */
+    getEvaluatorService() {
+        throw new Error('Evaluator service is not supported in NodeJS');
+    }
 }

package/package.json

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

package/services/EvaluatorService.d.ts

@@ -0,0 +1,11 @@
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RunCodeOptions } from '../helpers/websandbox/sandbox';
+export declare class EvaluatorService extends BaseServiceAbstract implements IBaseService {
+    private readonly sandbox;
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    teardown(): Promise<void>;
+    execute<T = unknown>(code: string | (() => T), context?: unknown, options?: RunCodeOptions): Promise<T>;
+}

package/services/EvaluatorService.js

@@ -0,0 +1,28 @@
+import { RocosError, errorCodes } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { WebSandbox } from '../helpers';
+export class EvaluatorService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`EvaluatorService(${this.config.url})`);
+        this.sandbox = WebSandbox.new().catch((e) => {
+            this.logger.error('Failed to create WebSandbox', e);
+            throw e;
+        });
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.EVALUATOR_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    async teardown() {
+        const sandbox = await this.sandbox;
+        sandbox.destroy();
+    }
+    async execute(code, context, options) {
+        const sandbox = await this.sandbox;
+        return sandbox.run(code, context, options);
+    }
+}

package/services/MapService.d.ts

@@ -102,6 +102,7 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
      *
      * @param projectId Project ID
      * @param mapId Map ID
+     * @param frameId Frame ID (optional)
      */
-    getGeoJSON(projectId: string, mapId: string): Promise<unknown>;
+    getGeoJSON(projectId: string, mapId: string, frameId?: string): Promise<unknown>;
 }

package/services/MapService.js

@@ -138,12 +138,14 @@ export class MapService extends BaseServiceAbstract {
      *
      * @param projectId Project ID
      * @param mapId Map ID
+     * @param frameId Frame ID (optional)
      */
-    async getGeoJSON(projectId, mapId) {
-        return this.callGet(formatServiceUrl(API_MAPS_GEOJSON_URL, {
+    async getGeoJSON(projectId, mapId, frameId) {
+        const params = {
             url: this.config.url,
             projectId,
             mapId,
-        }, this.config.insecure), 'Failed to get map GeoJSON.');
+        };
+        return this.callGet(formatServiceUrl(API_MAPS_GEOJSON_URL, params, this.config.insecure), 'Failed to get map GeoJSON.', frameId ? { frameID: frameId } : undefined);
     }
 }

package/services/index.d.ts

@@ -24,3 +24,4 @@ export * from './PlatformTimeService';
 export * from './SpotProvisioningService';
 export * from './SpotProvisioningServiceNode';
 export * from './MapService';
+export * from './EvaluatorService';

package/services/index.js

@@ -24,3 +24,4 @@ export * from './PlatformTimeService';
 export * from './SpotProvisioningService';
 export * from './SpotProvisioningServiceNode';
 export * from './MapService';
+export * from './EvaluatorService';