awv3-protocol/src/unpack.js

import v4 from 'uuid-v4'

export class Unpack {
    constructor() {
        this.id = v4()
        this.worker = new Worker(window.URL.createObjectURL(new Blob([require('../dist/bundle.js')])))
        this.promises = {}
        this.requests = 0

        this.worker.addEventListener(
            'message',
            message => {
                switch (message.data.action) {
                    case 'Finished':
                        var resolve = this.promises[message.data.task].resolve
                        delete this.promises[message.data.task]
                        resolve(message.data)

                        if (--this.requests < 0) this.requests = 0
                        break

                    case 'Result':
                        if (!!this.promises[message.data.task].callback) {
                            this.promises[message.data.task].callback(message.data.result)
                        }
                        break
                }
            },
            false,
        )
    }

    // Post message to worker
    post(obj, callback) {
        obj.parent = this.id
        obj.task = v4()
        let task = { callback: callback }
        this.promises[obj.task] = task
        task.promise = new Promise(resolve => {
            task.resolve = resolve
            if (obj.type === 'Binary') {
                this.worker.postMessage(obj, [obj.data.buffer])
            } else {
                this.worker.postMessage(JSON.stringify(obj))
            }
        })
        return task.promise
    }

    // This will race for a unused core
    static getFreeCore() {
        let core = undefined
        for (let candidate of cores) {
            if (candidate.requests == 0 && Object.keys(candidate.promises).length == 0) {
                core = candidate
                break
            }
        }

        if (core === undefined) {
            const sorted = cores.sort((a, b) => a.requests > b.requests)
            const candidates = sorted.filter(c => c.requests === sorted[0].requests)
            core = candidates[Math.round(Math.random() * (candidates.length - 1))]
        }

        core.requests++
        return core
    }

    static callWorkers(props) {
        for (let core of cores) {
            core.worker.postMessage(props)
        }
    }
}

// Create a worker for each core
let cores = Array.from(new Array(navigator.hardwareConcurrency || 4), () => new Unpack())

// Packs ArrayBuffer into deflated base64 for ClassCAD stream consumption
export default function unpack(object, callback) {
    return Unpack.getFreeCore().post(object, callback)
}