@marianmeres/webrtc 1.2.0 → 1.2.1

package/AGENTS.md

@@ -114,9 +114,11 @@ ERROR         --RESET-->       IDLE
 ### Constructor
 
 ```typescript
-new WebRtcManager(factory: WebRtcFactory, config?: WebRtcManagerConfig)
+new WebRtcManager<TContext = unknown>(factory: WebRtcFactory, config?: WebRtcManagerConfig)
 ```
 
+**Type Parameter:** `TContext` - Optional type for the `context` property (default: `unknown`)
+
 ### Logger Interface
 
 Console-compatible logger interface for custom logging implementations.
@@ -166,6 +168,7 @@ interface WebRtcManagerConfig {
 | remoteStream | MediaStream \| null | Remote audio stream |
 | dataChannels | ReadonlyMap<string, RTCDataChannel> | Active data channels |
 | peerConnection | RTCPeerConnection \| null | Underlying connection |
+| context | TContext \| null | User-defined context for arbitrary data |
 
 ### Lifecycle Methods
 

package/API.md

@@ -31,9 +31,15 @@ The main class for managing WebRTC connections.
 ### Constructor
 
 ```typescript
-new WebRtcManager(factory: WebRtcFactory, config?: WebRtcManagerConfig)
+new WebRtcManager<TContext = unknown>(factory: WebRtcFactory, config?: WebRtcManagerConfig)
 ```
 
+**Type Parameters:**
+
+| Name | Default | Description |
+|------|---------|-------------|
+| TContext | `unknown` | Type for the `context` property |
+
 **Parameters:**
 
 | Name | Type | Required | Description |
@@ -123,6 +129,33 @@ Returns the underlying RTCPeerConnection, or `null` if not initialized.
 
 ---
 
+#### context
+
+```typescript
+context: TContext | null
+```
+
+User-defined context object for storing arbitrary data associated with this manager. The class accepts an optional generic type parameter for type-safe context access.
+
+**Type Parameter:** `TContext` - The type of the context object (default: `unknown`)
+
+**Default:** `null`
+
+**Example:**
+
+```typescript
+// With type parameter for full type safety:
+const manager = new WebRtcManager<{ audioStream: MediaStream; sessionId: string }>(factory);
+manager.context = { audioStream: myStream, sessionId: '123' };
+manager.context.audioStream; // typed as MediaStream
+
+// Without type parameter (backwards compatible):
+const manager = new WebRtcManager(factory);
+manager.context = { anything: 'goes' };
+```
+
+---
+
 ### Lifecycle Methods
 
 #### initialize()

package/README.md

@@ -38,9 +38,11 @@ The manager doesn't handle the signaling transport layer - you're responsible fo
 ### Constructor
 
 ```typescript
-const manager = new WebRtcManager(factory, config);
+const manager = new WebRtcManager<TContext>(factory, config);
 ```
 
+- `TContext`: Optional type parameter for the `context` property (default: `unknown`)
+
 - `factory`: Object implementing `WebRtcFactory` interface (provides `createPeerConnection`, `getUserMedia`, `enumerateDevices`)
 - `config`: Optional configuration object
 
@@ -64,6 +66,7 @@ manager.localStream           // MediaStream | null
 manager.remoteStream          // MediaStream | null
 manager.dataChannels          // ReadonlyMap<string, RTCDataChannel>
 manager.peerConnection        // RTCPeerConnection | null
+manager.context               // TContext | null - user-defined data
 ```
 
 ### Lifecycle Methods
@@ -456,24 +459,31 @@ Mock-based tests for the manager's logic and state transitions:
 deno task test
 ```
 
-### Browser Integration Tests
+### Interactive Example
 
-Real peer-to-peer connection tests running in a browser environment:
+The `example/` directory contains a working demo of two peers communicating via WebRTC data channels:
 
 ```bash
-deno task test:browser
+# Build the example bundle
+deno task example:build
+
+# Serve the example directory
+cd example && deno run -A jsr:@std/http/file-server
 ```
 
-This builds the test bundle and starts a local server. Open the provided URL in your browser to run the tests interactively.
+Then open `http://localhost:8000/` in your browser.
 
-The browser tests verify:
-- Actual P2P connections between peers
-- Data channel message exchange
-- ICE candidate exchange
-- Connection state transitions
-- Resource cleanup
+**Structure:**
+- `index.html` - Parent page with two side-by-side iframes, acts as signaling relay via `postMessage`
+- `peer1.html` - The "offerer" peer (click "Connect" to initiate)
+- `peer2.html` - The "answerer" peer (waits for connection)
 
-See [tests/browser/README.md](tests/browser/README.md) for more details.
+This example demonstrates:
+- P2P connection establishment without a signaling server (uses `postMessage` between iframes)
+- SDP offer/answer exchange
+- ICE candidate exchange
+- Data channel creation and message passing
+- State change monitoring
 
 ## License
 

package/dist/webrtc-manager.d.ts

@@ -25,7 +25,7 @@ import { type WebRtcFactory, type WebRtcManagerConfig, WebRtcState, type WebRtcE
  * await manager.setLocalDescription(offer);
  * ```
  */
-export declare class WebRtcManager {
+export declare class WebRtcManager<TContext = unknown> {
     #private;
     /** Event emitted when connection state changes. Payload: {@link WebRtcState} */
     static readonly EVENT_STATE_CHANGE = "state_change";
@@ -51,6 +51,24 @@ export declare class WebRtcManager {
     static readonly EVENT_MICROPHONE_FAILED = "microphone_failed";
     /** Event emitted when an error occurs. Payload: `Error` */
     static readonly EVENT_ERROR = "error";
+    /**
+     * User-defined context object for storing arbitrary data associated with this manager.
+     * Useful for attaching application-specific state (e.g., audio streams, metadata)
+     * without modifying the manager internals.
+     *
+     * @example
+     * ```typescript
+     * // With type parameter for full type safety:
+     * const manager = new WebRtcManager<{ audioStream: MediaStream; sessionId: string }>(factory);
+     * manager.context = { audioStream: myStream, sessionId: '123' };
+     * manager.context.audioStream; // typed as MediaStream
+     *
+     * // Without type parameter (backwards compatible):
+     * const manager = new WebRtcManager(factory);
+     * manager.context = { anything: 'goes' };
+     * ```
+     */
+    context: TContext | null;
     /**
      * Creates a new WebRtcManager instance.
      * @param factory - Factory object providing WebRTC primitives (peer connection, media, devices).

package/dist/webrtc-manager.js

@@ -88,6 +88,24 @@ export class WebRtcManager {
     #remoteStream = null;
     #dataChannels = new Map();
     #reconnectAttempts = 0;
+    /**
+     * User-defined context object for storing arbitrary data associated with this manager.
+     * Useful for attaching application-specific state (e.g., audio streams, metadata)
+     * without modifying the manager internals.
+     *
+     * @example
+     * ```typescript
+     * // With type parameter for full type safety:
+     * const manager = new WebRtcManager<{ audioStream: MediaStream; sessionId: string }>(factory);
+     * manager.context = { audioStream: myStream, sessionId: '123' };
+     * manager.context.audioStream; // typed as MediaStream
+     *
+     * // Without type parameter (backwards compatible):
+     * const manager = new WebRtcManager(factory);
+     * manager.context = { anything: 'goes' };
+     * ```
+     */
+    context = null;
     #reconnectTimer = null;
     #fullReconnectTimeoutTimer = null;
     #deviceChangeHandler = null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@marianmeres/webrtc",
-	"version": "1.2.0",
+	"version": "1.2.1",
 	"type": "module",
 	"main": "dist/mod.js",
 	"types": "dist/mod.d.ts",