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

package/cjs/helpers/websandbox/connection.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var MessageType;
+(function (MessageType) {
+    MessageType["RESPONSE"] = "response";
+    MessageType["MESSAGE"] = "message";
+})(MessageType || (MessageType = {}));
+const defaultOptions = {
+    allowedSenderOrigin: undefined,
+    debugMode: false,
+};
+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,
+            });
+        });
+    }
+    /** Log a message if debug mode is enabled */
+    log(...args) {
+        if (this.options.debugMode) {
+            console.debug(`[${this.name}]`, ...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);
+    }
+}
+exports.default = Connection;

package/cjs/helpers/websandbox/frame/frame.js

@@ -0,0 +1,30 @@
+"use strict";
+// this file is bundled via webpack and included in the iframe source
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connection_1 = __importDefault(require("../connection"));
+const worker_1 = __importDefault(require("./worker"));
+class Frame {
+    constructor() {
+        const isDebugMode = !!window?.debugMode;
+        this.connection = new connection_1.default('FRAME', window.parent.postMessage.bind(window.parent), {
+            startTask: this.runCode.bind(this),
+        }, (listener) => {
+            window.addEventListener('message', listener);
+        }, {
+            debugMode: isDebugMode,
+        });
+        void this.connection.callRemoteMethod('iframeInitialised');
+        // use roughly half the number of logical cores available clamped between 1 and 6
+        const workers = Math.min(Math.max(Math.ceil(navigator.hardwareConcurrency / 2), 1), 6);
+        this.connection.log(`Creating ${workers} workers`);
+        this.workerManager = new worker_1.default(workers);
+    }
+    async runCode(task) {
+        return this.workerManager.execute(task);
+    }
+}
+const frame = new Frame();
+exports.default = frame;

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

@@ -0,0 +1,10 @@
+"use strict";
+// Auto-generated file
+/* eslint-disable */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_source_1 = __importDefault(require("./worker/worker.source"));
+const source = `(()=>{"use strict";var e;!function(e){e.RESPONSE="response",e.MESSAGE="message"}(e||(e={}));const s={allowedSenderOrigin:void 0,debugMode:!1};class t{constructor(e,t,r,n,o={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...s,...o},this.log("Created connection w/ allowedOrigin:",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(r));const[i]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=i,this.postMessageInternal=t,n((e=>this.onMessageListener(e)))}callRemoteMethod(s,...t){return this.log("Calling Remote Method",{name:s,args:t}),new Promise(((r,n)=>{const o=this.registerCallback(r,n);this.postMessage({callId:o,type:e.MESSAGE,methodName:s,arguments:t})}))}log(...e){this.options.debugMode&&console.debug(\`[\${this.name}]\`,...e)}onMessageListener(s){this.log("Received message",s);const{data:t}=s,{allowedSenderOrigin:r}=this.options;switch(r&&s.origin!==r&&console.warn(\`Received message from invalid origin: \${s.origin}\`),t.type){case e.RESPONSE:return void this.popCallback(t.callId,t.success,t.result);case e.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,s){this.log("calling local method",e,s);const t=this.serviceMethods.get(e);if(!t)throw new Error(\`service method \${e} not found\`);return t(...s)}responseOtherSide(s,t,r=!0){this.log("responding to remote call",{id:s,result:t,success:r});const n=t=>{this.postMessage({callId:s,type:e.RESPONSE,success:r,result:t})};try{n(t)}catch(e){e instanceof DOMException&&n(JSON.parse(JSON.stringify(t)))}}registerCallback(e,s){const t=(++this.incrementalID).toString();return this.log("registering callback for id",t),this.callbacks.set(t,{success:e,failure:s}),t}popCallback(e,s,t){this.log("calling callback for id",e,{success:s,result:t});const r=this.callbacks.get(e);s?r?.success(t):r?.failure(t),this.callbacks.delete(e)}postMessage(e,s="*"){this.log("sending message",{data:e,targetOrigin:s}),this.postMessageInternal(e,s)}}new class{constructor(){const e=!!window?.debugMode;this.connection=new t("FRAME",window.parent.postMessage.bind(window.parent),{startTask:this.runCode.bind(this)},(e=>{window.addEventListener("message",e)}),{debugMode:e}),this.connection.callRemoteMethod("iframeInitialised");const s=Math.max(Math.ceil(navigator.hardwareConcurrency/2),1);this.connection.log(\`Creating \${s} workers\`),this.workerManager=new class{constructor(e=1){this.messageListeners=new Map,this.requestedWorkers=e,this.workers=Array.from({length:e},(()=>this.createWorker())),this.nextWorkerGenerator=this.nextWorker()}async execute(e){const s=this.nextWorkerGenerator.next().value,t={...e,contextVariable:e.contextVariable??"ctx"},r=this.runTask(s,t),n=new Promise(((s,t)=>{const r=AbortSignal.timeout(e.timeout);r.addEventListener("abort",(()=>{t(r.reason)}))}));return Promise.race([r,n]).catch((e=>{if("TimeoutError"===e.name)throw this.terminate(s),new DOMException("soft timeout reached","TimeoutError");throw e})).finally((()=>{this.removeMessageListener(e.id)}))}terminate(e){for(const s of this.messageListeners.values())e.removeEventListener("message",s);e.terminate(),this.rebuildWorkers()}runTask(e,s){return new Promise(((t,r)=>{const n=e=>{const{data:n}=e;n.id===s.id&&(n.success?t(n.result):r(n.result))};this.messageListeners.set(s.id,n),e.addEventListener("message",n),e.postMessage(s)}))}createWorker(){const e=URL.createObjectURL(new Blob(["${worker_source_1.default.replace(/(['`"$])/g, '\\$1')}"],{type:"application/javascript"}));return new Worker(e)}rebuildWorkers(){const e=this.requestedWorkers-this.workers.length;if(e<0)throw new Error("Cannot have less than 0 workers");if(e<=0)return;const s=Array.from({length:e},(()=>this.createWorker()));this.workers.push(...s)}*nextWorker(){let e=0;for(;;)e=(e+1)%this.workers.length,yield this.workers[e]}removeMessageListener(e){const s=this.messageListeners.get(e);s&&(this.workers.forEach((e=>e.removeEventListener("message",s))),this.messageListeners.delete(e))}}(s)}async runCode(e){return this.workerManager.execute(e)}}})();`;
+exports.default = source;

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

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const frame_source_1 = __importDefault(require("./frame.source"));
+exports.default = frame_source_1.default;

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

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const manager_1 = __importDefault(require("./manager"));
+exports.default = manager_1.default;

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

@@ -0,0 +1,15 @@
+import { Task } from '../../types';
+export default class Manager {
+    private readonly requestedWorkers;
+    private readonly workers;
+    private nextWorkerIndex;
+    private readonly messageListeners;
+    constructor(workers?: number);
+    execute(task: Task): Promise<unknown>;
+    private terminate;
+    private runTask;
+    private createWorker;
+    private rebuildWorkers;
+    private getWorker;
+    private removeMessageListener;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// this token (__WORKER_SOURCE__) is replaced by webpack with the source of the worker
+const WORKER_SOURCE = '__WORKER_SOURCE__';
+class Manager {
+    constructor(workers = 1) {
+        this.nextWorkerIndex = 0;
+        this.messageListeners = new Map();
+        this.requestedWorkers = workers;
+        this.workers = Array.from({ length: workers }, () => this.createWorker());
+    }
+    async execute(task) {
+        const worker = this.getWorker();
+        const workerTask = {
+            ...task,
+            contextVariable: task.contextVariable ?? 'ctx',
+        };
+        const result = this.runTask(worker, workerTask);
+        const timeout = new Promise((_, reject) => {
+            const signal = AbortSignal.timeout(task.timeout);
+            signal.addEventListener('abort', () => {
+                reject(signal.reason);
+            });
+        });
+        return Promise.race([result, timeout])
+            .catch((e) => {
+            if (e.name === 'TimeoutError') {
+                this.terminate(worker);
+                throw new DOMException('soft timeout reached', 'TimeoutError');
+            }
+            throw e;
+        })
+            .finally(() => {
+            this.removeMessageListener(task.id);
+        });
+    }
+    terminate(worker) {
+        for (const listener of this.messageListeners.values()) {
+            worker.removeEventListener('message', listener);
+        }
+        worker.terminate();
+        this.rebuildWorkers();
+    }
+    runTask(worker, 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);
+            worker.addEventListener('message', listener);
+            worker.postMessage(task);
+        });
+    }
+    createWorker() {
+        const blob = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: 'application/javascript' }));
+        return new Worker(blob);
+    }
+    rebuildWorkers() {
+        const needed = this.requestedWorkers - this.workers.length;
+        if (needed < 0)
+            throw new Error('Cannot have less than 0 workers');
+        if (needed <= 0)
+            return;
+        const newWorkers = Array.from({ length: needed }, () => this.createWorker());
+        this.workers.push(...newWorkers);
+    }
+    getWorker() {
+        const worker = this.workers[this.nextWorkerIndex];
+        this.nextWorkerIndex = (this.nextWorkerIndex + 1) % this.workers.length;
+        return worker;
+    }
+    removeMessageListener(id) {
+        const listener = this.messageListeners.get(id);
+        if (!listener)
+            return;
+        this.workers.forEach((worker) => worker.removeEventListener('message', listener));
+        this.messageListeners.delete(id);
+    }
+}
+exports.default = Manager;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};

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

@@ -0,0 +1,6 @@
+"use strict";
+// Auto-generated file
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+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)}})();`;
+exports.default = source;

package/cjs/helpers/websandbox/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSandbox = void 0;
+const sandbox_1 = __importDefault(require("./sandbox"));
+exports.WebSandbox = sandbox_1.default;

package/cjs/helpers/websandbox/sandbox.d.ts

@@ -0,0 +1,57 @@
+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;
+    };
+    abortSignal?: AbortSignal | null;
+}
+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 readonly options;
+    private frame;
+    private connection?;
+    private initialised;
+    private frameAbortController;
+    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(reason?: unknown): void;
+    private initialise;
+    private validateOptions;
+    private destroyAndRebuild;
+    private removeMessageListener;
+    private runFunction;
+    private runCode;
+    private promisifyAbortSignal;
+    private createFrame;
+    private prepareFrameContent;
+}

package/cjs/helpers/websandbox/sandbox.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseOptions = void 0;
+const connection_1 = __importDefault(require("./connection"));
+const frame_1 = __importDefault(require("./frame"));
+const generateUUID_1 = require("../generateUUID");
+exports.BaseOptions = {
+    frameContainer: 'body',
+    debugMode: false,
+    contextVariable: 'ctx',
+    timeout: {
+        minimumMs: 1000,
+        maximumMs: 1500,
+    },
+    abortSignal: null,
+};
+/** 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.
+ */
+class WebSandbox {
+    static async new(options = {}) {
+        const sandbox = new WebSandbox(options);
+        await sandbox.initialised;
+        return sandbox;
+    }
+    constructor(options) {
+        this.options = { ...exports.BaseOptions, ...options };
+        this.frame = this.createFrame();
+        this.validateOptions(this.options);
+        this.initialised = this.initialise();
+        this.frameAbortController = new AbortController();
+        if (options.abortSignal) {
+            this.promisifyAbortSignal(options.abortSignal).catch((reason) => {
+                void this.destroyAndRebuild(this.frame.id, reason);
+            });
+        }
+    }
+    /** 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(reason) {
+        this.frameAbortController.abort(reason);
+        this.frame.remove();
+        this.removeMessageListener();
+    }
+    initialise() {
+        return new Promise((resolve) => {
+            this.connection = new connection_1.default('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 });
+        });
+    }
+    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(frameId, reason) {
+        if (this.frame.id !== frameId) {
+            return;
+        }
+        this.destroy(reason);
+        this.frame = this.createFrame();
+        this.frameAbortController = new AbortController();
+        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');
+        }
+        this.validateOptions({
+            ...this.options,
+            ...options,
+        });
+        const frameId = this.frame.id;
+        const timeout = this.promisifyAbortSignal(AbortSignal.timeout(options?.timeout?.maximumMs ?? this.options.timeout.maximumMs));
+        const frameAbortedSignal = this.promisifyAbortSignal(this.frameAbortController.signal);
+        const userAbortedSignal = options?.abortSignal ? this.promisifyAbortSignal(options.abortSignal) : null;
+        const taskId = (0, generateUUID_1.generateUUID)();
+        const task = this.connection.callRemoteMethod('startTask', {
+            id: taskId,
+            code,
+            context,
+            timeout: this.options.timeout.minimumMs,
+            contextVariable: options?.contextVariable ?? this.options.contextVariable,
+        });
+        const signals = [task, timeout, frameAbortedSignal, userAbortedSignal].filter((i) => i !== null);
+        return Promise.race(signals).catch(async (e) => {
+            if (e.name === 'TimeoutError') {
+                await this.destroyAndRebuild(frameId, 'task timed out');
+            }
+            throw e;
+        });
+    }
+    promisifyAbortSignal(signal) {
+        return new Promise((_, reject) => {
+            // If the signal is already aborted, immediately throw in order to reject the promise.
+            if (signal.aborted) {
+                reject(signal.reason);
+            }
+            // Watch for 'abort' signals
+            signal.addEventListener('abort', () => {
+                // Stop the main operation
+                // Reject the promise with the abort reason.
+                reject(signal.reason);
+            });
+        });
+    }
+    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');
+        if (iframe.sandbox) {
+            iframe.sandbox.add('allow-scripts');
+        }
+        else {
+            iframe.setAttribute('sandbox', 'allow-scripts');
+        }
+        iframe.srcdoc = this.prepareFrameContent();
+        iframe.style.display = 'none';
+        iframe.id = (0, generateUUID_1.generateUUID)();
+        container.appendChild(iframe);
+        return iframe;
+    }
+    prepareFrameContent() {
+        let script = frame_1.default;
+        if (this.options.debugMode) {
+            script = `window.debugMode=true;${script}`;
+        }
+        return `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <script>
+            ${script}
+          </script>
+        </head>
+      </html>
+    `;
+    }
+}
+exports.default = WebSandbox;

package/cjs/helpers/websandbox/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants/grpc"), exports);
+__exportStar(require("./constants/timezones"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./IRocosSDK"), exports);
+__exportStar(require("./RocosSDK"), exports);