Inline Web Worker Utility

Common errors

• TypeError: InlineWorker is not a constructor

  cause Attempting to instantiate `InlineWorker` using ES module `import` syntax (`import { InlineWorker } from 'inline-worker';`) in a CommonJS-only environment (e.g., older Node.js versions, or without a bundler configured for CJS interop).
  fix Ensure you are using the CommonJS `require` syntax: `const InlineWorker = require('inline-worker');`.

• ReferenceError: postMessage is not defined

  cause This error occurs within the worker function if `postMessage` is called incorrectly or if the `self` context passed to the worker function is overriding the global `postMessage` function.
  fix Within the worker function, `postMessage` should be called directly, as it's a global function within the Web Worker scope. If you passed a `self` object to the constructor, ensure you're not inadvertently using a property on that `self` object named `postMessage` that shadows the global one. You can also explicitly use `self.postMessage()` where `self` refers to the worker's global scope.

• Error: A worker script must be a function or a URL.

  cause The first argument provided to the `InlineWorker` constructor is not a valid JavaScript function.
  fix Ensure the first argument to `new InlineWorker()` is a properly defined JavaScript function that encapsulates your worker's logic, as shown in the package examples.

Warnings

• breaking The `inline-worker` package is primarily CommonJS-based. Attempting to use ES module `import` syntax directly in modern Node.js or browser environments without a compatible bundler or transpilation setup will likely result in module resolution errors or runtime failures.
  Fix: For Node.js, use `const InlineWorker = require('inline-worker');`. In browser environments or ESM projects, ensure your bundler (e.g., Webpack, Rollup, Parcel) is configured to correctly handle CommonJS modules, or consider using a modern alternative that supports ESM natively.
• gotcha This package is effectively abandoned, with its last publish eight years ago (as of April 2026). This means there will be no further updates, bug fixes, or security patches, which could lead to compatibility issues with newer JavaScript runtimes or potential security vulnerabilities in critical applications.
  Fix: For new projects, consider using a more actively maintained Web Worker library, or implement native Web Workers directly. For existing projects, thoroughly vet its compatibility with your current stack and consider forking the repository if critical maintenance is required.
• gotcha The `inline-worker` package does not ship with TypeScript definition files (`.d.ts`). This means TypeScript users will either need to provide their own type declarations or use `any` types, reducing type safety.
  Fix: Create a `declarations.d.ts` file with `declare module 'inline-worker';` or provide more specific types if you understand the internal API, e.g., `declare module 'inline-worker' { class InlineWorker extends Worker { constructor(func: Function, self?: object); } export = InlineWorker; }`
• gotcha The second `self` parameter in the `InlineWorker` constructor is a shared object. While useful for testing worker internal functions from the main thread, modifications to this object within the worker function are directly visible in the main thread. This shared state can lead to unexpected side effects if not carefully managed or understood.
  Fix: If shared state is not intended, avoid passing the `self` object or ensure that the worker logic does not mutate it in ways that would affect the main thread. If shared access is desired, clearly document the interaction points to prevent unintended side effects.

Install

• npm install inline-worker npm
• yarn add inline-worker yarn
• pnpm add inline-worker pnpm

Imports

• InlineWorker
  wrong:

  import { InlineWorker } from 'inline-worker';

  correct:

  const InlineWorker = require('inline-worker');

  This package is primarily designed for CommonJS environments. Direct ES module `import` syntax will likely fail in modern Node.js or browser environments without a transpiler or bundler configured to handle CommonJS interop.
• InlineWorker (constructor)
  wrong:

  new InlineWorker(workerFunction);

  correct:

  new InlineWorker(workerFunction, sharedSelfObject);

  While the `sharedSelfObject` parameter is optional, passing it allows for testing worker internal functions from the main thread, as demonstrated in the package's examples.

Quickstart

This quickstart demonstrates how to create an `InlineWorker` from a function, pass a shared `self` object for internal worker function testing, send messages to the worker, and receive responses.

const InlineWorker = require('inline-worker');

let self = {};
let worker = new InlineWorker(function(self) {
  // Define worker's message handler
  self.onmessage = function(e) {
    postMessage(self.bark(e.data)); // Calls a worker internal function and posts result back
  };

  // Define a worker internal function (accessible via the shared 'self' object)
  self.bark = function(msg) {
    return msg + '!!';
  };
}, self); // Pass 'self' object for shared access

// Main thread's message handler for worker responses
worker.onmessage = function(e) {
  console.log(e.data + '!!'); // Expected: 'hello!!!!'
};

// Send a message to the worker
worker.postMessage('hello'); // Initiates the worker process

// You can test worker internal functions directly via the shared 'self' object
console.log(self.bark('bye')); // Expected: 'bye!!'