Spawn dedicated, shared, and service workers in 1 window script (4 scopes in 1 script)

[abrahamjuliot]

// worker.js functions as both a window and worker script

const getWorkerData = async () => {
  // return some data
}

// Tests
const isWorker = !globalThis.document && !!globalThis.WorkerGlobalScope
const isSharedWorker = !!globalThis.SharedWorkerGlobalScope
const isServiceWorker = !!globalThis.ServiceWorkerGlobalScope

// WorkerGlobalScope
const getWorkerGlobalScope = async () => {
  const data = await getWorkerData()
  postMessage(data)
  close()
}

const getDedicatedWorker = () => {
  return new Promise(resolve => {
    try {
      const dedicatedWorker = new Worker(document.currentScript.src)
      dedicatedWorker.onmessage = message => {
        dedicatedWorker.terminate()
        return resolve(message.data)
      }
    } catch (error) {
      console.error(error)
      return resolve({})
    }
  })
}

// SharedWorkerGlobalScope
const getSharedWorkerGlobalScope = () => {
  onconnect = async message => {
    const port = message.ports[0]
    const data = await getWorkerData()
    port.postMessage(data)
  }
}

const getSharedWorker = () => {
  return new Promise(resolve => {
    try {
      const sharedWorker = new SharedWorker(document.currentScript.src)
      sharedWorker.port.start()
      sharedWorker.port.addEventListener('message', message => {
        sharedWorker.port.close()
        return resolve(message.data)
      })
    } catch (error) {
      console.error(error)
      return resolve({})
    }
  })
}

// ServiceWorkerGlobalScope
const getServiceWorkerGlobalScope = () => {
  const broadcast = new BroadcastChannel('creep_service')
  broadcast.onmessage = async event => {
    if (event.data && event.data.type == 'fingerprint') {
      const data = await getWorkerData()
      broadcast.postMessage(data)
    }
  }
}

const getServiceWorker = () => {
  return new Promise(async resolve => {
    try {
      navigator.serviceWorker.register(document.currentScript.src, {
        scope: '../tests/'
      }).catch(error => {
        console.error(error)
        return resolve({})
      })
      navigator.serviceWorker.ready.then(registration => {
        const broadcast = new BroadcastChannel('creep_service')
        broadcast.onmessage = message => {
          registration.unregister()
          broadcast.close()
          return resolve(message.data)
        }
        return broadcast.postMessage({
          type: 'fingerprint'
        })
      }).catch(error => {
        console.error(error)
        return resolve({})
      })
    } catch (error) {
      console.error(error)
      return resolve({})
    }
  })
}

// WorkerGlobalScope
if (isWorker) {
  return (
    isServiceWorker ? getServiceWorkerGlobalScope() :
    isSharedWorker ? getSharedWorkerGlobalScope() :
    getWorkerGlobalScope()
  )
}

// Window
const [
  windowScope,
  dedicatedWorker,
  sharedWorker,
  serviceWorker
] = await Promise.all([
  getWorkerData(),
  getDedicatedWorker(),
  getSharedWorker(),
  getServiceWorker()
]).catch(error => {
  console.error(error.message)
})

const json = x => JSON.stringify(x, null, '\t')
//console.log(`\nWorker: ${json(dedicatedWorker)}`)
//console.log(`\nSharedWorker: ${json(sharedWorker)}`)
//console.log(`\nServiceWorker: ${json(serviceWorker)}`)