@b9g/node-webworker 0.1.2 → 0.2.0-beta.1

package/README.md

@@ -6,7 +6,7 @@ Minimal Web Worker shim for Node.js until native support arrives.
 
 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  
+**Canonical Issue:** https://github.com/nodejs/node/issues/43583
 **Please 👍 and comment** on the issue to show demand for native Web Worker support!
 
 ## Installation
@@ -18,7 +18,7 @@ npm install @b9g/node-webworker
 ## Usage
 
 ```typescript
-import { Worker } from '@b9g/node-webworker';
+import {Worker} from '@b9g/node-webworker';
 
 // Create a worker (same API as Web Workers)
 const worker = new Worker('./worker.js', { type: 'module' });
@@ -32,22 +32,34 @@ worker.addEventListener('message', (event) => {
 worker.postMessage({ hello: 'world' });
 
 // Terminate when done
-await worker.terminate();
+worker.terminate();
 ```
 
+## Exports
+
+### Classes
+
+- `Worker` - Web Worker implementation using Node.js worker_threads
+- `MessageEvent` - Event class for worker messages
+- `ErrorEvent` - Event class for worker errors
+
+### Default Export
+
+- `Worker` - The Worker class
+
 ## 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
+- **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
+- **Module workers only** - Classic workers with `importScripts()` not supported
+- **Serialization differences** - Uses Node.js structured clone, not web's algorithm
 
 ## Deprecation Notice
 
@@ -57,4 +69,4 @@ We maintain this as a temporary workaround. Please help push for native support
 
 ## License
 
-MIT
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/node-webworker",
-  "version": "0.1.2",
+  "version": "0.2.0-beta.1",
   "description": "Minimal Web Worker shim for Node.js until native support arrives",
   "keywords": [
     "worker",
@@ -11,8 +11,7 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
-    "bun-types": "latest",
+    "@b9g/libuild": "^0.1.18",
     "@types/node": "^18.0.0"
   },
   "engines": {
@@ -34,14 +33,6 @@
     "./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

@@ -6,20 +6,27 @@
  *
  * @see https://github.com/nodejs/node/issues/43583
  */
-import { Worker as NodeWorker } from 'worker_threads';
 /**
- * Event-like object for message events
+ * Message event for worker communication
  */
-export interface MessageEvent {
+export declare class MessageEvent extends Event {
     readonly data: any;
-    readonly type: 'message';
+    constructor(data: any);
 }
 /**
- * Error event object
+ * Error event for worker errors
  */
-export interface ErrorEvent {
+export declare class ErrorEvent extends Event {
     readonly error: Error;
-    readonly type: 'error';
+    constructor(error: Error);
+}
+/**
+ * Close event for worker termination
+ * Includes exit code for crash detection
+ */
+export declare class CloseEvent extends Event {
+    readonly code: number;
+    constructor(code: number);
 }
 /**
  * Web Worker API implementation using Node.js worker_threads
@@ -28,11 +35,14 @@ export interface ErrorEvent {
  * to Node.js worker_threads underneath.
  */
 export declare class Worker {
-    private nodeWorker;
-    private messageListeners;
-    private errorListeners;
-    constructor(scriptURL: string, options?: {
-        type?: 'classic' | 'module';
+    #private;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+    onmessageerror: ((event: MessageEvent) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    constructor(scriptURL: string | URL, _options?: {
+        type?: "classic" | "module";
+        env?: Record<string, string>;
     });
     /**
      * Send a message to the worker
@@ -41,20 +51,20 @@ export declare class Worker {
     /**
      * Add an event listener (Web Worker API)
      */
-    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
-    addEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+    addEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+    addEventListener(type: "messageerror", listener: (event: MessageEvent) => void): void;
+    addEventListener(type: "close", listener: (event: CloseEvent) => 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>;
+    removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+    removeEventListener(type: "messageerror", listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: "close", listener: (event: CloseEvent) => void): void;
     /**
-     * Get the underlying Node.js Worker (for advanced usage)
+     * Terminate the worker (Web Worker standard - returns void, not a promise)
      */
-    get nodeWorker_(): NodeWorker;
+    terminate(): void;
 }
 export default Worker;

package/src/index.js

@@ -1,87 +1,190 @@
 /// <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 MessageEvent = class extends Event {
+  data;
+  constructor(data) {
+    super("message");
+    this.data = data;
+  }
+};
+var ErrorEvent = class extends Event {
+  error;
+  constructor(error) {
+    super("error");
+    this.error = error;
+  }
+};
+var CloseEvent = class extends Event {
+  code;
+  constructor(code) {
+    super("close");
+    this.code = code;
+  }
+};
+var WORKER_WRAPPER_CODE = `import{parentPort as p}from"worker_threads";const l=new Set();globalThis.onmessage=null;globalThis.onmessageerror=null;globalThis.postMessage=(d,t)=>t?.length?p.postMessage(d,t):p.postMessage(d);globalThis.self=globalThis;globalThis.addEventListener=(t,f)=>t==="message"&&l.add(f);globalThis.removeEventListener=(t,f)=>t==="message"&&l.delete(f);p.on("message",d=>{const e={data:d,type:"message"};globalThis.onmessage?.(e);l.forEach(f=>f(e))});const u=process.env.WORKER_SCRIPT_URL;if(u)await import(u);else throw Error("WORKER_SCRIPT_URL not set");`;
+var WORKER_WRAPPER_DATA_URL = new URL(
+  `data:text/javascript,${encodeURIComponent(WORKER_WRAPPER_CODE)}`
+);
 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",
+  #nodeWorker;
+  #messageListeners;
+  #errorListeners;
+  #messageerrorListeners;
+  #closeListeners;
+  // Web Worker standard properties
+  onmessage;
+  onerror;
+  onmessageerror;
+  onclose;
+  constructor(scriptURL, _options) {
+    this.#messageListeners = /* @__PURE__ */ new Set();
+    this.#errorListeners = /* @__PURE__ */ new Set();
+    this.#messageerrorListeners = /* @__PURE__ */ new Set();
+    this.#closeListeners = /* @__PURE__ */ new Set();
+    this.onmessage = null;
+    this.onerror = null;
+    this.onmessageerror = null;
+    this.onclose = null;
+    const scriptURLString = scriptURL.toString();
+    let workerScriptURL = scriptURLString;
+    if (!scriptURLString.startsWith("file://") && !scriptURLString.startsWith("data:")) {
+      if (scriptURLString.startsWith("./") || scriptURLString.startsWith("../")) {
+        throw new Error(
+          "Relative paths are not supported. Use new Worker(new URL('./worker.js', import.meta.url)) instead."
+        );
+      }
+      workerScriptURL = `file://${scriptURLString}`;
+    }
+    this.#nodeWorker = new NodeWorker(WORKER_WRAPPER_DATA_URL, {
+      ...{ type: "module" },
       env: {
+        // eslint-disable-next-line no-restricted-properties -- Workers inherit parent env
         ...process.env,
-        WORKER_SCRIPT_URL: scriptURL
+        ..._options?.env,
+        WORKER_SCRIPT_URL: workerScriptURL
       }
     });
-    this.nodeWorker.on("message", (data) => {
-      const event = { data, type: "message" };
-      this.messageListeners.forEach((listener) => {
+    this.#setupEventForwarding();
+  }
+  /**
+   * Report a close event when the worker exits
+   */
+  #reportClose(code) {
+    const event = new CloseEvent(code);
+    if (this.onclose) {
+      this.onclose(event);
+    }
+    this.#closeListeners.forEach((listener) => {
+      listener(event);
+    });
+  }
+  /**
+   * Report an error through the error event mechanism
+   */
+  #reportError(error) {
+    const event = new ErrorEvent(error);
+    if (this.onerror) {
+      this.onerror(event);
+    }
+    this.#errorListeners.forEach((listener) => {
+      listener(event);
+    });
+  }
+  /**
+   * Set up event forwarding from Node.js Worker to Web Worker API
+   */
+  #setupEventForwarding() {
+    this.#nodeWorker.on("message", (data) => {
+      const event = new MessageEvent(data);
+      if (this.onmessage) {
         try {
-          listener(event);
+          this.onmessage(event);
         } catch (error) {
-          console.error("[node-webworker] Error in message listener:", error);
+          this.#reportError(error);
         }
-      });
-    });
-    this.nodeWorker.on("error", (error) => {
-      const event = { error, type: "error" };
-      this.errorListeners.forEach((listener) => {
+      }
+      this.#messageListeners.forEach((listener) => {
         try {
           listener(event);
-        } catch (listenerError) {
-          console.error("[node-webworker] Error in error listener:", listenerError);
+        } catch (error) {
+          this.#reportError(error);
         }
       });
     });
+    this.#nodeWorker.on("error", (error) => {
+      this.#reportError(error);
+    });
+    this.#nodeWorker.on("messageerror", (data) => {
+      const event = new MessageEvent(data);
+      if (this.onmessageerror) {
+        this.onmessageerror(event);
+      }
+      this.#messageerrorListeners.forEach((listener) => {
+        listener(event);
+      });
+    });
+    this.#nodeWorker.on("exit", (code) => {
+      this.#reportClose(code);
+    });
   }
   /**
    * 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, transfer);
+    } else {
+      this.#nodeWorker.postMessage(message);
     }
-    this.nodeWorker.postMessage(message);
   }
   addEventListener(type, listener) {
     if (type === "message") {
-      this.messageListeners.add(listener);
+      this.#messageListeners.add(listener);
     } else if (type === "error") {
-      this.errorListeners.add(listener);
-    } else {
-      console.warn(`[node-webworker] Unsupported event type: ${type}`);
+      this.#errorListeners.add(listener);
+    } else if (type === "messageerror") {
+      this.#messageerrorListeners.add(
+        listener
+      );
+    } else if (type === "close") {
+      this.#closeListeners.add(listener);
     }
   }
   removeEventListener(type, listener) {
     if (type === "message") {
-      this.messageListeners.delete(listener);
+      this.#messageListeners.delete(listener);
     } else if (type === "error") {
-      this.errorListeners.delete(listener);
+      this.#errorListeners.delete(listener);
+    } else if (type === "messageerror") {
+      this.#messageerrorListeners.delete(
+        listener
+      );
+    } else if (type === "close") {
+      this.#closeListeners.delete(listener);
     }
   }
   /**
-   * Terminate the worker
+   * Terminate the worker (Web Worker standard - returns void, not a promise)
    */
-  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;
+  terminate() {
+    this.#nodeWorker.terminate().catch(() => {
+    });
+    this.#messageListeners.clear();
+    this.#errorListeners.clear();
+    this.#messageerrorListeners.clear();
+    this.#closeListeners.clear();
+    this.onmessage = null;
+    this.onerror = null;
+    this.onmessageerror = null;
+    this.onclose = null;
   }
 };
 var src_default = Worker;
 export {
+  CloseEvent,
+  ErrorEvent,
+  MessageEvent,
   Worker,
   src_default as default
 };

package/src/worker-wrapper.js

@@ -1,15 +0,0 @@
-// 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");
-}