@loaders.gl/worker-utils 3.4.11 → 3.4.12

package/dist/lib/worker-farm/worker-pool.js

@@ -1,155 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("../env-utils/globals");
-const worker_thread_1 = __importDefault(require("./worker-thread"));
-const worker_job_1 = __importDefault(require("./worker-job"));
-/**
- * Process multiple data messages with small pool of identical workers
- */
-class WorkerPool {
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-        return worker_thread_1.default.isSupported();
-    }
-    /**
-     * @param processor - worker function
-     * @param maxConcurrency - max count of workers
-     */
-    constructor(props) {
-        this.name = 'unnamed';
-        this.maxConcurrency = 1;
-        this.maxMobileConcurrency = 1;
-        this.onDebug = () => { };
-        this.reuseWorkers = true;
-        this.props = {};
-        this.jobQueue = [];
-        this.idleQueue = [];
-        this.count = 0;
-        this.isDestroyed = false;
-        this.source = props.source;
-        this.url = props.url;
-        this.setProps(props);
-    }
-    /**
-     * Terminates all workers in the pool
-     * @note Can free up significant memory
-     */
-    destroy() {
-        // Destroy idle workers, active Workers will be destroyed on completion
-        this.idleQueue.forEach((worker) => worker.destroy());
-        this.isDestroyed = true;
-    }
-    setProps(props) {
-        this.props = { ...this.props, ...props };
-        if (props.name !== undefined) {
-            this.name = props.name;
-        }
-        if (props.maxConcurrency !== undefined) {
-            this.maxConcurrency = props.maxConcurrency;
-        }
-        if (props.maxMobileConcurrency !== undefined) {
-            this.maxMobileConcurrency = props.maxMobileConcurrency;
-        }
-        if (props.reuseWorkers !== undefined) {
-            this.reuseWorkers = props.reuseWorkers;
-        }
-        if (props.onDebug !== undefined) {
-            this.onDebug = props.onDebug;
-        }
-    }
-    async startJob(name, onMessage = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-        // Promise resolves when thread starts working on this job
-        const startPromise = new Promise((onStart) => {
-            // Promise resolves when thread completes or fails working on this job
-            this.jobQueue.push({ name, onMessage, onError, onStart });
-            return this;
-        });
-        this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        return await startPromise;
-    }
-    // PRIVATE
-    /**
-     * Starts first queued job if worker is available or can be created
-     * Called when job is started and whenever a worker returns to the idleQueue
-     */
-    async _startQueuedJob() {
-        if (!this.jobQueue.length) {
-            return;
-        }
-        const workerThread = this._getAvailableWorker();
-        if (!workerThread) {
-            return;
-        }
-        // We have a worker, dequeue and start the job
-        const queuedJob = this.jobQueue.shift();
-        if (queuedJob) {
-            // Emit a debug event
-            // @ts-ignore
-            this.onDebug({
-                message: 'Starting job',
-                name: queuedJob.name,
-                workerThread,
-                backlog: this.jobQueue.length
-            });
-            // Create a worker job to let the app access thread and manage job completion
-            const job = new worker_job_1.default(queuedJob.name, workerThread);
-            // Set the worker thread's message handlers
-            workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
-            workerThread.onError = (error) => queuedJob.onError(job, error);
-            // Resolve the start promise so that the app can start sending messages to worker
-            queuedJob.onStart(job);
-            // Wait for the app to signal that the job is complete, then return worker to queue
-            try {
-                await job.result;
-            }
-            finally {
-                this.returnWorkerToQueue(workerThread);
-            }
-        }
-    }
-    /**
-     * Returns a worker to the idle queue
-     * Destroys the worker if
-     *  - pool is destroyed
-     *  - if this pool doesn't reuse workers
-     *  - if maxConcurrency has been lowered
-     * @param worker
-     */
-    returnWorkerToQueue(worker) {
-        const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
-        if (shouldDestroyWorker) {
-            worker.destroy();
-            this.count--;
-        }
-        else {
-            this.idleQueue.push(worker);
-        }
-        if (!this.isDestroyed) {
-            this._startQueuedJob(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        }
-    }
-    /**
-     * Returns idle worker or creates new worker if maxConcurrency has not been reached
-     */
-    _getAvailableWorker() {
-        // If a worker has completed and returned to the queue, it can be used
-        if (this.idleQueue.length > 0) {
-            return this.idleQueue.shift() || null;
-        }
-        // Create fresh worker if we haven't yet created the max amount of worker threads for this worker source
-        if (this.count < this._getMaxConcurrency()) {
-            this.count++;
-            const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-            return new worker_thread_1.default({ name, source: this.source, url: this.url });
-        }
-        // No worker available, have to wait
-        return null;
-    }
-    _getMaxConcurrency() {
-        return globals_1.isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
-    }
-}
-exports.default = WorkerPool;

package/dist/lib/worker-farm/worker-thread.js

@@ -1,131 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-const worker_threads_1 = require("../node/worker_threads");
-const globals_1 = require("../env-utils/globals");
-const assert_1 = require("../env-utils/assert");
-const get_loadable_worker_url_1 = require("../worker-utils/get-loadable-worker-url");
-const get_transfer_list_1 = require("../worker-utils/get-transfer-list");
-const NOOP = () => { };
-/**
- * Represents one worker thread
- */
-class WorkerThread {
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-        return ((typeof Worker !== 'undefined' && globals_1.isBrowser) ||
-            (typeof worker_threads_1.NodeWorker !== 'undefined' && !globals_1.isBrowser));
-    }
-    constructor(props) {
-        this.terminated = false;
-        this._loadableURL = '';
-        const { name, source, url } = props;
-        (0, assert_1.assert)(source || url); // Either source or url must be defined
-        this.name = name;
-        this.source = source;
-        this.url = url;
-        this.onMessage = NOOP;
-        this.onError = (error) => console.log(error); // eslint-disable-line
-        this.worker = globals_1.isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
-    }
-    /**
-     * Terminate this worker thread
-     * @note Can free up significant memory
-     */
-    destroy() {
-        this.onMessage = NOOP;
-        this.onError = NOOP;
-        this.worker.terminate(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        this.terminated = true;
-    }
-    get isRunning() {
-        return Boolean(this.onMessage);
-    }
-    /**
-     * Send a message to this worker thread
-     * @param data any data structure, ideally consisting mostly of transferrable objects
-     * @param transferList If not supplied, calculated automatically by traversing data
-     */
-    postMessage(data, transferList) {
-        transferList = transferList || (0, get_transfer_list_1.getTransferList)(data);
-        // @ts-ignore
-        this.worker.postMessage(data, transferList);
-    }
-    // PRIVATE
-    /**
-     * Generate a standard Error from an ErrorEvent
-     * @param event
-     */
-    _getErrorFromErrorEvent(event) {
-        // Note Error object does not have the expected fields if loading failed completely
-        // https://developer.mozilla.org/en-US/docs/Web/API/Worker#Event_handlers
-        // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
-        let message = 'Failed to load ';
-        message += `worker ${this.name} from ${this.url}. `;
-        if (event.message) {
-            message += `${event.message} in `;
-        }
-        // const hasFilename = event.filename && !event.filename.startsWith('blob:');
-        // message += hasFilename ? event.filename : this.source.slice(0, 100);
-        if (event.lineno) {
-            message += `:${event.lineno}:${event.colno}`;
-        }
-        return new Error(message);
-    }
-    /**
-     * Creates a worker thread on the browser
-     */
-    _createBrowserWorker() {
-        this._loadableURL = (0, get_loadable_worker_url_1.getLoadableWorkerURL)({ source: this.source, url: this.url });
-        const worker = new Worker(this._loadableURL, { name: this.name });
-        worker.onmessage = (event) => {
-            if (!event.data) {
-                this.onError(new Error('No data received'));
-            }
-            else {
-                this.onMessage(event.data);
-            }
-        };
-        // This callback represents an uncaught exception in the worker thread
-        worker.onerror = (error) => {
-            this.onError(this._getErrorFromErrorEvent(error));
-            this.terminated = true;
-        };
-        // TODO - not clear when this would be called, for now just log in case it happens
-        worker.onmessageerror = (event) => console.error(event); // eslint-disable-line
-        return worker;
-    }
-    /**
-     * Creates a worker thread in node.js
-     * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
-     */
-    _createNodeWorker() {
-        let worker;
-        if (this.url) {
-            // Make sure relative URLs start with './'
-            const absolute = this.url.includes(':/') || this.url.startsWith('/');
-            const url = absolute ? this.url : `./${this.url}`;
-            // console.log('Starting work from', url);
-            worker = new worker_threads_1.NodeWorker(url, { eval: false });
-        }
-        else if (this.source) {
-            worker = new worker_threads_1.NodeWorker(this.source, { eval: true });
-        }
-        else {
-            throw new Error('no worker');
-        }
-        worker.on('message', (data) => {
-            // console.error('message', data);
-            this.onMessage(data);
-        });
-        worker.on('error', (error) => {
-            // console.error('error', error);
-            this.onError(error);
-        });
-        worker.on('exit', (code) => {
-            // console.error('exit', code);
-        });
-        return worker;
-    }
-}
-exports.default = WorkerThread;

package/dist/lib/worker-utils/get-loadable-worker-url.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLoadableWorkerURL = void 0;
-const assert_1 = require("../env-utils/assert");
-const workerURLCache = new Map();
-/**
- * Creates a loadable URL from worker source or URL
- * that can be used to create `Worker` instances.
- * Due to CORS issues it may be necessary to wrap a URL in a small importScripts
- * @param props
- * @param props.source Worker source
- * @param props.url Worker URL
- * @returns loadable url
- */
-function getLoadableWorkerURL(props) {
-    (0, assert_1.assert)((props.source && !props.url) || (!props.source && props.url)); // Either source or url must be defined
-    let workerURL = workerURLCache.get(props.source || props.url);
-    if (!workerURL) {
-        // Differentiate worker urls from worker source code
-        if (props.url) {
-            workerURL = getLoadableWorkerURLFromURL(props.url);
-            workerURLCache.set(props.url, workerURL);
-        }
-        if (props.source) {
-            workerURL = getLoadableWorkerURLFromSource(props.source);
-            workerURLCache.set(props.source, workerURL);
-        }
-    }
-    (0, assert_1.assert)(workerURL);
-    return workerURL;
-}
-exports.getLoadableWorkerURL = getLoadableWorkerURL;
-/**
- * Build a loadable worker URL from worker URL
- * @param url
- * @returns loadable URL
- */
-function getLoadableWorkerURLFromURL(url) {
-    // A local script url, we can use it to initialize a Worker directly
-    if (!url.startsWith('http')) {
-        return url;
-    }
-    // A remote script, we need to use `importScripts` to load from different origin
-    const workerSource = buildScriptSource(url);
-    return getLoadableWorkerURLFromSource(workerSource);
-}
-/**
- * Build a loadable worker URL from worker source
- * @param workerSource
- * @returns loadable url
- */
-function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], { type: 'application/javascript' });
-    return URL.createObjectURL(blob);
-}
-/**
- * Per spec, worker cannot be initialized with a script from a different origin
- * However a local worker script can still import scripts from other origins,
- * so we simply build a wrapper script.
- *
- * @param workerUrl
- * @returns source
- */
-function buildScriptSource(workerUrl) {
-    return `\
-try {
-  importScripts('${workerUrl}');
-} catch (error) {
-  console.error(error);
-  throw error;
-}`;
-}

package/dist/lib/worker-utils/get-transfer-list.js

@@ -1,87 +0,0 @@
-"use strict";
-// NOTE - there is a copy of this function is both in core and loader-utils
-// core does not need all the utils in loader-utils, just this one.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransferListForWriter = exports.getTransferList = void 0;
-/**
- * Returns an array of Transferrable objects that can be used with postMessage
- * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage
- * @param object data to be sent via postMessage
- * @param recursive - not for application use
- * @param transfers - not for application use
- * @returns a transfer list that can be passed to postMessage
- */
-function getTransferList(object, recursive = true, transfers) {
-    // Make sure that items in the transfer list is unique
-    const transfersSet = transfers || new Set();
-    if (!object) {
-        // ignore
-    }
-    else if (isTransferable(object)) {
-        transfersSet.add(object);
-    }
-    else if (isTransferable(object.buffer)) {
-        // Typed array
-        transfersSet.add(object.buffer);
-    }
-    else if (ArrayBuffer.isView(object)) {
-        // object is a TypeArray viewing into a SharedArrayBuffer (not transferable)
-        // Do not iterate through the content in this case
-    }
-    else if (recursive && typeof object === 'object') {
-        for (const key in object) {
-            // Avoid perf hit - only go one level deep
-            getTransferList(object[key], recursive, transfersSet);
-        }
-    }
-    // If transfers is defined, is internal recursive call
-    // Otherwise it's called by the user
-    return transfers === undefined ? Array.from(transfersSet) : [];
-}
-exports.getTransferList = getTransferList;
-// https://developer.mozilla.org/en-US/docs/Web/API/Transferable
-function isTransferable(object) {
-    if (!object) {
-        return false;
-    }
-    if (object instanceof ArrayBuffer) {
-        return true;
-    }
-    if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {
-        return true;
-    }
-    if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {
-        return true;
-    }
-    // @ts-ignore
-    if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {
-        return true;
-    }
-    return false;
-}
-/**
- * Recursively drop non serializable values like functions and regexps.
- * @param object
- */
-function getTransferListForWriter(object) {
-    if (object === null) {
-        return {};
-    }
-    const clone = Object.assign({}, object);
-    Object.keys(clone).forEach((key) => {
-        // Typed Arrays and Arrays are passed with no change
-        if (typeof object[key] === 'object' &&
-            !ArrayBuffer.isView(object[key]) &&
-            !(object[key] instanceof Array)) {
-            clone[key] = getTransferListForWriter(object[key]);
-        }
-        else if (typeof clone[key] === 'function' || clone[key] instanceof RegExp) {
-            clone[key] = {};
-        }
-        else {
-            clone[key] = object[key];
-        }
-    });
-    return clone;
-}
-exports.getTransferListForWriter = getTransferListForWriter;

package/dist/lib/worker-utils/remove-nontransferable-options.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeNontransferableOptions = void 0;
-/**
- * Recursively drop non serializable values like functions and regexps.
- * @param object
- */
-function removeNontransferableOptions(object) {
-    if (object === null) {
-        return {};
-    }
-    const clone = Object.assign({}, object);
-    Object.keys(clone).forEach((key) => {
-        // Checking if it is an object and not a typed array.
-        if (typeof object[key] === 'object' && !ArrayBuffer.isView(object[key])) {
-            clone[key] = removeNontransferableOptions(object[key]);
-        }
-        else if (typeof clone[key] === 'function' || clone[key] instanceof RegExp) {
-            clone[key] = {};
-        }
-        else {
-            clone[key] = object[key];
-        }
-    });
-    return clone;
-}
-exports.removeNontransferableOptions = removeNontransferableOptions;

package/dist/types.js

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

package/dist/workers/null-worker.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const create_worker_1 = require("../lib/worker-api/create-worker");
-(0, create_worker_1.createWorker)(async (data) => {
-    // @ts-ignore
-    return data;
-});