@loaders.gl/worker-utils 3.1.0-alpha.5 → 3.1.0-beta.4

package/dist/lib/worker-api/process-on-worker.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOnWorker = exports.canProcessOnWorker = void 0;
+const worker_farm_1 = __importDefault(require("../worker-farm/worker-farm"));
+const remove_nontransferable_options_1 = require("../worker-utils/remove-nontransferable-options");
+const get_worker_url_1 = require("./get-worker-url");
+/**
+ * Determines if we can parse with worker
+ * @param loader
+ * @param data
+ * @param options
+ */
+function canProcessOnWorker(worker, options) {
+    if (!worker_farm_1.default.isSupported()) {
+        return false;
+    }
+    return worker.worker && options?.worker;
+}
+exports.canProcessOnWorker = canProcessOnWorker;
+/**
+ * This function expects that the worker thread sends certain messages,
+ * Creating such a worker can be automated if the worker is wrapper by a call to
+ * createWorker in @loaders.gl/worker-utils.
+ */
+async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = (0, get_worker_url_1.getWorkerName)(worker);
+    const url = (0, get_worker_url_1.getWorkerURL)(worker, options);
+    const workerFarm = worker_farm_1.default.getWorkerFarm(options);
+    const workerPool = workerFarm.getWorkerPool({ name, url });
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, 
+    // eslint-disable-next-line
+    onMessage.bind(null, context));
+    // Kick off the processing in the worker
+    const transferableOptions = (0, remove_nontransferable_options_1.removeNontransferableOptions)(options);
+    job.postMessage('process', { input: data, options: transferableOptions });
+    const result = await job.result;
+    return result.result;
+}
+exports.processOnWorker = processOnWorker;
+/**
+ * Job completes when we receive the result
+ * @param job
+ * @param message
+ */
+async function onMessage(context, job, type, payload) {
+    switch (type) {
+        case 'done':
+            // Worker is done
+            job.done(payload);
+            break;
+        case 'error':
+            // Worker encountered an error
+            job.error(new Error(payload.error));
+            break;
+        case 'process':
+            // Worker is asking for us (main thread) to process something
+            const { id, input, options } = payload;
+            try {
+                if (!context.process) {
+                    job.postMessage('error', { id, error: 'Worker not set up to process on main thread' });
+                    return;
+                }
+                const result = await context.process(input, options);
+                job.postMessage('done', { id, result });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'unknown error';
+                job.postMessage('error', { id, error: message });
+            }
+            break;
+        default:
+            // eslint-disable-next-line
+            console.warn(`process-on-worker: unknown message ${type}`);
+    }
+}

package/dist/lib/worker-api/validate-worker-version.d.ts

@@ -6,3 +6,4 @@ import type { WorkerObject } from '../../types';
  * @returns `true` if the two versions are compatible
  */
 export declare function validateWorkerVersion(worker: WorkerObject, coreVersion?: string): boolean;
+//# sourceMappingURL=validate-worker-version.d.ts.map

package/dist/lib/worker-api/validate-worker-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-worker-version.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-api/validate-worker-version.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAI9C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,WAAW,GAAE,MAAgB,GAC5B,OAAO,CAmBT"}

package/dist/lib/worker-api/validate-worker-version.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkerVersion = void 0;
+const assert_1 = require("../env-utils/assert");
+const version_1 = require("../env-utils/version");
+/**
+ * Check if worker is compatible with this library version
+ * @param worker
+ * @param libVersion
+ * @returns `true` if the two versions are compatible
+ */
+function validateWorkerVersion(worker, coreVersion = version_1.VERSION) {
+    (0, assert_1.assert)(worker, 'no worker provided');
+    const workerVersion = worker.version;
+    if (!coreVersion || !workerVersion) {
+        return false;
+    }
+    // TODO enable when fix the __version__ injection
+    // const coreVersions = parseVersion(coreVersion);
+    // const workerVersions = parseVersion(workerVersion);
+    // assert(
+    //   coreVersion.major === workerVersion.major && coreVersion.minor <= workerVersion.minor,
+    //   `worker: ${worker.name} is not compatible. ${coreVersion.major}.${
+    //     coreVersion.minor
+    //   }+ is required.`
+    // );
+    return true;
+}
+exports.validateWorkerVersion = validateWorkerVersion;
+// @ts-ignore
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function parseVersion(version) {
+    const parts = version.split('.').map(Number);
+    return { major: parts[0], minor: parts[1] };
+}

package/dist/lib/worker-farm/worker-body.d.ts

@@ -13,3 +13,4 @@ export default class WorkerBody {
      */
     static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void;
 }
+//# sourceMappingURL=worker-body.d.ts.map

package/dist/lib/worker-farm/worker-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-body.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,iBAAiB,EAAE,oBAAoB,EAAC,MAAM,aAAa,CAAC;AAK5F;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAI7B,MAAM,KAAK,SAAS,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,KAAK,GAAG,EAW9F;IAED,MAAM,CAAC,gBAAgB,CACrB,SAAS,EAAE,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,KAAK,GAAG;IAoB5E,MAAM,CAAC,mBAAmB,CACxB,SAAS,EAAE,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,KAAK,GAAG;IAQ5E;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI;CASjF"}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_transfer_list_1 = require("../worker-utils/get-transfer-list");
+const onMessageWrapperMap = new Map();
+/**
+ * Type safe wrapper for worker code
+ */
+class WorkerBody {
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
+    static set onmessage(onMessage) {
+        // eslint-disable-next-line no-restricted-globals
+        self.onmessage = (message) => {
+            if (!isKnownMessage(message)) {
+                return;
+            }
+            // Confusingly the message itself also has a 'type' field which is always set to 'message'
+            const { type, payload } = message.data;
+            onMessage(type, payload);
+        };
+    }
+    static addEventListener(onMessage) {
+        let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+        if (!onMessageWrapper) {
+            onMessageWrapper = (message) => {
+                if (!isKnownMessage(message)) {
+                    return;
+                }
+                // Confusingly the message itself also has a 'type' field which is always set to 'message'
+                const { type, payload } = message.data;
+                onMessage(type, payload);
+            };
+        }
+        // eslint-disable-next-line no-restricted-globals
+        self.addEventListener('message', onMessageWrapper);
+    }
+    static removeEventListener(onMessage) {
+        const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+        onMessageWrapperMap.delete(onMessage);
+        // eslint-disable-next-line no-restricted-globals
+        self.removeEventListener('message', onMessageWrapper);
+    }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
+    static postMessage(type, payload) {
+        if (self) {
+            const data = { source: 'loaders.gl', type, payload };
+            const transferList = (0, get_transfer_list_1.getTransferList)(payload);
+            // eslint-disable-next-line no-restricted-globals
+            // @ts-ignore
+            self.postMessage(data, transferList);
+        }
+    }
+}
+exports.default = WorkerBody;
+// Filter out noise messages sent to workers
+function isKnownMessage(message) {
+    const { type, data } = message;
+    return (type === 'message' &&
+        data &&
+        typeof data.source === 'string' &&
+        data.source.startsWith('loaders.gl'));
+}

package/dist/lib/worker-farm/worker-farm.d.ts

@@ -52,3 +52,4 @@ export default class WorkerFarm {
         onDebug: (() => void) | undefined;
     };
 }
+//# sourceMappingURL=worker-farm.d.ts.map

package/dist/lib/worker-farm/worker-farm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-farm.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-farm.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,eAAe,CAAC;AAGvC;;GAEG;AACH,oBAAY,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AASF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,WAAW,CAAiC;IAEpD,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAa;IAExC,qCAAqC;IACrC,MAAM,CAAC,WAAW,IAAI,OAAO;IAI7B,2DAA2D;IAC3D,MAAM,CAAC,aAAa,CAAC,KAAK,GAAE,eAAoB,GAAG,UAAU;IAM7D,0DAA0D;IAC1D,OAAO;IAOP;;;OAGG;IACH,OAAO,IAAI,IAAI;IAMf;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAQtC;;;;;;;;OAQG;IACH,aAAa,CAAC,OAAO,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,UAAU;IAejF,mBAAmB;;;;;;CAQpB"}

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

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_pool_1 = __importDefault(require("./worker-pool"));
+const worker_thread_1 = __importDefault(require("./worker-thread"));
+const DEFAULT_PROPS = {
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    onDebug: () => { },
+    reuseWorkers: true
+};
+/**
+ * Process multiple jobs with a "farm" of different workers in worker pools.
+ */
+class WorkerFarm {
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+        this.workerPools = new Map();
+        this.props = { ...DEFAULT_PROPS };
+        this.setProps(props);
+        /** @type Map<string, WorkerPool>} */
+        this.workerPools = new Map();
+    }
+    /** Check if Workers are supported */
+    static isSupported() {
+        return worker_thread_1.default.isSupported();
+    }
+    /** Get the singleton instance of the global worker farm */
+    static getWorkerFarm(props = {}) {
+        WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
+        WorkerFarm._workerFarm.setProps(props);
+        return WorkerFarm._workerFarm;
+    }
+    /**
+     * Terminate all workers in the farm
+     * @note Can free up significant memory
+     */
+    destroy() {
+        for (const workerPool of this.workerPools.values()) {
+            workerPool.destroy();
+        }
+    }
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
+    setProps(props) {
+        this.props = { ...this.props, ...props };
+        // Update worker pool props
+        for (const workerPool of this.workerPools.values()) {
+            workerPool.setProps(this._getWorkerPoolProps());
+        }
+    }
+    /**
+     * Returns a worker pool for the specified worker
+     * @param options - only used first time for a specific worker name
+     * @param options.name - the name of the worker - used to identify worker pool
+     * @param options.url -
+     * @param options.source -
+     * @example
+     *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+     */
+    getWorkerPool(options) {
+        const { name, source, url } = options;
+        let workerPool = this.workerPools.get(name);
+        if (!workerPool) {
+            workerPool = new worker_pool_1.default({
+                name,
+                source,
+                url
+            });
+            workerPool.setProps(this._getWorkerPoolProps());
+            this.workerPools.set(name, workerPool);
+        }
+        return workerPool;
+    }
+    _getWorkerPoolProps() {
+        return {
+            maxConcurrency: this.props.maxConcurrency,
+            maxMobileConcurrency: this.props.maxMobileConcurrency,
+            reuseWorkers: this.props.reuseWorkers,
+            onDebug: this.props.onDebug
+        };
+    }
+}
+exports.default = WorkerFarm;

package/dist/lib/worker-farm/worker-job.d.ts

@@ -24,5 +24,6 @@ export default class WorkerJob {
     /**
      * Call to reject the `result` Promise with the supplied error
      */
-    error(error: any): void;
+    error(error: Error): void;
 }
+//# sourceMappingURL=worker-job.d.ts.map

package/dist/lib/worker-farm/worker-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-job.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-job.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAE,oBAAoB,EAAC,MAAM,aAAa,CAAC;AACzE,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAG3C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,OAAO,CAAyB;gBAE5B,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY;IAYvD;;;OAGG;IACH,WAAW,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAQzE;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAMtB;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAK1B"}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("../env-utils/assert");
+/**
+ * Represents one Job handled by a WorkerPool or WorkerFarm
+ */
+class WorkerJob {
+    constructor(jobName, workerThread) {
+        this.name = jobName;
+        this.workerThread = workerThread;
+        this.isRunning = true;
+        this._resolve = () => { };
+        this._reject = () => { };
+        this.result = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+    }
+    /**
+     * Send a message to the job's worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     */
+    postMessage(type, payload) {
+        this.workerThread.postMessage({
+            source: 'loaders.gl',
+            type,
+            payload
+        });
+    }
+    /**
+     * Call to resolve the `result` Promise with the supplied value
+     */
+    done(value) {
+        (0, assert_1.assert)(this.isRunning);
+        this.isRunning = false;
+        this._resolve(value);
+    }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
+    error(error) {
+        (0, assert_1.assert)(this.isRunning);
+        this.isRunning = false;
+        this._reject(error);
+    }
+}
+exports.default = WorkerJob;

package/dist/lib/worker-farm/worker-pool.d.ts

@@ -72,3 +72,4 @@ export default class WorkerPool {
     _getMaxConcurrency(): number;
 }
 export {};
+//# sourceMappingURL=worker-pool.d.ts.map

package/dist/lib/worker-farm/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAE,oBAAoB,EAAC,MAAM,aAAa,CAAC;AAEzE,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAC3C,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,6CAA6C;AAC7C,aAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,4BAA4B;AAC5B,oBAAY,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,GAAG,CAAC;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,2BAA2B;AAC3B,aAAK,SAAS,GAAG,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;AAClG,aAAK,OAAO,GAAG,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAStD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,IAAI,EAAE,MAAM,CAAa;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAK;IAC3B,oBAAoB,EAAE,MAAM,CAAK;IACjC,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,GAAG,CAAY;IACxD,YAAY,EAAE,OAAO,CAAQ;IAE7B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,WAAW,CAAS;IAE5B;;;OAGG;gBACS,KAAK,EAAE,eAAe;IAMlC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAMf,QAAQ,CAAC,KAAK,EAAE,eAAe;IAoBzB,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,SAA+C,EAC1D,OAAO,GAAE,OAA0C,GAClD,OAAO,CAAC,SAAS,CAAC;IAarB;;;OAGG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAyCtC;;;;;;;OAOG;IACH,mBAAmB,CAAC,MAAM,EAAE,YAAY;IAgBxC;;OAEG;IACH,mBAAmB,IAAI,YAAY,GAAG,IAAI;IAiB1C,kBAAkB;CAGnB"}

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

@@ -0,0 +1,151 @@
+"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 {
+    /**
+     * @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.d.ts

@@ -33,9 +33,10 @@ export default class WorkerThread {
      * Generate a standard Error from an ErrorEvent
      * @param {ErrorEvent} event
      */
-    _getErrorFromErrorEvent(event: any): Error;
+    _getErrorFromErrorEvent(event: ErrorEvent): Error;
     /**
      * Creates a worker thread on the browser
      */
     _createBrowserWorker(): Worker;
 }
+//# sourceMappingURL=worker-thread.d.ts.map

package/dist/lib/worker-farm/worker-thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-farm/worker-thread.ts"],"names":[],"mappings":"AAMA,oBAAY,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,OAAO,CAAS;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;IAClC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEhC,OAAO,CAAC,YAAY,CAAc;IAElC,MAAM,CAAC,WAAW,IAAI,OAAO;gBAIjB,KAAK,EAAE,iBAAiB;IAYpC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAQf,IAAI,SAAS,YAEZ;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI;IAQlD;;;OAGG;IACH,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAiBjD;;OAEG;IACH,oBAAoB;CAqBrB"}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 {
+    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 = this._createBrowserWorker();
+    }
+    static isSupported() {
+        return typeof Worker !== 'undefined';
+    }
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
+    destroy() {
+        this.onMessage = NOOP;
+        this.onError = NOOP;
+        // @ts-ignore
+        this.worker.terminate();
+        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 {ErrorEvent} 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;
+    }
+}
+exports.default = WorkerThread;

package/dist/lib/worker-utils/get-loadable-worker-url.d.ts

@@ -11,3 +11,4 @@ export declare function getLoadableWorkerURL(props: {
     source?: string;
     url?: string;
 }): any;
+//# sourceMappingURL=get-loadable-worker-url.d.ts.map

package/dist/lib/worker-utils/get-loadable-worker-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-loadable-worker-url.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-utils/get-loadable-worker-url.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,OAmB1E"}