worktank/dist/worker/backend.js

A simple isomorphic library for executing functions inside WebWorkers or Node Threads pools.

/* IMPORT */
/* MAIN */
globalThis.WorkTankWorkerBackend = (() => {
    /* VARIABLES */
    const { addEventListener, postMessage } = globalThis;
    const registry = {};
    /* API */
    const castError = (error) => {
        if (error instanceof Error)
            return error;
        if (typeof error === 'string')
            return new Error(error);
        return new Error('Unknown error');
    };
    const log = (value) => {
        try {
            postMessage({ type: 'log', value });
        }
        catch (error) {
            console.error('Failed to post log message', error);
        }
    };
    const once = (fn) => {
        let called = false;
        let result;
        return () => {
            if (!called) {
                called = true;
                result = fn();
            }
            return result;
        };
    };
    const onMessage = (message) => {
        if (message.data?.type === 'exec') {
            onMessageExec(message.data.method, message.data.args);
        }
        else {
            log(`Unknown message type: ${message.data?.type}`);
        }
    };
    const onMessageExec = (method, args) => {
        const fn = registry[method];
        const result = new Promise(resolve => resolve(fn.apply(undefined, args)));
        result.then(onResultSuccess, onResultError);
    };
    const onResultError = (error) => {
        const { name, message, stack } = castError(error);
        try {
            postMessage({ type: 'result', error: { name, message, stack } });
        }
        catch {
            onResultError('Failed to post error message');
        }
    };
    const onResultSuccess = (value) => {
        try {
            postMessage({ type: 'result', value });
        }
        catch (error) {
            onResultError(error);
        }
    };
    const ready = once(() => {
        addEventListener('message', onMessage);
        postMessage({ type: 'ready' });
    });
    const registerEnv = (env) => {
        globalThis.process || (globalThis.process = {});
        globalThis.process.env = {
            ...globalThis.process.env,
            ...env
        };
    };
    const registerMethods = (methods) => {
        for (const name in methods) {
            const method = methods[name];
            if (typeof method === 'function') {
                registry[name] = method;
            }
            else {
                log(`Method "${name}" is not a function and will be ignored`);
            }
        }
    };
    /* RETURN */
    return { ready, registerEnv, registerMethods };
})();
export {};
/*! BOOTLOADER_PLACEHOLDER !*/