Product
Introducing License Enforcement in Socket
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
worker-loader
Advanced tools
The worker-loader npm package is a webpack loader that allows you to create web workers from your JavaScript files. It simplifies the process of offloading tasks to background threads, which can help improve the performance of your web applications by handling CPU-intensive operations without blocking the main thread.
Basic Web Worker Setup
This feature allows you to set up a basic web worker using worker-loader. The code demonstrates how to import a worker script, create a new worker instance, send a message to the worker, and handle messages received from the worker.
const Worker = require('worker-loader!./worker.js');
const worker = new Worker();
worker.postMessage({ message: 'Hello, Worker!' });
worker.onmessage = function(event) {
console.log('Received from worker:', event.data);
};
Handling Multiple Workers
This feature demonstrates how to handle multiple web workers simultaneously. The code shows how to import and create instances of different worker scripts, send tasks to each worker, and handle their responses independently.
const Worker1 = require('worker-loader!./worker1.js');
const Worker2 = require('worker-loader!./worker2.js');
const worker1 = new Worker1();
const worker2 = new Worker2();
worker1.postMessage({ task: 'Task 1' });
worker2.postMessage({ task: 'Task 2' });
worker1.onmessage = function(event) {
console.log('Worker 1 completed:', event.data);
};
worker2.onmessage = function(event) {
console.log('Worker 2 completed:', event.data);
};
Using Web Workers with TypeScript
This feature illustrates how to use worker-loader with TypeScript. The code demonstrates importing a TypeScript worker script, creating a worker instance, sending a message to the worker, and handling the response.
import Worker from 'worker-loader!./worker.ts';
const worker = new Worker();
worker.postMessage({ message: 'Hello, TypeScript Worker!' });
worker.onmessage = function(event) {
console.log('Received from TypeScript worker:', event.data);
};
Comlink is a library that simplifies the use of Web Workers by providing a proxy-based API. It allows you to call functions in the worker as if they were local functions, making the communication between the main thread and the worker more intuitive. Compared to worker-loader, Comlink offers a higher-level abstraction for worker communication.
Threads is a library that provides a simple and modern API for using Web Workers. It supports both JavaScript and TypeScript and offers features like thread pools and message channels. Threads focuses on ease of use and performance, making it a good alternative to worker-loader for more complex worker management.
Greenlet is a lightweight library that allows you to run functions in a Web Worker with minimal overhead. It provides a simple API for offloading functions to a worker and returning the results as promises. Greenlet is a good choice for projects that need a minimalistic solution for using Web Workers compared to the more feature-rich worker-loader.
npm i -D worker-loader
Inlined
App.js
import Worker from 'worker-loader!./Worker.js';
Config
webpack.config.js
{
module: {
rules: [
{
test: /\.worker\.js$/,
use: { loader: 'worker-loader' }
}
]
}
}
App.js
import Worker from './file.worker.js';
const worker = new Worker();
worker.postMessage({ a: 1 });
worker.onmessage = function (event) {};
worker.addEventListener("message", function (event) {});
Name | Type | Default | Description |
---|---|---|---|
name | {String} | [hash].worker.js | Set a custom name for the output script |
inline | {Boolean} | false | Inline the worker as a BLOB |
fallback | {Boolean} | false | Require a fallback for non-worker supporting environments |
publicPath | {String} | null | Override the path from which worker scripts are downloaded |
name
To set a custom name for the output script, use the name
parameter. The name may contain the string [hash]
, which will be replaced with a content dependent hash for caching purposes
webpack.config.js*
{
loader: 'worker-loader',
options: { name: 'WorkerName.[hash].js' }
}
inline
You can also inline the worker as a BLOB with the inline
parameter
webpack.config.js
{
loader: 'worker-loader',
options: { inline: true }
}
ℹ️ Inline mode will also create chunks for browsers without support for inline workers, to disable this behavior just set
fallback
parameter asfalse
webpack.config.js
{
loader: 'worker-loader'
options: { inline: true, fallback: false }
}
fallback
Require a fallback for non-worker supporting environments
webpack.config.js
{
loader: 'worker-loader'
options: { fallback: false }
}
publicPath
Overrides the path from which worker scripts are downloaded. If not specified, the same public path used for other webpack assets is used
webpack.config.js
{
loader: 'worker-loader'
options: { publicPath: '/scripts/workers/' }
}
The worker file can import dependencies just like any other file
Worker.js
const _ = require('lodash')
const obj = { foo: 'foo' }
_.has(obj, 'foo')
// Post data to parent thread
self.postMessage({ foo: 'foo' })
// Respond to message from parent thread
self.addEventListener('message', (event) => console.log(event))
Integrating with ES2015 Modules
ℹ️ You can even use ES2015 Modules if you have the
babel-loader
configured.
Worker.js
import _ from 'lodash'
const obj = { foo: 'foo' }
_.has(obj, 'foo')
// Post data to parent thread
self.postMessage({ foo: 'foo' })
// Respond to message from parent thread
self.addEventListener('message', (event) => console.log(event))
Integrating with TypeScript
To integrate with TypeScript, you will need to define a custom module for the exports of your worker
typings/custom.d.ts
declare module "worker-loader!*" {
class WebpackWorker extends Worker {
constructor();
}
export = WebpackWorker;
}
Worker.ts
const ctx: Worker = self as any;
// Post data to parent thread
ctx.postMessage({ foo: "foo" });
// Respond to message from parent thread
ctx.addEventListener("message", (event) => console.log(event));
App.ts
import Worker = require("worker-loader!./Worker");
const worker = new Worker();
worker.postMessage({ a: 1 });
worker.onmessage = (event) => {};
worker.addEventListener("message", (event) => {});
Cross-Origin Policy
WebWorkers
are restricted by a same-origin policy, so if your webpack
assets are not being served from the same origin as your application, their download may be blocked by your browser. This scenario can commonly occur if you are hosting your assets under a CDN domain. Even downloads from the webpack-dev-server
could be blocked. There are two workarounds
Firstly, you can inline the worker as a blob instead of downloading it as an external script via the inline
parameter
App.js
import Worker from './file.worker.js';
webpack.config.js
{
loader: 'worker-loader'
options: { inline: true }
}
Secondly, you may override the base download URL for your worker script via the publicPath
option
App.js
// This will cause the worker to be downloaded from `/workers/file.worker.js`
import Worker from './file.worker.js';
webpack.config.js
{
loader: 'worker-loader'
options: { publicPath: '/workers/' }
}
Bogdan Chadkin |
Juho Vepsäläinen |
Joshua Wiens |
Michael Ciniawsky |
Alexander Krasnoyarov |
FAQs
worker loader module for webpack
The npm package worker-loader receives a total of 531,934 weekly downloads. As such, worker-loader popularity was classified as popular.
We found that worker-loader demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 9 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Product
We're launching a new set of license analysis and compliance features for analyzing, managing, and complying with licenses across a range of supported languages and ecosystems.
Product
We're excited to introduce Socket Optimize, a powerful CLI command to secure open source dependencies with tested, optimized package overrides.