@b9g/node-webworker 0.1.2 → 0.1.3

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
@@ -35,13 +35,28 @@ worker.postMessage({ hello: 'world' });
 await worker.terminate();
 ```
 
+## Exports
+
+### Classes
+
+- `Worker` - Web Worker implementation using Node.js worker_threads
+
+### Types
+
+- `MessageEvent` - Event type for worker messages
+- `ErrorEvent` - Event type 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
 
@@ -57,4 +72,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.1.3",
   "description": "Minimal Web Worker shim for Node.js until native support arrives",
   "keywords": [
     "worker",
@@ -36,11 +36,11 @@
       "import": "./src/index.js"
     },
     "./worker-wrapper": {
-      "types": "./src/worker-wrapper.d.ts",
+      "types": "./src/undefined.d.ts",
       "import": "./src/worker-wrapper.js"
     },
     "./worker-wrapper.js": {
-      "types": "./src/worker-wrapper.d.ts",
+      "types": "./src/undefined.d.ts",
       "import": "./src/worker-wrapper.js"
     }
   }

package/src/index.d.ts

@@ -6,20 +6,20 @@
  *
  * @see https://github.com/nodejs/node/issues/43583
  */
-import { Worker as NodeWorker } from 'worker_threads';
+import { Worker as NodeWorker } from "worker_threads";
 /**
  * Event-like object for message events
  */
 export interface MessageEvent {
     readonly data: any;
-    readonly type: 'message';
+    readonly type: "message";
 }
 /**
  * Error event object
  */
 export interface ErrorEvent {
     readonly error: Error;
-    readonly type: 'error';
+    readonly type: "error";
 }
 /**
  * Web Worker API implementation using Node.js worker_threads
@@ -28,11 +28,11 @@ 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;
+    constructor(scriptURL: string | URL, _options?: {
+        type?: "classic" | "module";
     });
     /**
      * Send a message to the worker
@@ -41,17 +41,17 @@ 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;
     /**
      * Remove an event listener
      */
-    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
-    removeEventListener(type: 'error', listener: (event: ErrorEvent) => void): void;
+    removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
     /**
-     * Terminate the worker
+     * Terminate the worker (Web Worker standard - returns void, not a promise)
      */
-    terminate(): Promise<number>;
+    terminate(): void;
     /**
      * Get the underlying Node.js Worker (for advanced usage)
      */

package/src/index.js

@@ -1,83 +1,139 @@
 /// <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_WRAPPER_CODE = `
+import {parentPort} from "worker_threads";
+
+// Provide Web Worker globals
+globalThis.onmessage = null;
+globalThis.postMessage = (data) => parentPort.postMessage(data);
+
+// Set up message forwarding
+parentPort.on("message", (data) => {
+	if (globalThis.onmessage) {
+		globalThis.onmessage({data, type: "message"});
+	}
+});
+
+// Import the actual worker script URL from environment variable
+const 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");
+}
+`;
+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;
+  // Web Worker standard properties
+  // eslint-disable-next-line no-restricted-syntax
+  onmessage = null;
+  // eslint-disable-next-line no-restricted-syntax
+  onerror = null;
+  constructor(scriptURL, _options) {
+    this.#messageListeners = /* @__PURE__ */ new Set();
+    this.#errorListeners = /* @__PURE__ */ new Set();
+    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: {
         ...process.env,
-        WORKER_SCRIPT_URL: scriptURL
+        WORKER_SCRIPT_URL: workerScriptURL
       }
     });
-    this.nodeWorker.on("message", (data) => {
+    this.#setupEventForwarding();
+  }
+  /**
+   * Report an error through the error event mechanism
+   */
+  #reportError(error) {
+    const event = { error, type: "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 = { data, type: "message" };
-      this.messageListeners.forEach((listener) => {
+      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);
+    });
   }
   /**
    * 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);
     }
   }
   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);
     }
   }
   /**
-   * 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;
+  terminate() {
+    this.#nodeWorker.terminate().catch(() => {
+    });
+    this.#messageListeners.clear();
+    this.#errorListeners.clear();
+    this.onmessage = null;
+    this.onerror = null;
   }
   /**
    * Get the underlying Node.js Worker (for advanced usage)
    */
   get nodeWorker_() {
-    return this.nodeWorker;
+    return this.#nodeWorker;
   }
 };
 var src_default = Worker;