@dronedeploy/rocos-js-sdk 2.6.1 → 3.0.0-alpha.20

package/helpers/getSubscriptionsDifference.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubscriptionsDifference = void 0;
-const arrayRemove_1 = require("./arrayRemove");
-const getSubscriptionsDifference = (before, after) => {
-    const toRemove = Object.assign({}, before);
-    const toAdd = Object.assign({}, after);
+import { arrayRemove } from './arrayRemove';
+export const getSubscriptionsDifference = (before, after) => {
+    const toRemove = { ...before };
+    const toAdd = { ...after };
     Object.keys(before).forEach((key) => {
         if (after[key]) {
-            toRemove[key] = arrayRemove_1.arrayRemove(toRemove[key], after[key]);
+            toRemove[key] = arrayRemove(toRemove[key], after[key]);
             if (!toRemove[key].length) {
                 delete toRemove[key];
             }
@@ -15,7 +12,7 @@ const getSubscriptionsDifference = (before, after) => {
     });
     Object.keys(after).forEach((key) => {
         if (before[key]) {
-            toAdd[key] = arrayRemove_1.arrayRemove(toAdd[key], before[key]);
+            toAdd[key] = arrayRemove(toAdd[key], before[key]);
             if (!toAdd[key].length) {
                 delete toAdd[key];
             }
@@ -36,4 +33,3 @@ const getSubscriptionsDifference = (before, after) => {
         },
     };
 };
-exports.getSubscriptionsDifference = getSubscriptionsDifference;

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/getUniqueConfigKey.js

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

package/helpers/getUniqueId.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUniqueId = void 0;
-const flattenCallsignsLookup_1 = require("./flattenCallsignsLookup");
+import { flattenCallsignsLookup } from './flattenCallsignsLookup';
 /**
  *
  * @param projectId
@@ -9,7 +6,6 @@ const flattenCallsignsLookup_1 = require("./flattenCallsignsLookup");
  * @param sources
  * @param scope
  */
-const getUniqueId = (projectId, callsignsLookup, sources, scope) => {
-    return [projectId, ...flattenCallsignsLookup_1.flattenCallsignsLookup(callsignsLookup), ...sources.sort(), scope].join();
+export const getUniqueId = (projectId, callsignsLookup, sources, scope) => {
+    return [projectId, ...flattenCallsignsLookup(callsignsLookup), ...sources.sort(), scope].join();
 };
-exports.getUniqueId = getUniqueId;

package/helpers/getUnixTimeMs.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnixTimeMs = void 0;
-const getUnixTimeMs = (offsetMs, baseOn = new Date()) => {
+export const getUnixTimeMs = (offsetMs, baseOn = new Date()) => {
     const newDate = new Date(baseOn.getTime() + offsetMs);
     return newDate.getTime(); // Convert date to ms.
 };
-exports.getUnixTimeMs = getUnixTimeMs;

package/helpers/index.d.ts

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

package/helpers/index.js

@@ -1,15 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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("./generateUUID"), exports);
-__exportStar(require("./average"), exports);
-__exportStar(require("./standardDeviation"), exports);
+export * from './average';
+export * from './standardDeviation';
+export * from './generateUUID';
+export * from './getURLSearchParams';
+export * from './websandbox';

package/helpers/nanosecondToMillisecond.d.ts

@@ -1 +1 @@
-export declare const nanosecondToMillisecond: (nanoNum: number) => number;
+export declare const nanosecondToMillisecond: (nano: number | string) => number;

package/helpers/nanosecondToMillisecond.js

@@ -1,7 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nanosecondToMillisecond = void 0;
-const nanosecondToMillisecond = (nanoNum) => {
-    return nanoNum / 1000000;
+function isNumber(n) {
+    return typeof n === 'number';
+}
+export const nanosecondToMillisecond = (nano) => {
+    if (isNumber(nano)) {
+        return nano / 1e6;
+    }
+    if (nano.length < 16) {
+        return Number(nano) / 1e6;
+    }
+    return Number(nano.slice(0, -6) + '.' + nano.slice(-6));
 };
-exports.nanosecondToMillisecond = nanosecondToMillisecond;

package/helpers/nanosecondToMillisecond.spec.d.ts

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

package/helpers/nanosecondToMillisecond.spec.js

@@ -0,0 +1,20 @@
+import { nanosecondToMillisecond } from './nanosecondToMillisecond';
+describe('nanosecondToMillisecond', () => {
+    it.each `
+    input                    | expected
+    ${'0.0001'}              | ${0.0000000001}
+    ${'1'}                   | ${0.000001}
+    ${'1000000'}             | ${1}
+    ${'10000000'}            | ${10}
+    ${'-100000006'}           | ${-100.000006}
+    ${'1000000000000000000'} | ${1000000000000}
+    ${'1234567891011100001'} | ${1234567891011.100001}
+    ${'1234567891011100000'} | ${1234567891011.1}
+    ${0.0001}                | ${0.0000000001}
+    ${1}                     | ${0.000001}
+    ${1000000}               | ${1}
+    ${1000000000000001}      | ${1000000000.000001}
+  `('should convert $input to $expected', ({ input, expected }) => {
+        expect(nanosecondToMillisecond(input)).toBe(expected);
+    });
+});

package/helpers/randomString.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomString = void 0;
-const randomString = () => {
+export const randomString = () => {
     return Math.random().toString(16).substr(2);
 };
-exports.randomString = randomString;

package/helpers/standardDeviation.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.standardDeviation = void 0;
-const average_1 = require("./average");
-const standardDeviation = (numbers) => {
-    const avg = average_1.average(numbers);
+import { average } from './average';
+export const standardDeviation = (numbers) => {
+    const avg = average(numbers);
     const squareDiffs = numbers.map((value) => {
         const diff = value - avg;
         const sqrDiff = diff * diff;
         return sqrDiff;
     });
-    const avgSquareDiff = average_1.average(squareDiffs);
+    const avgSquareDiff = average(squareDiffs);
     const stdDev = Math.sqrt(avgSquareDiff);
     return stdDev;
 };
-exports.standardDeviation = standardDeviation;

package/helpers/standardDeviation.spec.d.ts

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

package/helpers/standardDeviation.spec.js

@@ -0,0 +1,11 @@
+import { standardDeviation } from './standardDeviation';
+describe('standardDeviation', () => {
+    it('should calculate standard deviation correctly', () => {
+        let numbers = [10, 12, 23, 23, 16, 23, 21, 16];
+        let stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 4.8989794855664)).toBeLessThan(0.000001);
+        numbers = [100, 12, 23, 23, 116, 23, 21, 162];
+        stdDev = standardDeviation(numbers);
+        expect(Math.abs(stdDev - 53.702886328394)).toBeLessThan(0.000001);
+    });
+});

package/helpers/stringToUint8Array.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringToUint8Array = void 0;
-const buffer_1 = require("buffer");
-const stringToUint8Array = (input) => {
+import { Buffer } from 'buffer';
+export const stringToUint8Array = (input) => {
     input = input ? input : '';
-    const buf = new buffer_1.Buffer(input);
+    const buf = new Buffer(input);
     const result = new Uint8Array(buf.length);
     for (let i = 0; i < buf.length; i++) {
         result[i] = buf[i];
     }
     return result;
 };
-exports.stringToUint8Array = stringToUint8Array;

package/helpers/uint8ArrayToString.js

@@ -1,15 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uint8ArrayToString = void 0;
-const uint8ArrayToString = (arr) => {
+export const uint8ArrayToString = (arr) => {
     if (!arr) {
         return '';
     }
     const strArr = [];
-    arr === null || arr === void 0 ? void 0 : arr.forEach((element) => {
+    arr?.forEach((element) => {
         strArr.push(String.fromCharCode(element));
     });
-    const str = strArr.join('');
-    return str;
+    return strArr.join('');
 };
-exports.uint8ArrayToString = uint8ArrayToString;

package/helpers/websandbox/connection.d.ts

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

package/helpers/websandbox/connection.js

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

package/helpers/websandbox/frame/frame.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,5 @@
+// Auto-generated file
+/* eslint-disable */
+import __WORKER_SOURCE__ from './worker/worker.source';
+const source = `(()=>{"use strict";var e={880:(e,t)=>{var s;Object.defineProperty(t,"__esModule",{value:!0}),function(e){e.RESPONSE="response",e.MESSAGE="message"}(s||(s={}));const r={allowedSenderOrigin:void 0,debugMode:!1};t.default=class{constructor(e,t,s,i,o={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...r,...o},this.log("Created connection w/ allowedOrigin:",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(s));const[n]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=n,this.postMessageInternal=t,i((e=>this.onMessageListener(e)))}callRemoteMethod(e,...t){return this.log("Calling Remote Method",{name:e,args:t}),new Promise(((r,i)=>{const o=this.registerCallback(r,i);this.postMessage({callId:o,type:s.MESSAGE,methodName:e,arguments:t})}))}onMessageListener(e){this.log("Received message",e);const{data:t}=e,{allowedSenderOrigin:r}=this.options;switch(r&&e.origin!==r&&console.warn(\`Received message from invalid origin: \${e.origin}\`),t.type){case s.RESPONSE:return void this.popCallback(t.callId,t.success,t.result);case s.MESSAGE:this.callLocalMethod(t.methodName,t.arguments).then((e=>this.responseOtherSide(t.callId,e))).catch((e=>this.responseOtherSide(t.callId,e,!1)))}}async callLocalMethod(e,t){this.log("calling local method",e,t);const s=this.serviceMethods.get(e);if(!s)throw new Error(\`service method \${e} not found\`);return s(...t)}responseOtherSide(e,t,r=!0){this.log("responding to remote call",{id:e,result:t,success:r});const i=t=>{this.postMessage({callId:e,type:s.RESPONSE,success:r,result:t})};try{i(t)}catch(e){e instanceof DOMException&&i(JSON.parse(JSON.stringify(t)))}}registerCallback(e,t){const s=(++this.incrementalID).toString();return this.log("registering callback for id",s),this.callbacks.set(s,{success:e,failure:t}),s}popCallback(e,t,s){this.log("calling callback for id",e,{success:t,result:s});const r=this.callbacks.get(e);t?r?.success(s):r?.failure(s),this.callbacks.delete(e)}postMessage(e,t="*"){this.log("sending message",{data:e,targetOrigin:t}),this.postMessageInternal(e,t)}log(...e){this.options.debugMode&&console.debug(\`[\${this.name}]\`,...e)}}},306:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(880)),o=r(s(54)),n=new class{constructor(){const e=!!window?.debugMode;this.connection=new i.default("FRAME",window.parent.postMessage.bind(window.parent),{startTask:this.runCode.bind(this)},(e=>{window.addEventListener("message",e)}),{debugMode:e}),this.connection.callRemoteMethod("iframeInitialised"),this.workerManager=new o.default}async runCode(e){return this.workerManager.execute(e)}};t.default=n},54:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(420));t.default=i.default},420:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.default=class{constructor(){this.messageListeners=new Map,this.worker=this.createWorker()}async execute(e){const t={...e,contextVariable:e.contextVariable??"ctx"},s=this.runTask(t),r=new Promise(((t,s)=>{const r=AbortSignal.timeout(e.timeout);r.addEventListener("abort",(()=>{s(r.reason)}))}));return Promise.race([s,r]).catch((e=>{throw"TimeoutError"===e.name&&this.terminate(),e})).finally((()=>{this.removeMessageListener(e.id)}))}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/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,11 @@
+import { Task } from '../../types';
+export default class Manager {
+    private worker;
+    private messageListeners;
+    constructor();
+    execute(task: Task): Promise<unknown>;
+    terminate(): void;
+    private runTask;
+    private createWorker;
+    private removeMessageListener;
+}

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

@@ -0,0 +1,67 @@
+// this token (__WORKER_SOURCE__) is replaced by webpack with the source of the worker
+const WORKER_SOURCE = '__WORKER_SOURCE__';
+export default class Manager {
+    constructor() {
+        this.messageListeners = new Map();
+        this.worker = this.createWorker();
+    }
+    async execute(task) {
+        const workerTask = {
+            ...task,
+            contextVariable: task.contextVariable ?? 'ctx',
+        };
+        const result = this.runTask(workerTask);
+        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();
+            }
+            throw e;
+        })
+            .finally(() => {
+            this.removeMessageListener(task.id);
+        });
+    }
+    terminate() {
+        for (const listener of this.messageListeners.values()) {
+            this.worker.removeEventListener('message', listener);
+        }
+        this.worker.terminate();
+        this.worker = this.createWorker();
+    }
+    runTask(task) {
+        return new Promise((resolve, reject) => {
+            const listener = (event) => {
+                const { data } = event;
+                if (data.id === task.id) {
+                    if (data.success) {
+                        resolve(data.result);
+                    }
+                    else {
+                        reject(data.result);
+                    }
+                }
+            };
+            this.messageListeners.set(task.id, listener);
+            this.worker.addEventListener('message', listener);
+            this.worker.postMessage(task);
+        });
+    }
+    createWorker() {
+        const blob = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: 'application/javascript' }));
+        return new Worker(blob);
+    }
+    removeMessageListener(id) {
+        const listener = this.messageListeners.get(id);
+        if (!listener) {
+            return;
+        }
+        this.worker.removeEventListener('message', listener);
+    }
+}

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

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