@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-ea70eab.0

package/src/schema/ClientEventTypes.ts

@@ -0,0 +1,176 @@
+/* eslint-disable no-shadow */
+
+interface DoubleRange {
+	max?: number;
+	min?: number;
+}
+
+interface ULongRange {
+	max?: number;
+	min?: number;
+}
+
+interface MediaTrackConstraints {
+	aspectRatio?: DoubleRange;
+	autoGainControl?: boolean[];
+	backgroundBlur?: boolean[];
+	channelCount?: ULongRange;
+	deviceId?: string;
+	displaySurface?: string;
+	echoCancellation?: boolean[];
+	facingMode?: string[];
+	frameRate?: DoubleRange;
+	groupId?: string;
+	height?: ULongRange;
+	noiseSuppression?: boolean[];
+	sampleRate?: ULongRange;
+	sampleSize?: ULongRange;
+	width?: ULongRange;
+}
+
+interface MediaTrackCapabilities {
+	aspectRatio?: DoubleRange;
+	autoGainControl?: boolean[];
+	backgroundBlur?: boolean[];
+	channelCount?: ULongRange;
+	deviceId?: string;
+	displaySurface?: string;
+	echoCancellation?: boolean[];
+	facingMode?: string[];
+	frameRate?: DoubleRange;
+	groupId?: string;
+	height?: ULongRange;
+	noiseSuppression?: boolean[];
+	sampleRate?: ULongRange;
+	sampleSize?: ULongRange;
+	width?: ULongRange;
+}
+
+interface MediaTrackSettings {
+	aspectRatio?: number;
+	autoGainControl?: boolean;
+	backgroundBlur?: boolean;
+	channelCount?: number;
+	deviceId?: string;
+	displaySurface?: string;
+	echoCancellation?: boolean;
+	facingMode?: string;
+	frameRate?: number;
+	groupId?: string;
+	height?: number;
+	noiseSuppression?: boolean;
+	sampleRate?: number;
+	sampleSize?: number;
+	width?: number;
+}
+
+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/{metaTypes.ts → ClientMetaTypes.ts}

@@ -1,6 +1,6 @@
 /* eslint-disable no-shadow */
 
-export enum ClientMetaType {
+export enum ClientMetaTypes {
 	MEDIA_CONSTRAINT = 'MEDIA_CONSTRAINT',
 	MEDIA_DEVICE = 'MEDIA_DEVICE',
 	MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = 'MEDIA_DEVICES_SUPPORTED_CONSTRAINTS',

package/src/schema/ClientSample.ts

@@ -170,7 +170,7 @@ export type IceCandidatePairStats = {
 	*/
 	remoteCandidateId?: string;
 
-	state?: 'new' | 'inProgress' | 'failed' | 'succeeded';
+	state?: 'new' | 'in-progress' | 'waiting' | 'failed' | 'succeeded' | 'cancelled' | 'inprogress';
 
 	/**
 	* Whether this candidate pair has been nominated.

package/src/updaters/ObserverUpdater.ts

@@ -0,0 +1,5 @@
+import { ObservedCall } from '../ObservedCall';
+
+export interface ObserverUpdater {
+	onCallUpdate(observedCall: ObservedCall): void;
+}

package/src/updaters/OnAllCallObserverUpdater.ts

@@ -0,0 +1,59 @@
+import { ObservedCall } from '../ObservedCall';
+import { Observer } from '../Observer';
+import { Updater } from './Updater';
+
+export class OnAllCallObserverUpdater implements Updater {
+	public readonly name = 'OnAllCallObserverUpdater';
+	public readonly description = 'Call Observer\'s update() method when all of the ObservedCalls are updated';
+	
+	private readonly _updatedCalls = new Set<string>();
+	public closed = false;
+
+	public constructor(
+		private observer: Observer
+	) {
+		this._onNewObservedCall = this._onNewObservedCall.bind(this);
+
+		this.observer.once('close', () => {
+			this.observer.off('newcall', this._onNewObservedCall);
+		});
+		this.observer.on('newcall', this._onNewObservedCall);
+	}
+
+	close(): void {
+		if (this.closed) return;
+		this.closed = true;
+
+		this._updatedCalls.clear();
+	}
+
+	private _onNewObservedCall(observedCall: ObservedCall) {
+		if (this.closed) return;
+		
+		const onUpdate = () => this._onObservedCallUpdated(observedCall);
+
+		observedCall.once('close', () => {
+			observedCall.off('update', onUpdate);
+			this._updatedCalls.delete(observedCall.callId);
+
+			this._updateIfEveryCallUpdated();
+		});
+		observedCall.on('update', onUpdate);
+	}
+
+	private _onObservedCallUpdated(observedCall: ObservedCall) {
+		if (observedCall.closed) return;
+
+		this._updatedCalls.add(observedCall.callId);
+
+		this._updateIfEveryCallUpdated();
+	}
+
+	private _updateIfEveryCallUpdated() {
+		if (this._updatedCalls.size < this.observer.observedCalls.size) return;
+		else if (this.closed) return;
+
+		this._updatedCalls.clear();
+		this.observer.update();
+	}
+}

package/src/updaters/OnAllClientCallUpdater.ts

@@ -0,0 +1,61 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedClient } from '../ObservedClient';
+import { Updater } from './Updater';
+ 
+export class OnAllClientCallUpdater implements Updater {
+	readonly name = 'OnAllClientCallUpdater';
+	readonly description = 'Call the update() method of the ObservedCall once all client has been updated';
+
+	private readonly _updatedClients = new Set<string>();
+	public closed = false;
+
+	public constructor(
+		private _observedCall: ObservedCall
+	) {
+		this._onNewObservedClient = this._onNewObservedClient.bind(this);
+
+		this._observedCall.once('close', () => {
+			this._observedCall.off('newclient', this._onNewObservedClient);
+		});
+		this._observedCall.on('newclient', this._onNewObservedClient);
+	}
+	
+	public close(): void {
+		if (this.closed) return;
+		this.closed = true;
+		// do nothing, as close once emitted unsubscription happened
+		this._updatedClients.clear();
+	}
+
+	private _onNewObservedClient(observedClient: ObservedClient) {
+		if (this.closed) return;
+		
+		const onUpdate = () => this._onClientUpdate(observedClient);
+
+		observedClient.once('close', () => {
+			observedClient.off('update', onUpdate);
+			this._updatedClients.delete(observedClient.clientId);
+			this._updateIfEveryClientUpdated();
+		});
+		observedClient.on('update', onUpdate);
+	}
+
+	private _onClientUpdate(observedClient: ObservedClient) {
+		if (observedClient.closed) return;
+
+		this._updatedClients.add(observedClient.clientId);
+		this._updateIfEveryClientUpdated();
+	}
+
+	private _updateIfEveryClientUpdated() {
+		if (this._updatedClients.size < this._observedCall.observedClients.size) {
+			return;
+		} else if (this.closed) {
+			return;
+		}
+
+		this._updatedClients.clear();
+		this._observedCall.update();
+	}
+
+}	

package/src/updaters/OnAnyCallObserverUpdater.ts

@@ -0,0 +1,41 @@
+import { ObservedCall } from '../ObservedCall';
+import { Observer } from '../Observer';
+import { Updater } from './Updater';
+ 
+export class OnAnyCallObserverUpdater implements Updater {
+	public readonly name = 'OnAnyCallObserverUpdater';
+	public readonly description = 'Call Observer\'s update() method on any of the ObservedCall is updated';
+	public closed = false;
+
+	public constructor(
+		private observver: Observer
+	) {
+		this._onNewObservedCall = this._onNewObservedCall.bind(this);
+
+		this.observver.once('close', () => {
+			this.observver.off('newcall', this._onNewObservedCall);
+		});
+		this.observver.on('newcall', this._onNewObservedCall);
+	}
+
+	public close(): void {
+		if (this.closed) return;
+		this.closed = true;
+		// do nothing, because we unsubscribe once close is emitted from observer
+	}
+
+	private _onNewObservedCall(observedCall: ObservedCall) {
+		if (this.closed) return;
+		
+		const onUpdate = () => {
+			if (this.closed) return;
+
+			this.observver.update();
+		};
+
+		observedCall.once('close', () => {
+			observedCall.off('update', onUpdate);
+		});
+		observedCall.on('update', onUpdate);
+	}
+}

package/src/updaters/OnAnyClientCallUpdater.ts

@@ -0,0 +1,39 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedClient } from '../ObservedClient';
+import { Updater } from './Updater';
+ 
+export class OnAnyClientCallUpdater implements Updater {
+	readonly name = 'OnAnyClientCallUpdater';
+	readonly description = 'Call the update() method of the ObservedCall when any of the client has been updated';
+	public closed = false;
+
+	public constructor(
+		private _observedCall: ObservedCall
+	) {
+		this._onNewObservedClient = this._onNewObservedClient.bind(this);
+
+		this._observedCall.once('close', () => {
+			this._observedCall.off('newclient', this._onNewObservedClient);
+		});
+		this._observedCall.on('newclient', this._onNewObservedClient);
+	}
+	
+	public close(): void {
+		if (this.closed) return;
+		this.closed = true;
+	}
+
+	private _onNewObservedClient(observedClient: ObservedClient) {
+		if (this.closed) return;
+		
+		const onUpdate = () => {
+			if (this.closed) return;
+			this._observedCall.update();
+		};
+
+		observedClient.once('close', () => {
+			observedClient.off('update', onUpdate);
+		});
+		observedClient.on('update', onUpdate);
+	}
+}

package/src/updaters/OnIntervalUpdater.ts

@@ -0,0 +1,19 @@
+import { Updater } from './Updater';
+
+export class OnIntervalUpdater implements Updater {
+	readonly name = 'OnIntervalUpdater';
+	readonly description = 'Call the update() method given in the constructor once the interval elapsed';
+
+	public timer: ReturnType<typeof setInterval>;
+
+	public constructor(
+		intervalInMs: number,
+		private readonly _update: () => void,
+	) {
+		this.timer = setInterval(() => this._update(), intervalInMs);
+	}
+	
+	public close(): void {
+		clearInterval(this.timer);
+	}
+}

package/src/updaters/Updater.ts

@@ -0,0 +1,5 @@
+export interface Updater {
+	readonly name: string;
+	readonly description?: string;
+	close(): void;
+}

package/src/utils/MediasoupRemoteTrackResolver.ts

@@ -0,0 +1,155 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedCallEventMonitor } from '../ObservedCallEventMonitor';
+import { ObservedInboundTrack } from '../ObservedInboundTrack';
+import { ObservedOutboundTrack } from '../ObservedOutboundTrack';
+import { RemoteTrackResolver } from './RemoteTrackResolver';
+
+export class MediasoupRemoteTrackResolver implements RemoteTrackResolver {
+	public readonly eventMonitor: ObservedCallEventMonitor<{
+		// empty
+	}>;
+
+	private _consumerIdToProducerId = new Map<string, string>();
+	private _producerIdToOutboundTrack = new Map<string, ObservedOutboundTrack>();
+	private _consumerIdToInboundTrack = new Map<string, ObservedInboundTrack>();
+	// private _producerIdToOutboundTrack = new Map<string, ObservedOutboundTrack>();
+
+	private _inboundTrackToConsumerId = new Map<string, string>();
+	private _producerIdToConsumerIds = new Map<string, string[]>();
+	private _outboundTrackToProducerId = new Map<string, string>();
+
+	public constructor(
+		public readonly observedCall: ObservedCall
+	) {
+		this.eventMonitor = this.observedCall.createEventMonitor({});
+
+		this.eventMonitor.onInboundTrackAdded = this._addInboundTrack.bind(this);
+		this.eventMonitor.onInboundTrackRemoved = this._removeInboundTrack.bind(this);
+		this.eventMonitor.onOutboundTrackAdded = this._addOutboundTrack.bind(this);
+		this.eventMonitor.onOutboundTrackRemoved = this._removeOutboundTrack.bind(this);
+
+		// this.eventMonitor.onClientEvent = (client, event) => {
+            
+		// };
+	}
+
+	public resolveRemoteOutboundTrack(inboundTrack: ObservedInboundTrack): ObservedOutboundTrack | undefined {
+		const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
+
+		if (!consumerId) return;
+        
+		const producerId = this._consumerIdToProducerId.get(consumerId);
+
+		if (!producerId) return;
+
+		return this._producerIdToOutboundTrack.get(producerId);
+	}
+
+	public resolveRemoteInboundTracks(outboundTrack: ObservedOutboundTrack): ObservedInboundTrack[] | undefined {
+		const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
+
+		if (!producerId) return;
+
+		const consumerIds = this._producerIdToConsumerIds.get(producerId);
+
+		if (!consumerIds) return;
+		
+		return consumerIds
+			.map((consumerId) => this._consumerIdToInboundTrack.get(consumerId))
+			.filter((inboundTrack) => Boolean(inboundTrack)) as ObservedInboundTrack[]
+		;     
+	}
+
+	private _addInboundTrack(inboundTrack: ObservedInboundTrack) {
+		const attachments = this._getInboundTrackAttachments(inboundTrack);
+
+		if (!attachments) return;
+
+		const {
+			producerId,
+			consumerId
+		} = attachments;
+
+		this._inboundTrackToConsumerId.set(inboundTrack.id, consumerId);
+		this._consumerIdToProducerId.set(consumerId, producerId);
+		this._consumerIdToInboundTrack.set(consumerId, inboundTrack);
+
+		let producerConsumers = this._producerIdToConsumerIds.get(producerId);
+
+		if (!producerConsumers) {
+			producerConsumers = [];
+			this._producerIdToConsumerIds.set(producerId, producerConsumers);
+		}
+		producerConsumers.push(consumerId);
+	}
+
+	private _removeInboundTrack(inboundTrack: ObservedInboundTrack) {
+		const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
+
+		if (!consumerId) return;
+
+		this._inboundTrackToConsumerId.delete(inboundTrack.id);
+		this._consumerIdToProducerId.delete(consumerId);
+		this._consumerIdToInboundTrack.delete(consumerId);
+        
+		const producerConsumers = this._producerIdToConsumerIds.get(consumerId);
+
+		if (!producerConsumers) return;
+
+		const filteredProducerConsumers = producerConsumers.filter((id) => id !== consumerId);
+
+		if (filteredProducerConsumers.length === 0) {
+			this._producerIdToConsumerIds.delete(consumerId);
+		} else {
+			this._producerIdToConsumerIds.set(consumerId, filteredProducerConsumers);
+		}
+	}
+
+	private _addOutboundTrack(outboundTrack: ObservedOutboundTrack) {
+		const attachments = this._getOutboundTrackAttachments(outboundTrack);
+
+		if (!attachments) return;
+
+		const {
+			producerId,
+		} = attachments;
+
+		this._producerIdToOutboundTrack.set(producerId, outboundTrack);
+		this._outboundTrackToProducerId.set(outboundTrack.id, producerId);
+	}
+
+	private _removeOutboundTrack(outboundTrack: ObservedOutboundTrack) {
+		const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
+
+		if (!producerId) return;
+
+		this._producerIdToOutboundTrack.delete(producerId);
+		this._outboundTrackToProducerId.delete(outboundTrack.id);
+	}
+
+	private _getInboundTrackAttachments(inboundTrack: ObservedInboundTrack) {
+		const {
+			producerId,
+			consumerId
+		} = inboundTrack.attachments ?? {};
+
+		if (!producerId || !consumerId || typeof producerId !== 'string' || typeof consumerId !== 'string') return;
+
+		return {
+			producerId,
+			consumerId
+		};
+	}
+
+	private _getOutboundTrackAttachments(outboundTrack: ObservedOutboundTrack) {
+		const {
+			producerId,
+		} = outboundTrack.attachments ?? {};
+
+		if (!producerId || typeof producerId !== 'string') return;
+
+		return {
+			producerId,
+		};
+	}
+}

package/tsconfig.json

@@ -2,7 +2,7 @@
 	"compileOnSave": true,
 	"compilerOptions":
 	{
-		"lib": [ "ES2020" ],
+		"lib": [ "ES2020", "dom" ],
 		"target": "ESNext",
 		"module": "CommonJS",
 		"moduleResolution": "node",

package/lib/schema/eventTypes.d.ts

@@ -1,33 +0,0 @@
-export declare enum ClientEventType {
-    CALL_STARTED = "CALL_STARTED",
-    CALL_ENDED = "CALL_ENDED",
-    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",
-    PRODUCER_ADDED = "PRODUCER_ADDED",
-    PRODUCER_REMOVED = "PRODUCER_REMOVED",
-    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"
-}
-//# sourceMappingURL=eventTypes.d.ts.map

package/lib/schema/eventTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventTypes.d.ts","sourceRoot":"","sources":["../../src/schema/eventTypes.ts"],"names":[],"mappings":"AAEA,oBAAY,eAAe;IAC1B,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,sBAAsB,2BAA2B;IACjD,sBAAsB,2BAA2B;IACjD,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,2BAA2B,gCAAgC;IAC3D,6BAA6B,kCAAkC;IAC/D,4BAA4B,iCAAiC;IAC7D,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,sBAAsB,2BAA2B;IACjD,0BAA0B,+BAA+B;IACzD,2BAA2B,gCAAgC;IAC3D,aAAa,kBAAkB;IAG/B,cAAc,mBAAmB;IACjC,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,gBAAgB,qBAAqB;IACrC,qBAAqB,0BAA0B;IAC/C,oBAAoB,yBAAyB;IAC7C,qBAAqB,0BAA0B;IAC/C,oBAAoB,yBAAyB;CAC7C"}

package/lib/schema/eventTypes.js

@@ -1,38 +0,0 @@
-"use strict";
-/* eslint-disable no-shadow */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientEventType = void 0;
-var ClientEventType;
-(function (ClientEventType) {
-    ClientEventType["CALL_STARTED"] = "CALL_STARTED";
-    ClientEventType["CALL_ENDED"] = "CALL_ENDED";
-    ClientEventType["CLIENT_JOINED"] = "CLIENT_JOINED";
-    ClientEventType["CLIENT_LEFT"] = "CLIENT_LEFT";
-    ClientEventType["PEER_CONNECTION_OPENED"] = "PEER_CONNECTION_OPENED";
-    ClientEventType["PEER_CONNECTION_CLOSED"] = "PEER_CONNECTION_CLOSED";
-    ClientEventType["MEDIA_TRACK_ADDED"] = "MEDIA_TRACK_ADDED";
-    ClientEventType["MEDIA_TRACK_REMOVED"] = "MEDIA_TRACK_REMOVED";
-    ClientEventType["MEDIA_TRACK_RESUMED"] = "MEDIA_TRACK_RESUMED";
-    ClientEventType["MEDIA_TRACK_MUTED"] = "MEDIA_TRACK_MUTED";
-    ClientEventType["MEDIA_TRACK_UNMUTED"] = "MEDIA_TRACK_UNMUTED";
-    ClientEventType["ICE_GATHERING_STATE_CHANGED"] = "ICE_GATHERING_STATE_CHANGED";
-    ClientEventType["PEER_CONNECTION_STATE_CHANGED"] = "PEER_CONNECTION_STATE_CHANGED";
-    ClientEventType["ICE_CONNECTION_STATE_CHANGED"] = "ICE_CONNECTION_STATE_CHANGED";
-    ClientEventType["DATA_CHANNEL_OPEN"] = "DATA_CHANNEL_OPEN";
-    ClientEventType["DATA_CHANNEL_CLOSED"] = "DATA_CHANNEL_CLOSED";
-    ClientEventType["DATA_CHANNEL_ERROR"] = "DATA_CHANNEL_ERROR";
-    ClientEventType["NEGOTIATION_NEEDED"] = "NEGOTIATION_NEEDED";
-    ClientEventType["SIGNALING_STATE_CHANGE"] = "SIGNALING_STATE_CHANGE";
-    ClientEventType["ICE_GATHERING_STATE_CHANGE"] = "ICE_GATHERING_STATE_CHANGE";
-    ClientEventType["ICE_CONNECTION_STATE_CHANGE"] = "ICE_CONNECTION_STATE_CHANGE";
-    ClientEventType["ICE_CANDIDATE"] = "ICE_CANDIDATE";
-    // mediasoup events
-    ClientEventType["PRODUCER_ADDED"] = "PRODUCER_ADDED";
-    ClientEventType["PRODUCER_REMOVED"] = "PRODUCER_REMOVED";
-    ClientEventType["CONSUMER_ADDED"] = "CONSUMER_ADDED";
-    ClientEventType["CONSUMER_REMOVED"] = "CONSUMER_REMOVED";
-    ClientEventType["DATA_PRODUCER_CREATED"] = "DATA_PRODUCER_CREATED";
-    ClientEventType["DATA_PRODUCER_CLOSED"] = "DATA_PRODUCER_CLOSED";
-    ClientEventType["DATA_CONSUMER_CREATED"] = "DATA_CONSUMER_CREATED";
-    ClientEventType["DATA_CONSUMER_CLOSED"] = "DATA_CONSUMER_CLOSED";
-})(ClientEventType = exports.ClientEventType || (exports.ClientEventType = {}));

package/lib/schema/metaTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metaTypes.d.ts","sourceRoot":"","sources":["../../src/schema/metaTypes.ts"],"names":[],"mappings":"AAEA,oBAAY,cAAc;IACzB,gBAAgB,qBAAqB;IACrC,YAAY,iBAAiB;IAC7B,mCAAmC,wCAAwC;IAC3E,gBAAgB,qBAAqB;IACrC,SAAS,cAAc;IAEvB,gBAAgB,qBAAqB;IACrC,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,OAAO,YAAY;CACnB;AAED,MAAM,MAAM,eAAe,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB,CAAA"}