@abndnce/pulsar-client 0.0.8 → 0.0.9

package/dist/index.d.mts

@@ -39,9 +39,14 @@ declare function connectNostr(_relay: string, _pubkey: string): Promise<PulsarCl
  */
 /**
  * Wait for an RTCDataChannel to enter the "open" state.
- * Rejects if it closes or errors before opening.
+ *
+ * Also monitors the RTCPeerConnection for failure/closure, and
+ * accepts an optional AbortSignal for cancellation.
+ *
+ * Rejects if the channel closes, the peer connection fails, or
+ * the timeout elapses before the channel opens.
  */
-declare function waitForDataChannelOpen(channel: RTCDataChannel, timeoutMs?: number): Promise<void>;
+declare function waitForDataChannelOpen(channel: RTCDataChannel, pc: RTCPeerConnection, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
 /**
  * Create a data channel on the given `pc` with the Pulsar socket label
  * convention (`socket/<hostname>:<port>`) and wait for it to open.
@@ -49,34 +54,47 @@ declare function waitForDataChannelOpen(channel: RTCDataChannel, timeoutMs?: num
  * This is the low-level primitive used by `connect()` and
  * `libcurlTransport()`.
  */
-declare function openSocketChannel(pc: RTCPeerConnection, hostname: string, port: number, timeoutMs?: number): Promise<RTCDataChannel>;
+declare function openSocketChannel(pc: RTCPeerConnection, hostname: string, port: number, timeoutMs?: number, signal?: AbortSignal): Promise<RTCDataChannel>;
 //#endregion
 //#region lib/tunnel.d.ts
 /**
- * A minimal WebSocket-like wrapper around an RTCDataChannel.
+ * WebSocket-compatible wrapper around an RTCDataChannel.
  *
- * libcurl.js expects its transport factory to return objects
- * with `send()`, `close()`, `onopen`, `onmessage`, `onclose`,
- * and `onerror` — which is exactly the RTCDataChannel API, so
- * the wrapper is thin.
+ * libcurl.js compares `readyState` against `WebSocket.OPEN` (numeric 1)
+ * and expects static constants (`CONNECTING`, `OPEN`, `CLOSING`, `CLOSED`).
+ * Using `EventTarget` ensures `addEventListener` / `removeEventListener`
+ * work, which libcurl's poll loop depends on.
  */
-declare class DataChannelSocket {
+declare class DataChannelSocket extends EventTarget {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  readonly url: string;
+  readonly protocol = "";
+  readonly extensions = "";
+  binaryType: string;
+  onopen: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
   private _channel;
   private _closed;
-  onopen: (() => void) | null;
-  onmessage: ((event: {
-    data: ArrayBuffer | string;
-  }) => void) | null;
-  onclose: (() => void) | null;
-  onerror: ((event: {
-    error?: string;
-  }) => void) | null;
-  constructor(channel: RTCDataChannel);
-  get readyState(): string;
-  get binaryType(): string;
-  set binaryType(_: string);
-  send(data: ArrayBuffer | string | ArrayBufferView): void;
+  private _closeDispatched;
+  private _readyState;
+  constructor(pc: RTCPeerConnection, destination: string);
+  private _open;
+  get readyState(): number;
+  get bufferedAmount(): number;
+  send(data: string | ArrayBufferLike | ArrayBufferView): void;
   close(): void;
+  private _dispatch;
+  private _dispatchError;
+  private _dispatchClose;
 }
 /**
  * Create a libcurl.js transport factory from an existing WebRTC

package/dist/index.mjs

@@ -91,10 +91,19 @@ async function connectNostr(_relay, _pubkey) {
 */
 /**
 * Wait for an RTCDataChannel to enter the "open" state.
-* Rejects if it closes or errors before opening.
+*
+* Also monitors the RTCPeerConnection for failure/closure, and
+* accepts an optional AbortSignal for cancellation.
+*
+* Rejects if the channel closes, the peer connection fails, or
+* the timeout elapses before the channel opens.
 */
-function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
+function waitForDataChannelOpen(channel, pc, timeoutMs = 1e4, signal) {
 	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
 		if (channel.readyState === "open") {
 			resolve();
 			return;
@@ -105,22 +114,39 @@ function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
 		}, timeoutMs);
 		const cleanup = () => {
 			clearTimeout(timeout);
-			channel.onopen = null;
-			channel.onclose = null;
-			channel.onerror = null;
+			channel.removeEventListener("open", onOpen);
+			channel.removeEventListener("close", onClose);
+			channel.removeEventListener("error", onError);
+			pc.removeEventListener("connectionstatechange", onStateChange);
+			signal?.removeEventListener("abort", onAbort);
 		};
-		channel.onopen = () => {
+		const onOpen = () => {
 			cleanup();
 			resolve();
 		};
-		channel.onclose = () => {
+		const onClose = () => {
 			cleanup();
 			reject(/* @__PURE__ */ new Error("DataChannel closed before opening"));
 		};
-		channel.onerror = (e) => {
+		const onError = () => {
 			cleanup();
-			reject(/* @__PURE__ */ new Error(`DataChannel error before opening: ${e}`));
+			reject(/* @__PURE__ */ new Error("DataChannel error before opening"));
+		};
+		const onStateChange = () => {
+			if (pc.connectionState === "failed" || pc.connectionState === "closed") {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Peer connection ${pc.connectionState}`));
+			}
 		};
+		const onAbort = () => {
+			cleanup();
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+		};
+		channel.addEventListener("open", onOpen, { once: true });
+		channel.addEventListener("close", onClose, { once: true });
+		channel.addEventListener("error", onError, { once: true });
+		pc.addEventListener("connectionstatechange", onStateChange);
+		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
 /**
@@ -130,60 +156,111 @@ function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
 * This is the low-level primitive used by `connect()` and
 * `libcurlTransport()`.
 */
-function openSocketChannel(pc, hostname, port, timeoutMs) {
+function openSocketChannel(pc, hostname, port, timeoutMs, signal) {
 	const label = `${SOCKET_PREFIX}${hostname}:${port}`;
 	const channel = pc.createDataChannel(label, { ordered: true });
-	return waitForDataChannelOpen(channel, timeoutMs).then(() => channel);
+	return waitForDataChannelOpen(channel, pc, timeoutMs, signal).then(() => channel);
 }
 //#endregion
 //#region lib/tunnel.ts
 /**
-* A minimal WebSocket-like wrapper around an RTCDataChannel.
+* WebSocket-compatible wrapper around an RTCDataChannel.
 *
-* libcurl.js expects its transport factory to return objects
-* with `send()`, `close()`, `onopen`, `onmessage`, `onclose`,
-* and `onerror` — which is exactly the RTCDataChannel API, so
-* the wrapper is thin.
+* libcurl.js compares `readyState` against `WebSocket.OPEN` (numeric 1)
+* and expects static constants (`CONNECTING`, `OPEN`, `CLOSING`, `CLOSED`).
+* Using `EventTarget` ensures `addEventListener` / `removeEventListener`
+* work, which libcurl's poll loop depends on.
 */
-var DataChannelSocket = class {
-	_channel;
-	_closed = false;
+var DataChannelSocket = class DataChannelSocket extends EventTarget {
+	static CONNECTING = 0;
+	static OPEN = 1;
+	static CLOSING = 2;
+	static CLOSED = 3;
+	CONNECTING = 0;
+	OPEN = 1;
+	CLOSING = 2;
+	CLOSED = 3;
+	url;
+	protocol = "";
+	extensions = "";
+	binaryType = "arraybuffer";
 	onopen = null;
-	onmessage = null;
 	onclose = null;
 	onerror = null;
-	constructor(channel) {
+	onmessage = null;
+	_channel = null;
+	_closed = false;
+	_closeDispatched = false;
+	_readyState = DataChannelSocket.CONNECTING;
+	constructor(pc, destination) {
+		super();
+		this.url = `wss://pulsar-tunnel.local/${destination}`;
+		const channel = pc.createDataChannel(`${SOCKET_PREFIX}${destination}`, { ordered: true });
+		channel.binaryType = "arraybuffer";
 		this._channel = channel;
-		channel.onopen = () => {
-			if (!this._closed) this.onopen?.();
-		};
+		this._open(channel, pc);
+	}
+	async _open(channel, pc) {
+		try {
+			await waitForDataChannelOpen(channel, pc);
+		} catch (error) {
+			if (!this._closed) {
+				console.error(`[DataChannelSocket] Failed to open channel: ${error instanceof Error ? error.message : String(error)}`);
+				this._dispatchError();
+			}
+			this._dispatchClose();
+			return;
+		}
+		if (this._closed) {
+			channel.close();
+			this._dispatchClose();
+			return;
+		}
+		this._channel = channel;
+		this._readyState = DataChannelSocket.OPEN;
 		channel.onmessage = (event) => {
-			if (!this._closed) this.onmessage?.({ data: event.data });
+			this._dispatch(new MessageEvent("message", { data: event.data }));
 		};
 		channel.onclose = () => {
-			this._closed = true;
-			this.onclose?.();
+			this._readyState = DataChannelSocket.CLOSED;
+			this._dispatchClose();
 		};
-		channel.onerror = (event) => {
-			this.onerror?.({ error: String(event) });
+		channel.onerror = () => {
+			this._dispatchError();
 		};
+		this._dispatch(new Event("open"));
 	}
 	get readyState() {
-		return this._channel.readyState;
+		return this._readyState;
 	}
-	get binaryType() {
-		return "arraybuffer";
+	get bufferedAmount() {
+		return this._channel?.bufferedAmount ?? 0;
 	}
-	set binaryType(_) {}
 	send(data) {
-		if (this._closed || this._channel.readyState !== "open") return;
-		this._channel.send(data);
+		if (this._readyState !== DataChannelSocket.OPEN || !this._channel) throw new Error("DataChannelSocket is not open");
+		if (typeof data === "string") this._channel.send(data);
+		else this._channel.send(data);
 	}
 	close() {
+		if (this._closed) return;
 		this._closed = true;
-		try {
-			this._channel.close();
-		} catch {}
+		if (this._channel && this._channel.readyState !== "closed") this._channel.close();
+		else this._dispatchClose();
+	}
+	_dispatch(event) {
+		const handlerName = `on${event.type}`;
+		const handler = this[handlerName];
+		if (handler) handler(event);
+		this.dispatchEvent(event);
+	}
+	_dispatchError() {
+		this._dispatch(new Event("error"));
+	}
+	_dispatchClose() {
+		if (this._closeDispatched) return;
+		this._closeDispatched = true;
+		this._readyState = DataChannelSocket.CLOSED;
+		this._dispatch(new CloseEvent("close"));
 	}
 };
 /**
@@ -218,7 +295,7 @@ function libcurlTransport(pc) {
 		}
 		if (!dest) throw new Error(`libcurl transport: no destination found in URL "${url}"`);
 		if (dest.lastIndexOf(":") === -1) throw new Error(`libcurl transport: invalid destination "${dest}" — expected "hostname:port"`);
-		return new DataChannelSocket(pc.createDataChannel(`${SOCKET_PREFIX}${dest}`, { ordered: true }));
+		return new DataChannelSocket(pc, dest);
 	};
 }
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abndnce/pulsar-client",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "homepage": "https://github.com/abndnce/pulsar",
   "license": "MIT",
   "exports": {