@yang__yj/pixelstreaming-core 1.0.0 → 1.0.1

package/src/__test__/mockMediaStream.ts

@@ -0,0 +1,124 @@
+export class MockMediaStreamImpl implements MediaStream {
+    active: boolean;
+    id: string;
+
+    constructor(data?: MediaStream | MediaStreamTrack[]) {
+        //
+    }
+
+    onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+    onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+    addTrack(track: MediaStreamTrack): void {
+        throw new Error("Method not implemented.");
+    }
+    clone(): MediaStream {
+        throw new Error("Method not implemented.");
+    }
+    getAudioTracks(): MediaStreamTrack[] {
+        throw new Error("Method not implemented.");
+    }
+    getTrackById(trackId: string): MediaStreamTrack | null {
+        throw new Error("Method not implemented.");
+    }
+    getTracks(): MediaStreamTrack[] {
+        throw new Error("Method not implemented.");
+    }
+    getVideoTracks(): MediaStreamTrack[] {
+        throw new Error("Method not implemented.");
+    }
+    removeTrack(track: MediaStreamTrack): void {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event: Event): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+}
+
+export class MockMediaStreamTrackImpl implements MediaStreamTrack {
+    contentHint: string;
+    enabled: boolean;
+    id: string;
+    kind: string;
+    label: string;
+    muted: boolean;
+    readyState: MediaStreamTrackState;
+
+    constructor() {
+        this.kind = 'video';
+        this.readyState = 'live';
+    }
+
+    onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    applyConstraints(constraints?: MediaTrackConstraints | undefined): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+    clone(): MediaStreamTrack {
+        throw new Error("Method not implemented.");
+    }
+    getCapabilities(): MediaTrackCapabilities {
+        throw new Error("Method not implemented.");
+    }
+    getConstraints(): MediaTrackConstraints {
+        throw new Error("Method not implemented.");
+    }
+    getSettings(): MediaTrackSettings {
+        throw new Error("Method not implemented.");
+    }
+    stop(): void {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event: Event): boolean {
+        throw new Error("Method not implemented.");
+    }
+}
+
+const mockHTMLMediaElementPlay = (ableToPlay: boolean) => {
+    if (ableToPlay) {
+        return Promise.resolve();
+    }
+    return Promise.reject("mock cancel");
+};
+
+const originalMediaStream = global.MediaStream;
+const originalMediaStreamTrack = global.MediaStreamTrack;
+export const mockMediaStream = () => {
+    global.MediaStream = MockMediaStreamImpl;
+    global.MediaStreamTrack = MockMediaStreamTrackImpl;
+}
+
+export const unmockMediaStream = () => {
+    global.MediaStream = originalMediaStream;
+    global.MediaStreamTrack = originalMediaStreamTrack;
+}
+
+export const mockHTMLMediaElement = (options: { ableToPlay: boolean, readyState?: number }) => {
+    const { ableToPlay, readyState } = options;
+    jest.spyOn(HTMLMediaElement.prototype, 'play').mockReturnValue(mockHTMLMediaElementPlay(ableToPlay));
+    if (readyState !== undefined) {
+        jest.spyOn(HTMLMediaElement.prototype, 'readyState', 'get').mockReturnValue(readyState);
+    }
+}
+

package/src/__test__/mockRTCPeerConnection.ts

@@ -0,0 +1,347 @@
+export interface MockRTCPeerConnectionSpyFunctions {
+    constructorSpy: null | ((config: RTCConfiguration) => void);
+    closeSpy: null | (() => void);
+    setRemoteDescriptionSpy: null | ((description: RTCSessionDescriptionInit) => void);
+    setLocalDescriptionSpy: null | ((description: RTCLocalSessionDescriptionInit) => void);
+    createAnswerSpy: null | (() => void);
+    addTransceiverSpy: null | ((trackOrKind: string | MediaStreamTrack, init?: RTCRtpTransceiverInit | undefined) => void);
+    addIceCandidateSpy: null | ((candidate: RTCIceCandidateInit) => void);
+    sendDataSpy: null | ((data: ArrayBuffer) => void);
+}
+
+export interface MockRTCPeerConnectionTriggerFunctions {
+    triggerIceConnectionStateChange: null | ((state: RTCIceConnectionState) => void);
+    triggerOnTrack: null | ((data: RTCTrackEventInit) => void);
+    triggerOnIceCandidate: null | ((data: RTCPeerConnectionIceEventInit) => void);
+    triggerOnDataChannel: null | ((data: RTCDataChannelEventInit) => void);
+}
+
+const spyFunctions: MockRTCPeerConnectionSpyFunctions = {
+    constructorSpy: null,
+    closeSpy: null,
+    setRemoteDescriptionSpy: null,
+    setLocalDescriptionSpy: null,
+    createAnswerSpy: null,
+    addTransceiverSpy: null,
+    addIceCandidateSpy: null,
+    sendDataSpy: null,
+};
+
+const triggerFunctions: MockRTCPeerConnectionTriggerFunctions = {
+    triggerIceConnectionStateChange: null,
+    triggerOnTrack: null,
+    triggerOnIceCandidate: null,
+    triggerOnDataChannel: null
+};
+
+export class MockRTCPeerConnectionImpl implements RTCPeerConnection {
+
+    canTrickleIceCandidates: boolean | null;
+    connectionState: RTCPeerConnectionState;
+    currentLocalDescription: RTCSessionDescription | null;
+    currentRemoteDescription: RTCSessionDescription | null;
+    iceConnectionState: RTCIceConnectionState;
+    iceGatheringState: RTCIceGatheringState;
+    localDescription: RTCSessionDescription | null;
+    pendingLocalDescription: RTCSessionDescription | null;
+    pendingRemoteDescription: RTCSessionDescription | null;
+    remoteDescription: RTCSessionDescription | null;
+    sctp: RTCSctpTransport | null;
+    signalingState: RTCSignalingState;
+    _dataChannels: RTCDataChannel[] = [];
+
+    constructor(config: RTCConfiguration) {
+        this.connectionState = "new";
+        this.iceConnectionState = "new";
+        spyFunctions.constructorSpy?.(config);
+        triggerFunctions.triggerIceConnectionStateChange = this.triggerIceConnectionStateChange.bind(this);
+        triggerFunctions.triggerOnTrack = this.triggerOnTrack.bind(this);
+        triggerFunctions.triggerOnIceCandidate = this.triggerOnIceCandidate.bind(this);
+        triggerFunctions.triggerOnDataChannel =
+            this.triggerOnDataChannel.bind(this);
+    }
+
+    onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
+    onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
+    addIceCandidate(candidate?: RTCIceCandidateInit | undefined): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    addIceCandidate(candidate?: unknown, successCallback?: unknown, failureCallback?: unknown): Promise<void> {
+        if (this.iceConnectionState !== "connected" && this.iceConnectionState !== "completed") {
+            this.iceConnectionState = "checking";
+        }
+        this.oniceconnectionstatechange?.(new Event("iceconnectionstatechange"));
+        spyFunctions.addIceCandidateSpy?.(candidate as RTCIceCandidateInit);
+        return Promise.resolve();
+    }
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender {
+        throw new Error("Method not implemented.");
+    }
+    addTransceiver(trackOrKind: string | MediaStreamTrack, init?: RTCRtpTransceiverInit | undefined): RTCRtpTransceiver {
+        spyFunctions.addTransceiverSpy?.(trackOrKind, init);
+        return {} as RTCRtpTransceiver;
+    }
+    createAnswer(options?: RTCAnswerOptions | undefined): Promise<RTCSessionDescriptionInit>;
+    createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    createAnswer(successCallback?: unknown, failureCallback?: unknown): Promise<void> | Promise<RTCSessionDescriptionInit> {
+        spyFunctions.createAnswerSpy?.();
+        const res: RTCSessionDescriptionInit = {
+            type: "answer",
+            sdp: "v=0\r\no=- 5791786663981007547 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=group:BUNDLE 0 1 2\r\na=extmap-allow-mixed\r\na=msid-semantic: WMS\r\nm=video 9 UDP/TLS/RTP/SAVPF 96 98\r\nc=IN IP4 0.0.0.0\r\na=rtcp:9 IN IP4 0.0.0.0\r\na=ice-ufrag:z0li\r\na=ice-pwd:DkbG5Q3dFSIygDc47cms4TGA\r\na=ice-options:trickle\r\na=fingerprint:sha-256 F9:5B:3C:AB:89:88:0E:1B:2E:63:B3:D2:B8:92:59:E2:3A:46:B6:85:09:F4:50:0E:72:4F:9F:70:6D:5F:BD:1A\r\na=setup:active\r\na=mid:0\r\na=extmap:1 urn:ietf:params:rtp-hdrext:toffset\r\na=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\na=extmap:3 urn:3gpp:video-orientation\r\na=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\na=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay\r\na=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type\r\na=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing\r\na=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space\r\na=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\r\na=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\r\na=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\r\na=recvonly\r\na=rtcp-mux\r\na=rtcp-rsize\r\na=rtpmap:96 H264/90000\r\na=rtcp-fb:96 goog-remb\r\na=rtcp-fb:96 transport-cc\r\na=rtcp-fb:96 ccm fir\r\na=rtcp-fb:96 nack\r\na=rtcp-fb:96 nack pli\r\na=fmtp:96 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\r\na=rtpmap:98 H264/90000\r\na=rtcp-fb:98 goog-remb\r\na=rtcp-fb:98 transport-cc\r\na=rtcp-fb:98 ccm fir\r\na=rtcp-fb:98 nack\r\na=rtcp-fb:98 nack pli\r\na=fmtp:98 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111 63 110\r\nc=IN IP4 0.0.0.0\r\na=rtcp:9 IN IP4 0.0.0.0\r\na=ice-ufrag:z0li\r\na=ice-pwd:DkbG5Q3dFSIygDc47cms4TGA\r\na=ice-options:trickle\r\na=fingerprint:sha-256 F9:5B:3C:AB:89:88:0E:1B:2E:63:B3:D2:B8:92:59:E2:3A:46:B6:85:09:F4:50:0E:72:4F:9F:70:6D:5F:BD:1A\r\na=setup:active\r\na=mid:1\r\na=extmap:14 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\na=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\na=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\na=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\r\na=recvonly\r\na=rtcp-mux\r\na=rtpmap:111 opus/48000/2\r\na=rtcp-fb:111 transport-cc\r\na=fmtp:111 minptime=10;useinbandfec=1\r\na=rtpmap:63 red/48000/2\r\na=fmtp:63 111/111\r\na=rtpmap:110 telephone-event/48000\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\nc=IN IP4 0.0.0.0\r\na=ice-ufrag:z0li\r\na=ice-pwd:DkbG5Q3dFSIygDc47cms4TGA\r\na=ice-options:trickle\r\na=fingerprint:sha-256 F9:5B:3C:AB:89:88:0E:1B:2E:63:B3:D2:B8:92:59:E2:3A:46:B6:85:09:F4:50:0E:72:4F:9F:70:6D:5F:BD:1A\r\na=setup:active\r\na=mid:2\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n"
+        };
+        return Promise.resolve(res);
+    }
+    createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit | undefined): RTCDataChannel {
+        const dataChannel = new RTCDataChannel();
+        this._dataChannels.push(dataChannel);
+        return dataChannel;
+    }
+    createOffer(options?: RTCOfferOptions | undefined): Promise<RTCSessionDescriptionInit>;
+    createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback, options?: RTCOfferOptions | undefined): Promise<void>;
+    createOffer(successCallback?: unknown, failureCallback?: unknown, options?: unknown): Promise<void> | Promise<RTCSessionDescriptionInit> {
+        throw new Error("Method not implemented.");
+    }
+    getConfiguration(): RTCConfiguration {
+        throw new Error("Method not implemented.");
+    }
+    getReceivers(): RTCRtpReceiver[] {
+        throw new Error("Method not implemented.");
+    }
+    getSenders(): RTCRtpSender[] {
+        throw new Error("Method not implemented.");
+    }
+    getStats(selector?: MediaStreamTrack | null | undefined): Promise<RTCStatsReport> {
+        const stats = {
+            forEach: function (callbackfn: (value: any) => void): void {
+                callbackfn({
+                    type: 'candidate-pair',
+                    bytesReceived: 123,
+                });
+                callbackfn({
+                    type: 'local-candidate',
+                    address: 'mock-address',
+                });
+            },
+        };
+        return Promise.resolve(stats as RTCStatsReport);
+    }
+    getTransceivers(): RTCRtpTransceiver[] {
+        return [];
+    }
+    removeTrack(sender: RTCRtpSender): void {
+        throw new Error("Method not implemented.");
+    }
+    restartIce(): void {
+        throw new Error("Method not implemented.");
+    }
+    setConfiguration(configuration?: RTCConfiguration | undefined): void {
+        throw new Error("Method not implemented.");
+    }
+    setLocalDescription(description?: RTCLocalSessionDescriptionInit | undefined): Promise<void>;
+    setLocalDescription(description: RTCLocalSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    setLocalDescription(description?: unknown, successCallback?: unknown, failureCallback?: unknown): Promise<void> {
+        spyFunctions.setLocalDescriptionSpy?.(description as RTCLocalSessionDescriptionInit);
+        return Promise.resolve();
+    }
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    setRemoteDescription(description: unknown, successCallback?: unknown, failureCallback?: unknown): Promise<void> {
+        spyFunctions.setRemoteDescriptionSpy?.(description as RTCSessionDescriptionInit);
+        return Promise.resolve();
+    }
+    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event: Event): boolean {
+        throw new Error("Method not implemented.");
+    }
+    static generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate> {
+        throw new Error("Method not implemented.");
+    }
+
+    close(): void {
+        this.connectionState = "closed";
+        this.iceConnectionState = "closed";
+        this.onconnectionstatechange?.(new Event(this.connectionState));
+        this.oniceconnectionstatechange?.(new Event(this.iceConnectionState));
+        this._dataChannels.forEach((channel) => channel.close());
+        spyFunctions.closeSpy?.();
+    }
+
+    triggerIceConnectionStateChange(state: RTCIceConnectionState) {
+        this.iceConnectionState = state;
+        const event = new Event(state);
+        this.oniceconnectionstatechange?.(event);
+    }
+
+    triggerOnTrack(data: RTCTrackEventInit) {
+        const event = new RTCTrackEvent('track', data);
+        this.ontrack?.(event);
+    }
+
+    triggerOnIceCandidate(data: RTCPeerConnectionIceEventInit) {
+        const event = new RTCPeerConnectionIceEvent('icecandidate', data);
+        this.onicecandidate?.(event);
+    }
+
+    triggerOnDataChannel(data: RTCDataChannelEventInit) {
+        this._dataChannels.push(data.channel);
+        const event = new RTCDataChannelEvent('datachannel', data);
+        this.ondatachannel?.(event);
+    }
+}
+
+export class MockRTCIceCandidateImpl implements RTCIceCandidate {
+    address: string | null;
+    candidate: string;
+    component: RTCIceComponent | null;
+    foundation: string | null;
+    port: number | null;
+    priority: number | null;
+    protocol: RTCIceProtocol | null;
+    relatedAddress: string | null;
+    relatedPort: number | null;
+    sdpMLineIndex: number | null;
+    sdpMid: string | null;
+    tcpType: RTCIceTcpCandidateType | null;
+    type: RTCIceCandidateType | null;
+    usernameFragment: string | null;
+
+    constructor(options?: RTCIceCandidateInit) {
+        this.candidate = options?.candidate || "";
+        this.sdpMid = options?.sdpMid || null;
+        this.sdpMLineIndex = options?.sdpMLineIndex || null;
+        this.usernameFragment = options?.usernameFragment || null;
+    }
+
+    toJSON(): RTCIceCandidateInit {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export class MockRTCDataChannelImpl implements RTCDataChannel {
+    binaryType: BinaryType;
+    bufferedAmount: number;
+    bufferedAmountLowThreshold: number;
+    id: number | null;
+    label: string;
+    maxPacketLifeTime: number | null;
+    maxRetransmits: number | null;
+    negotiated: boolean;
+    ordered: boolean;
+    protocol: string;
+    readyState: RTCDataChannelState;
+
+    constructor() {
+        this.readyState = "open";
+    }
+
+    onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclosing: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onmessage: ((this: RTCDataChannel, ev: MessageEvent<any>) => any) | null;
+    onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
+    close(): void {
+        this.onclose?.(new Event('close'));
+    }
+    send(data: string): void;
+    send(data: Blob): void;
+    send(data: ArrayBuffer): void;
+    send(data: ArrayBufferView): void;
+    send(data: unknown): void {
+        spyFunctions.sendDataSpy?.(data as ArrayBuffer);
+    }
+    addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event: Event): boolean {
+        if (event.type === 'message') {
+            this.onmessage?.(event as MessageEvent);
+        }
+        return true;
+    }
+}
+
+export class MockRTCDataChannelEventImpl extends Event implements RTCDataChannelEvent {
+    channel: RTCDataChannel;
+    constructor(name: string, data: RTCDataChannelEventInit) {
+        super(name, data);
+        this.channel = data.channel;
+    }
+}
+
+export class MockRTCTrackEventImpl extends Event implements RTCTrackEvent {
+    receiver: RTCRtpReceiver;
+    streams: readonly MediaStream[];
+    track: MediaStreamTrack;
+    transceiver: RTCRtpTransceiver;
+    constructor(name: string, data: RTCTrackEventInit) {
+        super(name, data);
+        this.receiver = data.receiver;
+        this.streams = data.streams || [];
+        this.track = data.track;
+        this.transceiver = data.transceiver;
+    }
+}
+
+const originalRTCPeerConnection = global.RTCPeerConnection;
+const originalRTCIceCandidate = global.RTCIceCandidate;
+const originalRTCDataChannel = global.RTCDataChannel;
+const originalRTCDataChannelEvent = global.RTCDataChannelEvent;
+const originalRTCTrackEvent = global.RTCTrackEvent;
+export const mockRTCPeerConnection = (): [
+    MockRTCPeerConnectionSpyFunctions,
+    MockRTCPeerConnectionTriggerFunctions
+] => {
+    spyFunctions.constructorSpy = jest.fn();
+    spyFunctions.closeSpy = jest.fn();
+    spyFunctions.setRemoteDescriptionSpy = jest.fn();
+    spyFunctions.setLocalDescriptionSpy = jest.fn();
+    spyFunctions.createAnswerSpy = jest.fn();
+    spyFunctions.addTransceiverSpy = jest.fn();
+    spyFunctions.addIceCandidateSpy = jest.fn();
+    spyFunctions.sendDataSpy = jest.fn();
+    global.RTCPeerConnection = MockRTCPeerConnectionImpl;
+    global.RTCIceCandidate = MockRTCIceCandidateImpl;
+    global.RTCDataChannel = MockRTCDataChannelImpl;
+    global.RTCDataChannelEvent = MockRTCDataChannelEventImpl;
+    global.RTCTrackEvent = MockRTCTrackEventImpl;
+    return [spyFunctions, triggerFunctions];
+};
+
+export const unmockRTCPeerConnection = () => {
+    global.RTCPeerConnection = originalRTCPeerConnection;
+    global.RTCIceCandidate = originalRTCIceCandidate;
+    global.RTCDataChannel = originalRTCDataChannel;
+    global.RTCDataChannelEvent = originalRTCDataChannelEvent;
+    global.RTCTrackEvent = originalRTCTrackEvent;
+    spyFunctions.constructorSpy = null;
+    spyFunctions.closeSpy = null;
+    spyFunctions.setRemoteDescriptionSpy = null;
+    spyFunctions.setLocalDescriptionSpy = null;
+    spyFunctions.createAnswerSpy = null;
+    spyFunctions.addTransceiverSpy = null;
+    spyFunctions.addIceCandidateSpy = null;
+    spyFunctions.sendDataSpy = null;
+};

package/src/__test__/mockRTCRtpReceiver.ts

@@ -0,0 +1,22 @@
+export const mockRTCRtpReceiverImpl = {
+    prototype: jest.fn(),
+    getCapabilities: () => ({
+        codecs: [
+            {
+                clockRate: 60,
+                mimeType: "testMimeType",
+                sdpFmtpLine: "AV1"
+            }
+        ] as RTCRtpCodecCapability[],
+        headerExtensions: [] as RTCRtpHeaderExtensionCapability[]
+    })
+} as any as typeof global.RTCRtpReceiver;
+
+const originalRTCRtpReceiver = global.RTCRtpReceiver;
+export const mockRTCRtpReceiver = () => {
+    global.RTCRtpReceiver = mockRTCRtpReceiverImpl;
+}
+
+export const unmockRTCRtpReceiver = () => {
+    global.RTCRtpReceiver = originalRTCRtpReceiver;
+}

package/src/__test__/mockWebSocket.ts

@@ -0,0 +1,130 @@
+export interface MockWebSocketSpyFunctions {
+    constructorSpy: null | ((url: string) => void);
+    openSpy: null | ((event: Event) => void);
+    errorSpy: null | ((event: Event) => void);
+    closeSpy: null | ((event: CloseEvent) => void);
+    messageSpy: null | ((event: MessageEvent) => void);
+    messageBinarySpy: null | ((event: MessageEvent) => void);
+    sendSpy: null | ((data: string | Blob | ArrayBufferView | ArrayBufferLike) => void);
+}
+
+export interface MockWebSocketTriggerFunctions {
+    triggerOnOpen: null | (() => void);
+    triggerOnError: null | (() => void);
+    triggerOnClose: null | ((closeReason?: CloseEventInit) => void);
+    triggerOnMessage: null | ((message?: object) => void);
+    triggerOnMessageBinary: null | ((message?: Blob) => void);
+}
+
+const spyFunctions: MockWebSocketSpyFunctions = {
+    constructorSpy: null,
+    openSpy: null,
+    errorSpy: null,
+    closeSpy: null,
+    messageSpy: null,
+    messageBinarySpy: null,
+    sendSpy: null
+};
+
+const triggerFunctions: MockWebSocketTriggerFunctions = {
+    triggerOnOpen: null,
+    triggerOnError: null,
+    triggerOnClose: null,
+    triggerOnMessage: null,
+    triggerOnMessageBinary: null
+};
+
+export class MockWebSocketImpl extends WebSocket {
+    _readyState: number;
+
+    constructor(url: string | URL, protocols?: string | string[]) {
+        super(url, protocols);
+        this._readyState = this.OPEN;
+        spyFunctions.constructorSpy?.(this.url);
+        triggerFunctions.triggerOnOpen = this.triggerOnOpen.bind(this);
+        triggerFunctions.triggerOnError = this.triggerOnError.bind(this);
+        triggerFunctions.triggerOnClose = this.triggerOnClose.bind(this);
+        triggerFunctions.triggerOnMessage = this.triggerOnMessage.bind(this);
+        triggerFunctions.triggerOnMessageBinary =
+            this.triggerOnMessageBinary.bind(this);
+    }
+
+    get readyState() {
+        return this._readyState;
+    }
+
+    close(code?: number | undefined, reason?: string | undefined): void {
+        super.close(code, reason);
+        this._readyState = this.CLOSED;
+        this.triggerOnClose({ code, reason });
+    }
+
+    send(data: string | Blob | ArrayBufferView | ArrayBufferLike): void {
+        spyFunctions.sendSpy?.(data);
+    }
+
+    triggerOnOpen() {
+        const event = new Event('open');
+        this.onopen?.(event);
+        spyFunctions.openSpy?.(event);
+    }
+
+    triggerOnError() {
+        const event = new Event('error');
+        this.onerror?.(event);
+        spyFunctions.errorSpy?.(event);
+    }
+
+    triggerOnClose(closeReason?: CloseEventInit) {
+        const reason = closeReason ?? { code: 1, reason: 'mock reason' };
+        const event = new CloseEvent('close', reason);
+        this.onclose?.(event);
+        spyFunctions.closeSpy?.(event);
+    }
+
+    triggerOnMessage(message?: object) {
+        const data = message
+            ? JSON.stringify(message)
+            : JSON.stringify({ type: 'test' });
+        const event = new MessageEvent('message', { data });
+        this.onmessage?.(event);
+        spyFunctions.messageSpy?.(event);
+    }
+
+    triggerOnMessageBinary(message?: Blob) {
+        const data =
+            message ??
+            new Blob([JSON.stringify({ type: 'test' })], {
+                type: 'application/json'
+            });
+        const event = new MessageEvent('messagebinary', { data });
+        this.onmessagebinary?.(event);
+        spyFunctions.messageBinarySpy?.(event);
+    }
+}
+
+const originalWebSocket = WebSocket;
+export const mockWebSocket = (): [
+    MockWebSocketSpyFunctions,
+    MockWebSocketTriggerFunctions
+] => {
+    spyFunctions.constructorSpy = jest.fn();
+    spyFunctions.openSpy = jest.fn();
+    spyFunctions.errorSpy = jest.fn();
+    spyFunctions.closeSpy = jest.fn();
+    spyFunctions.messageSpy = jest.fn();
+    spyFunctions.messageBinarySpy = jest.fn();
+    spyFunctions.sendSpy = jest.fn();
+    global.WebSocket = MockWebSocketImpl;
+    return [spyFunctions, triggerFunctions];
+};
+
+export const unmockWebSocket = () => {
+    global.WebSocket = originalWebSocket;
+    spyFunctions.constructorSpy = null;
+    spyFunctions.openSpy = null;
+    spyFunctions.errorSpy = null;
+    spyFunctions.closeSpy = null;
+    spyFunctions.messageSpy = null;
+    spyFunctions.messageBinarySpy = null;
+};

package/src/pixelstreamingfrontend.ts

@@ -0,0 +1,50 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+export { WebRtcPlayerController } from './WebRtcPlayer/WebRtcPlayerController';
+export { WebXRController } from './WebXR/WebXRController';
+export {
+    Config,
+    ControlSchemeType,
+    Flags,
+    NumericParameters,
+    TextParameters,
+    OptionParameters,
+    // FlagsIds,
+    // NumericParametersIds,
+    // TextParametersIds,
+    // OptionParametersIds,
+    // AllSettings
+} from './Config/Config';
+export { SettingBase } from './Config/SettingBase';
+export { SettingFlag } from './Config/SettingFlag';
+export { SettingNumber } from './Config/SettingNumber';
+export { SettingOption } from './Config/SettingOption';
+export { SettingText } from './Config/SettingText';
+export { PixelStreaming } from './PixelStreaming/PixelStreaming';
+
+export { AFKController as AfkLogic } from './AFK/AFKController';
+
+export { LatencyTestResults } from './DataChannel/LatencyTestResults';
+export {
+    EncoderSettings,
+    InitialSettings,
+    WebRTCSettings
+} from './DataChannel/InitialSettings';
+export { AggregatedStats } from './PeerConnectionController/AggregatedStats';
+export { Logger } from './Logger/Logger';
+export { UnquantizedDenormalizedUnsignedCoord as UnquantizedAndDenormalizeUnsigned } from './Util/CoordinateConverter';
+export { MessageDirection } from './UeInstanceMessage/StreamMessageController';
+export { MessageSend } from './WebSockets/MessageSend';
+export { MessageRecv, MessageStreamerList } from './WebSockets/MessageReceive';
+export { WebSocketController } from './WebSockets/WebSocketController';
+export { SignallingProtocol } from './WebSockets/SignallingProtocol';
+
+export { CandidatePairStats } from './PeerConnectionController/CandidatePairStats';
+export { CandidateStat } from './PeerConnectionController/CandidateStat';
+export { DataChannelStats } from './PeerConnectionController/DataChannelStats';
+export {
+    InboundAudioStats,
+    InboundVideoStats
+} from './PeerConnectionController/InboundRTPStats';
+export { OutBoundVideoStats } from './PeerConnectionController/OutBoundRTPStats';
+export * from './Util/EventEmitter';