@b9g/node-webworker 0.1.2

package/README.md

@@ -0,0 +1,60 @@
+# @b9g/node-webworker
+
+Minimal Web Worker shim for Node.js until native support arrives.
+
+## Why This Package Exists
+
+Node.js lacks native Web Worker support, despite being a web standard since 2009. This package provides a minimal, reliable shim using Node.js `worker_threads` until native support is added.
+
+**🔗 Canonical Issue:** https://github.com/nodejs/node/issues/43583  
+**Please 👍 and comment** on the issue to show demand for native Web Worker support!
+
+## Installation
+
+```bash
+npm install @b9g/node-webworker
+```
+
+## Usage
+
+```typescript
+import { Worker } from '@b9g/node-webworker';
+
+// Create a worker (same API as Web Workers)
+const worker = new Worker('./worker.js', { type: 'module' });
+
+// Listen for messages
+worker.addEventListener('message', (event) => {
+  console.log('Received:', event.data);
+});
+
+// Send a message
+worker.postMessage({ hello: 'world' });
+
+// Terminate when done
+await worker.terminate();
+```
+
+## Features
+
+- ✅ **Standards-compliant API** - Drop-in replacement for Web Workers
+- ✅ **ES Module support** - Works with modern JavaScript
+- ✅ **Minimal overhead** - Thin wrapper around `worker_threads`
+- ✅ **Error handling** - Proper event forwarding
+- ✅ **Clean termination** - Resource cleanup
+
+## Limitations
+
+- **Transferable objects** - Limited support (logs warning)
+- **Node.js only** - Don't use this in browsers (they have native Web Workers)
+- **Basic API** - Only core Worker features, not full spec
+
+## Deprecation Notice
+
+⚠️ **This package will be deprecated** once Node.js implements native Web Workers.
+
+We maintain this as a temporary workaround. Please help push for native support by engaging with [nodejs/node#43583](https://github.com/nodejs/node/issues/43583).
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@b9g/node-webworker",
+  "version": "0.1.2",
+  "description": "Minimal Web Worker shim for Node.js until native support arrives",
+  "keywords": [
+    "worker",
+    "web-worker",
+    "node",
+    "shim",
+    "temporary"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.11",
+    "bun-types": "latest",
+    "@types/node": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./package.json": "./package.json",
+    "./index": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./worker-wrapper": {
+      "types": "./src/worker-wrapper.d.ts",
+      "import": "./src/worker-wrapper.js"
+    },
+    "./worker-wrapper.js": {
+      "types": "./src/worker-wrapper.d.ts",
+      "import": "./src/worker-wrapper.js"
+    }
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @b9g/node-webworker - Minimal Web Worker shim for Node.js
+ *
+ * This package provides a minimal Web Worker API implementation for Node.js
+ * until native Web Worker support is added to Node.js core.
+ *
+ * @see https://github.com/nodejs/node/issues/43583
+ */
+import { Worker as NodeWorker } from 'worker_threads';
+/**
+ * Event-like object for message events
+ */
+export interface MessageEvent {
+    readonly data: any;
+    readonly type: 'message';
+}
+/**
+ * Error event object
+ */
+export interface ErrorEvent {
+    readonly error: Error;
+    readonly type: 'error';
+}
+/**
+ * Web Worker API implementation using Node.js worker_threads
+ *
+ * This provides a minimal, standards-compliant interface that maps
+ * to Node.js worker_threads underneath.
+ */
+export declare class Worker {
+    private nodeWorker;
+    private messageListeners;
+    private errorListeners;
+    constructor(scriptURL: string, options?: {
+        type?: 'classic' | 'module';
+    });
+    /**
+     * Send a message to the worker
+     */
+    postMessage(message: any, transfer?: Transferable[]): void;
+    /**
+     * Add an event listener (Web Worker API)
+     */
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    addEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    /**
+     * Remove an event listener
+     */
+    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    /**
+     * Terminate the worker
+     */
+    terminate(): Promise<number>;
+    /**
+     * Get the underlying Node.js Worker (for advanced usage)
+     */
+    get nodeWorker_(): NodeWorker;
+}
+export default Worker;

package/src/index.js

@@ -0,0 +1,87 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import { Worker as NodeWorker } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var Worker = class {
+  nodeWorker;
+  messageListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  constructor(scriptURL, options) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const wrapperScript = join(__dirname, "worker-wrapper.js");
+    this.nodeWorker = new NodeWorker(wrapperScript, {
+      type: "module",
+      env: {
+        ...process.env,
+        WORKER_SCRIPT_URL: scriptURL
+      }
+    });
+    this.nodeWorker.on("message", (data) => {
+      const event = { data, type: "message" };
+      this.messageListeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error("[node-webworker] Error in message listener:", error);
+        }
+      });
+    });
+    this.nodeWorker.on("error", (error) => {
+      const event = { error, type: "error" };
+      this.errorListeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (listenerError) {
+          console.error("[node-webworker] Error in error listener:", listenerError);
+        }
+      });
+    });
+  }
+  /**
+   * Send a message to the worker
+   */
+  postMessage(message, transfer) {
+    if (transfer && transfer.length > 0) {
+      console.warn("[node-webworker] Transferable objects not fully supported");
+    }
+    this.nodeWorker.postMessage(message);
+  }
+  addEventListener(type, listener) {
+    if (type === "message") {
+      this.messageListeners.add(listener);
+    } else if (type === "error") {
+      this.errorListeners.add(listener);
+    } else {
+      console.warn(`[node-webworker] Unsupported event type: ${type}`);
+    }
+  }
+  removeEventListener(type, listener) {
+    if (type === "message") {
+      this.messageListeners.delete(listener);
+    } else if (type === "error") {
+      this.errorListeners.delete(listener);
+    }
+  }
+  /**
+   * Terminate the worker
+   */
+  async terminate() {
+    const exitCode = await this.nodeWorker.terminate();
+    this.messageListeners.clear();
+    this.errorListeners.clear();
+    return exitCode;
+  }
+  /**
+   * Get the underlying Node.js Worker (for advanced usage)
+   */
+  get nodeWorker_() {
+    return this.nodeWorker;
+  }
+};
+var src_default = Worker;
+export {
+  Worker,
+  src_default as default
+};

package/src/worker-wrapper.js

@@ -0,0 +1,15 @@
+// src/worker-wrapper.js
+import { parentPort } from "worker_threads";
+globalThis.onmessage = null;
+globalThis.postMessage = (data) => parentPort.postMessage(data);
+parentPort.on("message", (data) => {
+  if (globalThis.onmessage) {
+    globalThis.onmessage({ data, type: "message" });
+  }
+});
+var WORKER_SCRIPT_URL = process.env.WORKER_SCRIPT_URL;
+if (WORKER_SCRIPT_URL) {
+  await import(WORKER_SCRIPT_URL);
+} else {
+  throw new Error("WORKER_SCRIPT_URL environment variable not set");
+}