@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.4.8 → 1.0.1

package/dist/types/__test__/mockRTCPeerConnection.d.ts

@@ -0,0 +1,134 @@
+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);
+}
+export declare 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);
+    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>;
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
+    addTransceiver(trackOrKind: string | MediaStreamTrack, init?: RTCRtpTransceiverInit | undefined): RTCRtpTransceiver;
+    createAnswer(options?: RTCAnswerOptions | undefined): Promise<RTCSessionDescriptionInit>;
+    createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit | undefined): RTCDataChannel;
+    createOffer(options?: RTCOfferOptions | undefined): Promise<RTCSessionDescriptionInit>;
+    createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback, options?: RTCOfferOptions | undefined): Promise<void>;
+    getConfiguration(): RTCConfiguration;
+    getReceivers(): RTCRtpReceiver[];
+    getSenders(): RTCRtpSender[];
+    getStats(selector?: MediaStreamTrack | null | undefined): Promise<RTCStatsReport>;
+    getTransceivers(): RTCRtpTransceiver[];
+    removeTrack(sender: RTCRtpSender): void;
+    restartIce(): void;
+    setConfiguration(configuration?: RTCConfiguration | undefined): void;
+    setLocalDescription(description?: RTCLocalSessionDescriptionInit | undefined): Promise<void>;
+    setLocalDescription(description: RTCLocalSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    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;
+    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;
+    dispatchEvent(event: Event): boolean;
+    static generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
+    close(): void;
+    triggerIceConnectionStateChange(state: RTCIceConnectionState): void;
+    triggerOnTrack(data: RTCTrackEventInit): void;
+    triggerOnIceCandidate(data: RTCPeerConnectionIceEventInit): void;
+    triggerOnDataChannel(data: RTCDataChannelEventInit): void;
+}
+export declare 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);
+    toJSON(): RTCIceCandidateInit;
+}
+export declare 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();
+    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;
+    send(data: string): void;
+    send(data: Blob): void;
+    send(data: ArrayBuffer): void;
+    send(data: ArrayBufferView): void;
+    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;
+    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;
+    dispatchEvent(event: Event): boolean;
+}
+export declare class MockRTCDataChannelEventImpl extends Event implements RTCDataChannelEvent {
+    channel: RTCDataChannel;
+    constructor(name: string, data: RTCDataChannelEventInit);
+}
+export declare class MockRTCTrackEventImpl extends Event implements RTCTrackEvent {
+    receiver: RTCRtpReceiver;
+    streams: readonly MediaStream[];
+    track: MediaStreamTrack;
+    transceiver: RTCRtpTransceiver;
+    constructor(name: string, data: RTCTrackEventInit);
+}
+export declare const mockRTCPeerConnection: () => [MockRTCPeerConnectionSpyFunctions, MockRTCPeerConnectionTriggerFunctions];
+export declare const unmockRTCPeerConnection: () => void;

package/dist/types/__test__/mockRTCRtpReceiver.d.ts

@@ -0,0 +1,3 @@
+export declare const mockRTCRtpReceiverImpl: typeof global.RTCRtpReceiver;
+export declare const mockRTCRtpReceiver: () => void;
+export declare const unmockRTCRtpReceiver: () => void;

package/dist/types/__test__/mockWebSocket.d.ts

@@ -0,0 +1,33 @@
+import { BaseMessage } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+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?: BaseMessage) => void);
+    triggerOnMessageBinary: null | ((message?: Blob) => void);
+    triggerRemoteClose: null | ((code?: number, reason?: string) => void);
+}
+export declare class MockWebSocketImpl extends WebSocket {
+    _readyState: number;
+    constructor(url: string | URL, protocols?: string | string[]);
+    get readyState(): number;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    send(data: string | Blob | ArrayBufferView | ArrayBufferLike): void;
+    triggerOnOpen(): void;
+    triggerOnError(): void;
+    triggerOnClose(closeReason?: CloseEventInit): void;
+    triggerRemoteClose(code?: number, reason?: string): void;
+    triggerOnMessage(message: BaseMessage): void;
+    triggerOnMessageBinary(message?: Blob): void;
+}
+export declare const mockWebSocket: () => [MockWebSocketSpyFunctions, MockWebSocketTriggerFunctions];
+export declare const unmockWebSocket: () => void;

package/dist/types/pixelstreamingfrontend.d.ts

@@ -17,7 +17,8 @@ export { CandidatePairStats } from './PeerConnectionController/CandidatePairStat
 export { CandidateStat } from './PeerConnectionController/CandidateStat';
 export { DataChannelStats } from './PeerConnectionController/DataChannelStats';
 export { InboundAudioStats, InboundVideoStats } from './PeerConnectionController/InboundRTPStats';
-export { OutBoundVideoStats } from './PeerConnectionController/OutBoundRTPStats';
+export { OutboundRTPStats, RemoteOutboundRTPStats } from './PeerConnectionController/OutBoundRTPStats';
+export * from './PeerConnectionController/LatencyCalculator';
 export * from './DataChannel/DataChannelLatencyTestResults';
 export * from './Util/EventEmitter';
 export * from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';

package/eslint.config.mjs

@@ -0,0 +1,52 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+    {
+        ignores: ["src/__test__/**/*.ts", "**/*.test.ts"],
+    },
+    eslint.configs.recommended,
+    tseslint.configs.recommendedTypeCheckedOnly,
+    {
+        languageOptions: {
+            parser: tseslint.parser,
+            parserOptions: {
+                project: 'tsconfig.base.json',
+            },
+        },
+        files: ["src/**/*.ts"],
+        rules: {
+            // TODO: when updating eslint a lot of issues suddently popped up
+            // these ignores should be turned off slowly and new issues should
+            // be addressed
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unsafe-member-access": "off",
+            "@typescript-eslint/no-unsafe-call": "off",
+            "@typescript-eslint/no-unsafe-assignment": "off",
+            "@typescript-eslint/no-unsafe-argument": "off",
+            "@typescript-eslint/no-unsafe-return": "off",
+            "@typescript-eslint/no-floating-promises": "off",
+            "@typescript-eslint/restrict-plus-operands": "off",
+            "@typescript-eslint/unbound-method": "off",
+            "@typescript-eslint/no-duplicate-type-constituents": "off",
+            "@typescript-eslint/no-redundant-type-constituents": "off",
+            "@typescript-eslint/restrict-template-expressions": "off",
+            "@typescript-eslint/no-unnecessary-type-assertion": "off",
+            "@typescript-eslint/no-array-delete": "off",
+            "@typescript-eslint/no-unsafe-enum-comparison": "off",
+            "@typescript-eslint/require-await": "off",
+            "@typescript-eslint/no-base-to-string": "off",
+            "no-unused-vars": "off",
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                {
+                    "argsIgnorePattern": "^_",
+                    "varsIgnorePattern": "^_",
+                    "caughtErrorsIgnorePattern": "^_"
+                }
+            ]
+        }
+    }
+);
+

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@epicgames-ps/lib-pixelstreamingfrontend-ue5.5",
-    "version": "0.4.8",
+    "version": "1.0.1",
     "description": "Frontend library for Unreal Engine 5.5 Pixel Streaming",
     "main": "dist/cjs/pixelstreamingfrontend.js",
     "module": "dist/esm/pixelstreamingfrontend.js",
@@ -12,29 +12,28 @@
         "build:esm": "tsc --project tsconfig.esm.json",
         "build": "npm run build:cjs && npm run build:esm",
         "rebuild": "npm run clean && npm run build",
-        "watch": "nodemon -V -d 3 --watch src --watch ../../Common/dist -e 'ts,js,mjs,cjs,json' --exec 'npm run build:cjs'",
-        "lint": "eslint src --ext .js,.jsx,.ts,.tsx",
+        "watch": "nodemon -V -d 3 --watch src --watch ../../Common/dist -e \"ts,js,mjs,cjs,json\" --exec \"npm run build:cjs\"",
+        "lint": "eslint src",
         "test": "jest --detectOpenHandles --coverage=true",
         "spellcheck": "cspell \"{README.md,.github/*.md,src/**/*.ts}\""
     },
     "devDependencies": {
+        "@eslint/js": "^9.20.0",
         "@types/jest": "^29.5.14",
-        "@typescript-eslint/eslint-plugin": "^6.21.0",
-        "cspell": "^4.1.0",
-        "eslint": "^8.11.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.2.1",
+        "@types/webxr": "^0.5.21",
+        "cspell": "^8.17.3",
+        "eslint": "^9.20.0",
         "jest": "^29.7.0",
         "jest-environment-jsdom": "^29.7.0",
-        "prettier": "3.3.3",
+        "nodemon": "^3.1.9",
+        "rimraf": "^6.0.1",
         "ts-jest": "^29.2.5",
-        "typedoc": "^0.27.4",
-        "typescript": "^5.0.0"
+        "typescript": "^5.7.3",
+        "typescript-eslint": "^8.24.0"
     },
     "dependencies": {
-        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.1.7",
-        "@types/webxr": "^0.5.1",
-        "sdp": "^3.1.0"
+        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.2.8",
+        "sdp": "^3.2.0"
     },
     "repository": {
         "type": "git",

package/src/Config/Config.ts

@@ -33,6 +33,7 @@ export class Flags {
     static XRControllerInput = 'XRControllerInput' as const;
     static WaitForStreamer = 'WaitForStreamer' as const;
     static HideUI = 'HideUI' as const;
+    static EnableCaptureTimeExt = 'EnableCaptureTimeExt' as const;
 }
 
 export type FlagsKeys = Exclude<keyof typeof Flags, 'prototype'>;
@@ -564,6 +565,19 @@ export class Config {
             )
         );
 
+        this.flags.set(
+            Flags.EnableCaptureTimeExt,
+            new SettingFlag(
+                Flags.EnableCaptureTimeExt,
+                'Enable abs-capture-time',
+                'Enables the abs-capture-time RTP header extension',
+                settings && Object.prototype.hasOwnProperty.call(settings, Flags.EnableCaptureTimeExt)
+                    ? settings[Flags.EnableCaptureTimeExt]
+                    : true,
+                useUrlParams
+            )
+        );
+
         /**
          * Numeric parameters
          */

package/src/Config/SettingBase.ts

@@ -18,7 +18,7 @@ export class SettingBase {
         label: string,
         description: string,
         defaultSettingValue: unknown,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultOnChangeListener: (changedValue: unknown, setting: SettingBase) => void = () => {
             /* Do nothing, to be overridden. */
         }

package/src/Config/SettingFlag.ts

@@ -16,7 +16,7 @@ export class SettingFlag<CustomIds extends string = FlagsIds> extends SettingBas
         description: string,
         defaultFlagValue: boolean,
         useUrlParams: boolean,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultOnChangeListener: (changedValue: unknown, setting: SettingBase) => void = () => {
             /* Do nothing, to be overridden. */
         }

package/src/Config/SettingNumber.ts

@@ -21,7 +21,7 @@ export class SettingNumber<CustomIds extends string = NumericParametersIds> exte
         max: number | null,
         defaultNumber: number,
         useUrlParams: boolean,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultOnChangeListener: (changedValue: unknown, setting: SettingBase) => void = () => {
             /* Do nothing, to be overridden. */
         }

package/src/Config/SettingOption.ts

@@ -22,12 +22,12 @@ export class SettingOption<CustomIds extends string = OptionParametersIds> exten
         defaultTextValue: string,
         options: Array<string>,
         useUrlParams: boolean,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultUrlParamResolver: (urlParamValue: string) => string = function (value: string) {
             /* Return the string as-is by default */
             return value;
         },
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultOnChangeListener: (changedValue: unknown, setting: SettingBase) => void = () => {
             /* Do nothing, to be overridden. */
         }

package/src/Config/SettingText.ts

@@ -17,7 +17,7 @@ export class SettingText<CustomIds extends string = TextParametersIds> extends S
         description: string,
         defaultTextValue: string,
         useUrlParams: boolean,
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
+         
         defaultOnChangeListener: (changedValue: unknown, setting: SettingBase) => void = () => {
             /* Do nothing, to be overridden. */
         }

package/src/Inputs/GamepadController.ts

@@ -21,7 +21,7 @@ declare global {
 /**
  * Gamepad layout codes enum
  */
-/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
+ 
 export enum GamepadLayout {
     RightClusterBottomButton = 0,
     RightClusterRightButton = 1,
@@ -46,7 +46,7 @@ export enum GamepadLayout {
     RightStickHorizontal = 2,
     RightStickVertical = 3
 }
-/* eslint-enable @typescript-eslint/no-duplicate-enum-values */
+ 
 
 /**
  * Handles gamepad events from the document to send to the streamer.

package/src/PeerConnectionController/AggregatedStats.ts

@@ -5,7 +5,7 @@ import { InboundTrackStats } from './InboundTrackStats';
 import { DataChannelStats } from './DataChannelStats';
 import { CandidateStat } from './CandidateStat';
 import { CandidatePairStats } from './CandidatePairStats';
-import { OutBoundRTPStats, OutBoundVideoStats } from './OutBoundRTPStats';
+import { RemoteOutboundRTPStats, OutboundRTPStats } from './OutBoundRTPStats';
 import { SessionStats } from './SessionStats';
 import { StreamStats } from './StreamStats';
 import { CodecStats } from './CodecStats';
@@ -15,15 +15,17 @@ import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
  * The Aggregated Stats that is generated from the RTC Stats Report
  */
 
-type RTCStatsTypePS = RTCStatsType | 'stream' | 'media-playout' | 'track';
 export class AggregatedStats {
     inboundVideoStats: InboundVideoStats;
     inboundAudioStats: InboundAudioStats;
     candidatePairs: Array<CandidatePairStats>;
-    DataChannelStats: DataChannelStats;
+    datachannelStats: DataChannelStats;
     localCandidates: Array<CandidateStat>;
     remoteCandidates: Array<CandidateStat>;
-    outBoundVideoStats: OutBoundVideoStats;
+    outboundVideoStats: OutboundRTPStats;
+    outboundAudioStats: OutboundRTPStats;
+    remoteOutboundVideoStats: RemoteOutboundRTPStats;
+    remoteOutboundAudioStats: RemoteOutboundRTPStats;
     sessionStats: SessionStats;
     streamStats: StreamStats;
     codecs: Map<string, CodecStats>;
@@ -32,8 +34,11 @@ export class AggregatedStats {
     constructor() {
         this.inboundVideoStats = new InboundVideoStats();
         this.inboundAudioStats = new InboundAudioStats();
-        this.DataChannelStats = new DataChannelStats();
-        this.outBoundVideoStats = new OutBoundVideoStats();
+        this.datachannelStats = new DataChannelStats();
+        this.outboundVideoStats = new OutboundRTPStats();
+        this.outboundAudioStats = new OutboundRTPStats();
+        this.remoteOutboundAudioStats = new RemoteOutboundRTPStats();
+        this.remoteOutboundVideoStats = new RemoteOutboundRTPStats();
         this.sessionStats = new SessionStats();
         this.streamStats = new StreamStats();
         this.codecs = new Map<string, CodecStats>();
@@ -49,7 +54,7 @@ export class AggregatedStats {
         this.candidatePairs = new Array<CandidatePairStats>();
 
         rtcStatsReport.forEach((stat) => {
-            const type: RTCStatsTypePS = stat.type;
+            const type: string = stat.type;
 
             switch (type) {
                 case 'candidate-pair':
@@ -64,7 +69,7 @@ export class AggregatedStats {
                     this.handleDataChannel(stat);
                     break;
                 case 'inbound-rtp':
-                    this.handleInBoundRTP(stat);
+                    this.handleInboundRTP(stat);
                     break;
                 case 'local-candidate':
                     this.handleLocalCandidate(stat);
@@ -74,6 +79,7 @@ export class AggregatedStats {
                 case 'media-playout':
                     break;
                 case 'outbound-rtp':
+                    this.handleLocalOutbound(stat);
                     break;
                 case 'peer-connection':
                     break;
@@ -83,7 +89,7 @@ export class AggregatedStats {
                 case 'remote-inbound-rtp':
                     break;
                 case 'remote-outbound-rtp':
-                    this.handleRemoteOutBound(stat);
+                    this.handleRemoteOutbound(stat);
                     break;
                 case 'track':
                     this.handleTrack(stat);
@@ -125,16 +131,16 @@ export class AggregatedStats {
      * @param stat - the stats coming in from the data channel
      */
     handleDataChannel(stat: DataChannelStats) {
-        this.DataChannelStats.bytesReceived = stat.bytesReceived;
-        this.DataChannelStats.bytesSent = stat.bytesSent;
-        this.DataChannelStats.dataChannelIdentifier = stat.dataChannelIdentifier;
-        this.DataChannelStats.id = stat.id;
-        this.DataChannelStats.label = stat.label;
-        this.DataChannelStats.messagesReceived = stat.messagesReceived;
-        this.DataChannelStats.messagesSent = stat.messagesSent;
-        this.DataChannelStats.protocol = stat.protocol;
-        this.DataChannelStats.state = stat.state;
-        this.DataChannelStats.timestamp = stat.timestamp;
+        this.datachannelStats.bytesReceived = stat.bytesReceived;
+        this.datachannelStats.bytesSent = stat.bytesSent;
+        this.datachannelStats.dataChannelIdentifier = stat.dataChannelIdentifier;
+        this.datachannelStats.id = stat.id;
+        this.datachannelStats.label = stat.label;
+        this.datachannelStats.messagesReceived = stat.messagesReceived;
+        this.datachannelStats.messagesSent = stat.messagesSent;
+        this.datachannelStats.protocol = stat.protocol;
+        this.datachannelStats.state = stat.state;
+        this.datachannelStats.timestamp = stat.timestamp;
     }
 
     /**
@@ -159,23 +165,23 @@ export class AggregatedStats {
      * @param stat - ice candidate stats
      */
     handleRemoteCandidate(stat: CandidateStat) {
-        const RemoteCandidate = new CandidateStat();
-        RemoteCandidate.label = 'remote-candidate';
-        RemoteCandidate.address = stat.address;
-        RemoteCandidate.port = stat.port;
-        RemoteCandidate.protocol = stat.protocol;
-        RemoteCandidate.id = stat.id;
-        RemoteCandidate.candidateType = stat.candidateType;
-        RemoteCandidate.relayProtocol = stat.relayProtocol;
-        RemoteCandidate.transportId = stat.transportId;
-        this.remoteCandidates.push(RemoteCandidate);
+        const remoteCandidate = new CandidateStat();
+        remoteCandidate.label = 'remote-candidate';
+        remoteCandidate.address = stat.address;
+        remoteCandidate.port = stat.port;
+        remoteCandidate.protocol = stat.protocol;
+        remoteCandidate.id = stat.id;
+        remoteCandidate.candidateType = stat.candidateType;
+        remoteCandidate.relayProtocol = stat.relayProtocol;
+        remoteCandidate.transportId = stat.transportId;
+        this.remoteCandidates.push(remoteCandidate);
     }
 
     /**
      * Process the Inbound RTP Audio and Video Data
      * @param stat - inbound rtp stats
      */
-    handleInBoundRTP(stat: InboundRTPStats) {
+    handleInboundRTP(stat: InboundRTPStats) {
         switch (stat.kind) {
             case 'video':
                 // Calculate bitrate between stat updates
@@ -216,25 +222,63 @@ export class AggregatedStats {
     }
 
     /**
-     * Process the outbound RTP Audio and Video Data
-     * @param stat - remote outbound stats
+     * Process the "local" outbound RTP Audio and Video stats.
+     * @param stat - local outbound rtp stats
      */
-    handleRemoteOutBound(stat: OutBoundRTPStats) {
-        switch (stat.kind) {
-            case 'video':
-                this.outBoundVideoStats.bytesSent = stat.bytesSent;
-                this.outBoundVideoStats.id = stat.id;
-                this.outBoundVideoStats.localId = stat.localId;
-                this.outBoundVideoStats.packetsSent = stat.packetsSent;
-                this.outBoundVideoStats.remoteTimestamp = stat.remoteTimestamp;
-                this.outBoundVideoStats.timestamp = stat.timestamp;
-                break;
-            case 'audio':
-                break;
+    handleLocalOutbound(stat: OutboundRTPStats) {
+        const localOutboundStats: OutboundRTPStats =
+            stat.kind === 'audio' ? this.outboundAudioStats : this.outboundVideoStats;
+        localOutboundStats.active = stat.active;
+        localOutboundStats.codecId = stat.codecId;
+        localOutboundStats.bytesSent = stat.bytesSent;
+        localOutboundStats.frameHeight = stat.frameHeight;
+        localOutboundStats.frameWidth = stat.frameWidth;
+        localOutboundStats.framesEncoded = stat.framesEncoded;
+        localOutboundStats.framesPerSecond = stat.framesPerSecond;
+        localOutboundStats.headerBytesSent = stat.headerBytesSent;
+        localOutboundStats.id = stat.id;
+        localOutboundStats.keyFramesEncoded = stat.keyFramesEncoded;
+        localOutboundStats.kind = stat.kind;
+        localOutboundStats.mediaSourceId = stat.mediaSourceId;
+        localOutboundStats.mid = stat.mid;
+        localOutboundStats.nackCount = stat.nackCount;
+        localOutboundStats.packetsSent = stat.packetsSent;
+        localOutboundStats.qpSum = stat.qpSum;
+        localOutboundStats.qualityLimitationDurations = stat.qualityLimitationDurations;
+        localOutboundStats.qualityLimitationReason = stat.qualityLimitationReason;
+        localOutboundStats.remoteId = stat.remoteId;
+        localOutboundStats.retransmittedBytesSent = stat.retransmittedBytesSent;
+        localOutboundStats.rid = stat.rid;
+        localOutboundStats.scalabilityMode = stat.scalabilityMode;
+        localOutboundStats.ssrc = stat.ssrc;
+        localOutboundStats.targetBitrate = stat.targetBitrate;
+        localOutboundStats.timestamp = stat.timestamp;
+        localOutboundStats.totalEncodeTime = stat.totalEncodeTime;
+        localOutboundStats.totalEncodeBytesTarget = stat.totalEncodeBytesTarget;
+        localOutboundStats.totalPacketSendDelay = stat.totalPacketSendDelay;
+        localOutboundStats.transportId = stat.transportId;
+    }
 
-            default:
-                break;
-        }
+    /**
+     * Process the "remote" outbound RTP Audio and Video stats.
+     * @param stat - remote outbound rtp stats
+     */
+    handleRemoteOutbound(stat: RemoteOutboundRTPStats) {
+        const remoteOutboundStats: RemoteOutboundRTPStats =
+            stat.kind === 'audio' ? this.remoteOutboundAudioStats : this.remoteOutboundVideoStats;
+        remoteOutboundStats.bytesSent = stat.bytesSent;
+        remoteOutboundStats.codecId = stat.codecId;
+        remoteOutboundStats.id = stat.id;
+        remoteOutboundStats.kind = stat.kind;
+        remoteOutboundStats.localId = stat.localId;
+        remoteOutboundStats.packetsSent = stat.packetsSent;
+        remoteOutboundStats.remoteTimestamp = stat.remoteTimestamp;
+        remoteOutboundStats.reportsSent = stat.reportsSent;
+        remoteOutboundStats.roundTripTimeMeasurements = stat.roundTripTimeMeasurements;
+        remoteOutboundStats.ssrc = stat.ssrc;
+        remoteOutboundStats.timestamp = stat.timestamp;
+        remoteOutboundStats.totalRoundTripTime = stat.totalRoundTripTime;
+        remoteOutboundStats.transportId = stat.transportId;
     }
 
     /**
@@ -288,16 +332,31 @@ export class AggregatedStats {
      * @returns The candidate pair that is currently receiving data
      */
     public getActiveCandidatePair(): CandidatePairStats | null {
+        if (this.candidatePairs === undefined) {
+            return null;
+        }
+
         // Check if the RTCTransport stat is not undefined
         if (this.transportStats) {
             // Return the candidate pair that matches the transport candidate pair id
-            return this.candidatePairs.find(
-                (candidatePair) => candidatePair.id === this.transportStats.selectedCandidatePairId,
-                null
+            const selectedPair: CandidatePairStats | undefined = this.candidatePairs.find(
+                (candidatePair) => candidatePair.id === this.transportStats.selectedCandidatePairId
             );
+            if (selectedPair === undefined) {
+                return null;
+            } else {
+                return selectedPair;
+            }
         }
 
-        // Fall back to the selected candidate pair
-        return this.candidatePairs.find((candidatePair) => candidatePair.selected, null);
+        // Fall back to the `.selected` member of the candidate pair
+        const selectedPair: CandidatePairStats | undefined = this.candidatePairs.find(
+            (candidatePair) => candidatePair.selected
+        );
+        if (selectedPair === undefined) {
+            return null;
+        } else {
+            return selectedPair;
+        }
     }
 }