@observertc/observer-js 0.42.9 → 1.0.1-28c6425.0

package/src/monitors/TurnUsageMonitor.ts

@@ -1,187 +1,187 @@
-import { EventEmitter } from 'events';
-import { ObservedPeerConnection } from '../ObservedPeerConnection';
-import { ObservedICEEvents } from '../ObservedICE';
-import { ObservedClient } from '../ObservedClient';
-
-export type TurnUsageMonitorEvents = {
-	close: [],
-	'newturnip': [string],
-	update: [TurnUsage],
-	addpeerconnection: [ObservedPeerConnection],
-	removepeerconnection: [ObservedPeerConnection],
-}
-
-export type TurnUsage = {
-	turnIp: string;
-	totalBytesSent: number;
-	totalBytesReceived: number;
-	totalPacketsSent: number;
-	totalPacketsReceived: number;
-}
-
-export type TurnStats = {
-	turnIp: string;
-	totalBytesSent: number;
-	totalBytesReceived: number;
-	totalPacketsSent: number;
-	totalPacketsReceived: number;
-	deltaBytesSent: number;
-	deltaBytesReceived: number;
-	timestamp: number;
-	outboundBitrate: number;
-	inboundBitrate: number;
-}
-
-type ObservedConnection = {
-	peerConnection: ObservedPeerConnection,
-	onUpdate: (...e: ObservedICEEvents['update']) => void;
-
-}
-
-export declare interface TurnUsageMonitor {
-	on<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
-	off<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
-	once<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
-	emit<U extends keyof TurnUsageMonitorEvents>(event: U, ...args: TurnUsageMonitorEvents[U]): boolean;
-}
-
-export class TurnUsageMonitor extends EventEmitter {
-	private readonly _connections = new Map<string, ObservedConnection>();
-	private readonly _turnUsage = new Map<string, TurnUsage>();
-	private readonly _stats = new Map<string, TurnStats>();
-
-	private _closed = false;
-	public constructor() {
-		super();
-		this.setMaxListeners(Infinity);
-	}
-
-	public get stats(): TurnStats[] {
-		const result: TurnStats[] = [];
-
-		for (const [ turnIp, usage ] of this._turnUsage) {
-			const stats = this._stats.get(turnIp) ?? {
-				turnIp,
-				totalBytesSent: 0,
-				totalBytesReceived: 0,
-				totalPacketsSent: 0,
-				totalPacketsReceived: 0,
-				deltaBytesSent: 0,
-				deltaBytesReceived: 0,
-				timestamp: Date.now(),
-				outboundBitrate: 0,
-				inboundBitrate: 0,
-			};
-
-			stats.deltaBytesSent = usage.totalBytesSent - stats.totalBytesSent;
-			stats.deltaBytesReceived = usage.totalBytesReceived - stats.totalBytesReceived;
-			stats.timestamp = Date.now();
-			stats.outboundBitrate = (stats.deltaBytesSent * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
-			stats.inboundBitrate = (stats.deltaBytesReceived * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
-			stats.totalBytesSent = usage.totalBytesSent;
-			stats.totalBytesReceived = usage.totalBytesReceived;
-			stats.totalPacketsSent = usage.totalPacketsSent;
-			stats.totalPacketsReceived = usage.totalPacketsReceived;
-
-			this._stats.set(turnIp, stats);
-
-			result.push(stats);
-		}
-
-		return result;
-	}
-
-	public addPeerConnection(peerConnection: ObservedPeerConnection) {
-		if (this.closed) return;
-		if (this._connections.has(peerConnection.peerConnectionId)) return;
-
-		const ice = peerConnection.ICE;
-
-		const onUpdate = () => {
-			const turnIp = ice?.selectedRemoteCandidate?.address;
+// import { EventEmitter } from 'events';
+// import { ObservedPeerConnection } from '../ObservedPeerConnection';
+// import { ObservedICEEvents } from '../ObservedICE';
+// import { ObservedClient } from '../ObservedClient';
+
+// export type TurnUsageMonitorEvents = {
+// 	close: [],
+// 	'newturnip': [string],
+// 	update: [TurnUsage],
+// 	addpeerconnection: [ObservedPeerConnection],
+// 	removepeerconnection: [ObservedPeerConnection],
+// }
+
+// export type TurnUsage = {
+// 	turnIp: string;
+// 	totalBytesSent: number;
+// 	totalBytesReceived: number;
+// 	totalPacketsSent: number;
+// 	totalPacketsReceived: number;
+// }
+
+// export type TurnStats = {
+// 	turnIp: string;
+// 	totalBytesSent: number;
+// 	totalBytesReceived: number;
+// 	totalPacketsSent: number;
+// 	totalPacketsReceived: number;
+// 	deltaBytesSent: number;
+// 	deltaBytesReceived: number;
+// 	timestamp: number;
+// 	outboundBitrate: number;
+// 	inboundBitrate: number;
+// }
+
+// type ObservedConnection = {
+// 	peerConnection: ObservedPeerConnection,
+// 	onUpdate: (...e: ObservedICEEvents['update']) => void;
+
+// }
+
+// export declare interface TurnUsageMonitor {
+// 	on<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+// 	off<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+// 	once<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+// 	emit<U extends keyof TurnUsageMonitorEvents>(event: U, ...args: TurnUsageMonitorEvents[U]): boolean;
+// }
+
+// export class TurnUsageMonitor extends EventEmitter {
+// 	private readonly _connections = new Map<string, ObservedConnection>();
+// 	private readonly _turnUsage = new Map<string, TurnUsage>();
+// 	private readonly _stats = new Map<string, TurnStats>();
+
+// 	private _closed = false;
+// 	public constructor() {
+// 		super();
+// 		this.setMaxListeners(Infinity);
+// 	}
+
+// 	public get stats(): TurnStats[] {
+// 		const result: TurnStats[] = [];
+
+// 		for (const [ turnIp, usage ] of this._turnUsage) {
+// 			const stats = this._stats.get(turnIp) ?? {
+// 				turnIp,
+// 				totalBytesSent: 0,
+// 				totalBytesReceived: 0,
+// 				totalPacketsSent: 0,
+// 				totalPacketsReceived: 0,
+// 				deltaBytesSent: 0,
+// 				deltaBytesReceived: 0,
+// 				timestamp: Date.now(),
+// 				outboundBitrate: 0,
+// 				inboundBitrate: 0,
+// 			};
+
+// 			stats.deltaBytesSent = usage.totalBytesSent - stats.totalBytesSent;
+// 			stats.deltaBytesReceived = usage.totalBytesReceived - stats.totalBytesReceived;
+// 			stats.timestamp = Date.now();
+// 			stats.outboundBitrate = (stats.deltaBytesSent * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
+// 			stats.inboundBitrate = (stats.deltaBytesReceived * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
+// 			stats.totalBytesSent = usage.totalBytesSent;
+// 			stats.totalBytesReceived = usage.totalBytesReceived;
+// 			stats.totalPacketsSent = usage.totalPacketsSent;
+// 			stats.totalPacketsReceived = usage.totalPacketsReceived;
+
+// 			this._stats.set(turnIp, stats);
+
+// 			result.push(stats);
+// 		}
+
+// 		return result;
+// 	}
+
+// 	public addPeerConnection(peerConnection: ObservedPeerConnection) {
+// 		if (this.closed) return;
+// 		if (this._connections.has(peerConnection.peerConnectionId)) return;
+
+// 		const ice = peerConnection.ICE;
+
+// 		const onUpdate = () => {
+// 			const turnIp = ice?.selectedRemoteCandidate?.address;
 			
-			if (!peerConnection.usingTURN || !turnIp) return;
+// 			if (!peerConnection.usingTURN || !turnIp) return;
 			
-			let usage = this._turnUsage.get(turnIp);
-
-			if (!usage) {
-				usage = {
-					turnIp,
-					totalBytesSent: 0,
-					totalBytesReceived: 0,
-					totalPacketsSent: 0,
-					totalPacketsReceived: 0,
-				};
-				this._turnUsage.set(turnIp, usage);
-
-				this.emit('newturnip', turnIp);
-			}
+// 			let usage = this._turnUsage.get(turnIp);
+
+// 			if (!usage) {
+// 				usage = {
+// 					turnIp,
+// 					totalBytesSent: 0,
+// 					totalBytesReceived: 0,
+// 					totalPacketsSent: 0,
+// 					totalPacketsReceived: 0,
+// 				};
+// 				this._turnUsage.set(turnIp, usage);
+
+// 				this.emit('newturnip', turnIp);
+// 			}
 			
-			usage.totalBytesSent += ice.deltaBytesSent;
-			usage.totalBytesReceived += ice.deltaBytesReceived;
-			usage.totalPacketsSent += ice.deltaPacketsSent;
-			usage.totalPacketsReceived += ice.deltaPacketsReceived;
+// 			usage.totalBytesSent += ice.deltaBytesSent;
+// 			usage.totalBytesReceived += ice.deltaBytesReceived;
+// 			usage.totalPacketsSent += ice.deltaPacketsSent;
+// 			usage.totalPacketsReceived += ice.deltaPacketsReceived;
 
-			this.emit('update', usage);
-		};
+// 			this.emit('update', usage);
+// 		};
 
-		peerConnection.ICE.on('update', onUpdate);
+// 		peerConnection.ICE.on('update', onUpdate);
 
-		this._connections.set(peerConnection.peerConnectionId, {
-			peerConnection,
-			onUpdate
-		});
+// 		this._connections.set(peerConnection.peerConnectionId, {
+// 			peerConnection,
+// 			onUpdate
+// 		});
 
-		this.emit('addpeerconnection', peerConnection);
-	}
+// 		this.emit('addpeerconnection', peerConnection);
+// 	}
 
-	public removePeerConnection(peerConnection: ObservedPeerConnection) {
-		if (this.closed) return;
-		if (!this._connections.has(peerConnection.peerConnectionId)) return;
+// 	public removePeerConnection(peerConnection: ObservedPeerConnection) {
+// 		if (this.closed) return;
+// 		if (!this._connections.has(peerConnection.peerConnectionId)) return;
 
-		const { onUpdate } = this._connections.get(peerConnection.peerConnectionId) ?? {};
+// 		const { onUpdate } = this._connections.get(peerConnection.peerConnectionId) ?? {};
 		
-		if (!onUpdate) return;
+// 		if (!onUpdate) return;
 
-		peerConnection.ICE.off('update', onUpdate);
+// 		peerConnection.ICE.off('update', onUpdate);
 
-		this._connections.delete(peerConnection.peerConnectionId);
+// 		this._connections.delete(peerConnection.peerConnectionId);
 
-		this.emit('removepeerconnection', peerConnection);
-	}
+// 		this.emit('removepeerconnection', peerConnection);
+// 	}
 
-	public get turnIps() {
-		return Array.from(this._turnUsage.keys());
-	}
+// 	public get turnIps() {
+// 		return Array.from(this._turnUsage.keys());
+// 	}
 
-	public get peerConnections() {
-		return Array.from(this._connections.values()).map(({ peerConnection }) => peerConnection);
-	}
+// 	public get peerConnections() {
+// 		return Array.from(this._connections.values()).map(({ peerConnection }) => peerConnection);
+// 	}
 
-	public getUsage(turnIp: string) {
-		return this._turnUsage.get(turnIp);
-	}
+// 	public getUsage(turnIp: string) {
+// 		return this._turnUsage.get(turnIp);
+// 	}
 
-	public get clients(): ReadonlyMap<string, ObservedClient> {
-		const result = new Map<string, ObservedClient>();
+// 	public get clients(): ReadonlyMap<string, ObservedClient> {
+// 		const result = new Map<string, ObservedClient>();
 
-		for (const pc of this.peerConnections) {
-			if (result.has(pc.clientId)) continue;
+// 		for (const pc of this.peerConnections) {
+// 			if (result.has(pc.clientId)) continue;
 			
-			result.set(pc.clientId, pc.client);
-		}
+// 			result.set(pc.clientId, pc.client);
+// 		}
 
-		return result;
-	}
+// 		return result;
+// 	}
 
-	public get closed() {
-		return this._closed;
-	}
+// 	public get closed() {
+// 		return this._closed;
+// 	}
 
-	public close() {
-		if (this._closed) return;
-		this._closed = true;
+// 	public close() {
+// 		if (this._closed) return;
+// 		this._closed = true;
 
-		this.emit('close');
-	}
-}
+// 		this.emit('close');
+// 	}
+// }

package/src/schema/ClientEventTypes.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-shadow */
+
+export enum ClientEventTypes {
+	CLIENT_JOINED = 'CLIENT_JOINED',
+	CLIENT_LEFT = 'CLIENT_LEFT',
+	PEER_CONNECTION_OPENED = 'PEER_CONNECTION_OPENED',
+	PEER_CONNECTION_CLOSED = 'PEER_CONNECTION_CLOSED',
+	MEDIA_TRACK_ADDED = 'MEDIA_TRACK_ADDED',
+	MEDIA_TRACK_REMOVED = 'MEDIA_TRACK_REMOVED',
+	MEDIA_TRACK_RESUMED = 'MEDIA_TRACK_RESUMED',
+	MEDIA_TRACK_MUTED = 'MEDIA_TRACK_MUTED',
+	MEDIA_TRACK_UNMUTED = 'MEDIA_TRACK_UNMUTED',
+	ICE_GATHERING_STATE_CHANGED = 'ICE_GATHERING_STATE_CHANGED',
+	PEER_CONNECTION_STATE_CHANGED = 'PEER_CONNECTION_STATE_CHANGED',
+	ICE_CONNECTION_STATE_CHANGED = 'ICE_CONNECTION_STATE_CHANGED',
+	DATA_CHANNEL_OPEN = 'DATA_CHANNEL_OPEN',
+	DATA_CHANNEL_CLOSED = 'DATA_CHANNEL_CLOSED',
+	DATA_CHANNEL_ERROR = 'DATA_CHANNEL_ERROR',
+	NEGOTIATION_NEEDED = 'NEGOTIATION_NEEDED',
+	SIGNALING_STATE_CHANGE = 'SIGNALING_STATE_CHANGE',
+	ICE_GATHERING_STATE_CHANGE = 'ICE_GATHERING_STATE_CHANGE',
+	ICE_CONNECTION_STATE_CHANGE = 'ICE_CONNECTION_STATE_CHANGE',
+	ICE_CANDIDATE = 'ICE_CANDIDATE',
+	
+	// mediasoup events
+	PRODUCER_ADDED = 'PRODUCER_ADDED',
+	PRODUCER_REMOVED = 'PRODUCER_REMOVED',
+	PRODUCER_PAUSED = 'PRODUCER_PAUSED',
+	PRODUCER_RESUMED = 'PRODUCER_RESUMED',
+	CONSUMER_ADDED = 'CONSUMER_ADDED',
+	CONSUMER_REMOVED = 'CONSUMER_REMOVED',
+	DATA_PRODUCER_CREATED = 'DATA_PRODUCER_CREATED',
+	DATA_PRODUCER_CLOSED = 'DATA_PRODUCER_CLOSED',
+	DATA_CONSUMER_CREATED = 'DATA_CONSUMER_CREATED',
+	DATA_CONSUMER_CLOSED = 'DATA_CONSUMER_CLOSED',
+}
+
+export interface PeerConnectionOpenedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceConnectionState: string;
+	iceGatheringState: string;
+	signalingState: string;
+}
+
+export interface PeerConnectionClosedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceConnectionState: string;
+	iceGatheringState: string;
+	signalingState: string;
+}
+
+export interface MediaTrackMutedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface MediaTrackUnmutedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface MediaTrackAddedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+	constraints: MediaTrackConstraints,
+	capabilities: MediaTrackCapabilities,
+	settings: MediaTrackSettings,
+}
+
+export interface MediaTrackRemovedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface DataChannelErrorEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+	error: string,
+}
+
+export interface DataChannelOpenEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+}
+
+export interface DataChannelClosedEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+}

package/src/schema/ClientMetaTypes.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-shadow */
+
+export enum ClientMetaTypes {
+	MEDIA_CONSTRAINT = 'MEDIA_CONSTRAINT',
+	MEDIA_DEVICE = 'MEDIA_DEVICE',
+	MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = 'MEDIA_DEVICES_SUPPORTED_CONSTRAINTS',
+	USER_MEDIA_ERROR = 'USER_MEDIA_ERROR',
+	LOCAL_SDP = 'LOCAL_SDP',
+
+	OPERATION_SYSTEM = 'OPERATION_SYSTEM',
+	ENGINE = 'ENGINE',
+	PLATFORM = 'PLATFORM',
+	BROWSER = 'BROWSER',
+}
+
+export type MediaDeviceInfo = {
+	deviceId: string;
+	label: string;
+	kind: string;
+	groupId: string;
+}
+
+export type Browser = {
+	name: string;
+	version: string;
+}
+
+export type Platform = {
+	name: string;
+	version: string;
+}
+
+export type Engine = {
+	name: string;
+	version: string;
+}
+
+export type OperationSystem = {
+	name: string;
+	version: string;
+}