js const rs = new ReadableStream({ start(controller) { controller.enqueue('hello'); } }); const w = new Worker('worker.js'); w.postMessage(rs, [rs]);

js onmessage = async (evt) => { const rs = evt.data; const reader = rs.getReader(); const {value, done} = await reader.read(); console.log(value); // logs 'hello'. };

```js import { ReadableStream } from 'node:stream/web'; import { Worker } from 'node:worker_threads';

const readable = new ReadableStream(getSomeSource());

const worker = new Worker('/path/to/worker.js', { workerData: readable, transferList: [readable], }); ```

```js const { workerData: stream } = require('worker_threads');

const reader = stream.getReader(); reader.read().then(console.log); ```

A note on setting worker-loader’s publicPath with webpack 5

Webpack 5 introduced a mechanism to detect the publicPath that should be used automatically

[...]

Webpack 5 exposes a global variable called __webpack_public_path__ that allows you to do that.

// Updates the `publicPath` at runtime, overriding whatever was set in the
// webpack's `output` section.
__webpack_public_path__ = "/workers/";

const myWorker = new Worker(
  new URL("/workers/worker.js");
);

// Eventually, restore the `publicPath` to whatever was set in output.
__webpack_public_path__ = "https://my-static-cdn/";

Web Workers

As of webpack 5, you can use Web Workers without worker-loader.

Syntax

new Worker(new URL('./worker.js', import.meta.url));

// main.js
const { RemoteReadableStream, RemoteWritableStream } = RemoteWebStreams;
(async () => {
  const worker = new Worker('./worker.js');
  // create a stream to send the input to the worker
  const { writable, readablePort } = new RemoteWritableStream();
  // create a stream to receive the output from the worker
  const { readable, writablePort } = new RemoteReadableStream();
  // transfer the other ends to the worker
  worker.postMessage({ readablePort, writablePort }, [readablePort, writablePort]);

  const response = await fetch('./some-data.txt');
  await response.body
    // send the downloaded data to the worker
    // and receive the results back
    .pipeThrough({ readable, writable })
    // show the results as they come in
    .pipeTo(new WritableStream({
      write(chunk) {
        const results = document.getElementById('results');
        results.appendChild(document.createTextNode(chunk)); // tadaa!
      }
    }));
})();

// worker.js
const { fromReadablePort, fromWritablePort } = RemoteWebStreams;
self.onmessage = async (event) => {
  // create the input and output streams from the transferred ports
  const { readablePort, writablePort } = event.data;
  const readable = fromReadablePort(readablePort);
  const writable = fromWritablePort(writablePort);

  // process data
  await readable
    .pipeThrough(new TransformStream({
      transform(chunk, controller) {
        controller.enqueue(process(chunk)); // do the actual work
      }
    }))
    .pipeTo(writable); // send the results back to main thread
};

// To know the maximum numbers of thread that can be used
// on user’s system, use

window.navigator.hardwareConcurrency property.

I wonder how can we identify issues like this when they occur