factory.js

'use strict';


/**
 * @author schukai GmbH
 */


import {internalSymbol} from "../../constants.js";
import {assignToNamespace, Monster} from "../../namespace.js";
import {Base} from "../../types/base.js";
import {getGlobal, getGlobalFunction} from "../../types/global.js";
import {isFunction} from "../../types/is.js";
import {validateInstance, validateString} from "../../types/validate.js";



/**
 * You can call the function via the monster namespace `new Monster.DOM.Worker.getLocaleOfDocument()`.
 *
 * ```
 * <script type="module">
 * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
 * console.log(new Monster.DOM.Worker.Factory())
 * </script>
 * ```
 *
 * Alternatively, you can also integrate this function individually.
 *
 * ```
 * <script type="module">
 * import {Factory} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/dom/worker/factory.js';
 * console.log(new Factory())
 * </script>
 * ```
 *
 * @since 1.25.0
 * @copyright schukai GmbH
 * @memberOf Monster.DOM.Worker
 * @summary A small factory to create worker
 */
class Factory extends Base {


    /**
     *
     */
    constructor() {
        super();
        this[internalSymbol] = {
            worker: new WeakMap
        }
    }

    /**
     * Creates a worker from a URL
     *
     * @param {string|URL} url
     * @param {function} messageHandler
     * @param {function} errorHandler
     * @return {Worker}
     */
    createFromURL = function (url, messageHandler, errorHandler) {

        if (url instanceof URL) {
            url = url.toString();
        }

        const workerClass = getGlobalFunction('Worker');
        var worker = new workerClass(validateString(url));

        if (isFunction(messageHandler)) {
            worker.onmessage = (event) => {
                messageHandler.call(worker, event);
            }
        }

        if (isFunction(errorHandler)) {
            worker.onerror = (event) => {
                errorHandler.call(worker, event);
            }
        }

        return worker;
    };

    /**
     * Creates a worker from a script
     *
     * @param {string} content
     * @param {function} messageHandler
     * @param {function} errorHandler
     * @return {Worker}
     * @see https://developer.mozilla.org/de/docs/Web/API/URL/createObjectURL
     */
    createFromScript = function (content, messageHandler, errorHandler) {
        const blobFunction = new getGlobalFunction('Blob')
        const blob = new blobFunction([validateString(content)], {type: 'script/javascript'});

        const url = getGlobalFunction('URL').createObjectURL(blob);
        const worker = this.createFromURL(url, messageHandler, errorHandler);

        this[internalSymbol]['worker'].set(worker, url);

        return worker;

    };

    /**
     * Terminate the worker and call revokeObjectURL if necessary.
     *
     * @param worker
     * @return {Monster.DOM.Worker.Factory}
     */
    terminate(worker) {

        const workerClass = getGlobalFunction('Worker');
        validateInstance(worker, workerClass);

        worker.terminate();

        if (this[internalSymbol]['worker'].has(worker)) {
            const url = this[internalSymbol]['worker'].get(worker);
            URL.revokeObjectURL(url);
        }

        return this;
    }


}

assignToNamespace('Monster.DOM.Worker', Factory);
export {Monster, Factory}