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

package/dist/types/PixelStreaming/PixelStreaming.d.ts

@@ -8,6 +8,7 @@ import { WebXRController } from '../WebXR/WebXRController';
 import { MessageDirection } from '../UeInstanceMessage/StreamMessageController';
 import { DataChannelLatencyTestConfig, DataChannelLatencyTestController } from '../DataChannel/DataChannelLatencyTestController';
 import { DataChannelLatencyTestResponse } from '../DataChannel/DataChannelLatencyTestResults';
+import { LatencyInfo } from '../PeerConnectionController/LatencyCalculator';
 export interface PixelStreamingOverrides {
     /** The DOM element where Pixel Streaming video and user input event handlers are attached to.
      * You can give an existing DOM element here. If not given, the library will create a new div element
@@ -109,15 +110,27 @@ export declare class PixelStreaming {
     muteCamera(): void;
     private setCameraMuted;
     /**
-     * Emit an event on auto connecting
+     * Internal function to emit an event when auto connecting occurs
      */
     _onWebRtcAutoConnect(): void;
     /**
-     * Set up functionality to happen when receiving a webRTC answer
+     * Internal function to emit an event for when SDP negotiation is fully finished.
      */
     _onWebRtcSdp(): void;
     /**
-     * Emits a StreamLoading event
+     * Internal function to emit an SDP offer after it has been set.
+     */
+    _onWebRtcSdpOffer(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Internal function to emit an SDP answer after it has been set.
+     */
+    _onWebRtcSdpAnswer(answer: RTCSessionDescriptionInit): void;
+    /**
+     * Internal function call to emit a `latencyCalculated` event.
+     */
+    _onLatencyCalculated(latencyInfo: LatencyInfo): void;
+    /**
+     * Internal function to emits a StreamLoading event
      */
     _onStreamLoading(): void;
     /**
@@ -170,6 +183,7 @@ export declare class PixelStreaming {
      */
     _onQualityControlOwnership(hasQualityOwnership: boolean): void;
     _onPlayerCount(playerCount: number): void;
+    _onSubscribeFailed(message: string): void;
     _setupWebRtcTCPRelayDetection(statsReceivedEvent: StatsReceivedEvent): void;
     /**
      * Request a connection latency test.

package/dist/types/Util/EventEmitter.d.ts

@@ -2,6 +2,7 @@ import { FlagsIds, NumericParametersIds, OptionParametersIds, TextParametersIds
 import { LatencyTestResults } from '../DataChannel/LatencyTestResults';
 import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
 import { InitialSettings } from '../DataChannel/InitialSettings';
+import { LatencyInfo } from '../PeerConnectionController/LatencyCalculator';
 import { Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { SettingFlag } from '../Config/SettingFlag';
 import { SettingNumber } from '../Config/SettingNumber';
@@ -65,6 +66,28 @@ export declare class WebRtcSdpEvent extends Event {
     readonly type: 'webRtcSdp';
     constructor();
 }
+/**
+ * An event that is emitted after the SDP answer is set.
+ */
+export declare class WebRtcSdpAnswerEvent extends Event {
+    readonly type: 'webRtcSdpAnswer';
+    readonly data: {
+        /** The sdp answer */
+        sdp: RTCSessionDescriptionInit;
+    };
+    constructor(data: WebRtcSdpAnswerEvent['data']);
+}
+/**
+ * An event that is emitted after the SDP offer is set.
+ */
+export declare class WebRtcSdpOfferEvent extends Event {
+    readonly type: 'webRtcSdpOffer';
+    readonly data: {
+        /** The sdp offer */
+        sdp: RTCSessionDescriptionInit;
+    };
+    constructor(data: WebRtcSdpOfferEvent['data']);
+}
 /**
  * An event that is emitted when auto connecting.
  */
@@ -280,6 +303,16 @@ export declare class LatencyTestResultEvent extends Event {
     };
     constructor(data: LatencyTestResultEvent['data']);
 }
+/**
+ * An event that is emitted everytime latency is calculated using the WebRTC stats API.
+ */
+export declare class LatencyCalculatedEvent extends Event {
+    readonly type: 'latencyCalculated';
+    readonly data: {
+        latencyInfo: LatencyInfo;
+    };
+    constructor(data: LatencyCalculatedEvent['data']);
+}
 /**
  * An event that is emitted when receiving data channel latency test response from server.
  * This event is handled by DataChannelLatencyTestController
@@ -303,6 +336,13 @@ export declare class DataChannelLatencyTestResultEvent extends Event {
     };
     constructor(data: DataChannelLatencyTestResultEvent['data']);
 }
+export declare class SubscribeFailedEvent extends Event {
+    readonly type: 'subscribeFailed';
+    readonly data: {
+        message: string;
+    };
+    constructor(data: SubscribeFailedEvent['data']);
+}
 /**
  * An event that is emitted when receiving initial settings from UE.
  */
@@ -401,7 +441,7 @@ export declare class WebRtcTCPRelayDetectedEvent extends Event {
     readonly type: 'webRtcTCPRelayDetected';
     constructor();
 }
-export type PixelStreamingEvent = AfkWarningActivateEvent | AfkWarningUpdateEvent | AfkWarningDeactivateEvent | AfkTimedOutEvent | VideoEncoderAvgQPEvent | WebRtcSdpEvent | WebRtcAutoConnectEvent | WebRtcConnectingEvent | WebRtcConnectedEvent | WebRtcFailedEvent | WebRtcDisconnectedEvent | DataChannelOpenEvent | DataChannelCloseEvent | DataChannelErrorEvent | VideoInitializedEvent | StreamLoadingEvent | StreamPreConnectEvent | StreamReconnectEvent | StreamPreDisconnectEvent | PlayStreamErrorEvent | PlayStreamEvent | PlayStreamRejectedEvent | LoadFreezeFrameEvent | HideFreezeFrameEvent | StatsReceivedEvent | StreamerListMessageEvent | StreamerIDChangedMessageEvent | LatencyTestResultEvent | DataChannelLatencyTestResponseEvent | DataChannelLatencyTestResultEvent | InitialSettingsEvent | SettingsChangedEvent | XrSessionStartedEvent | XrSessionEndedEvent | XrFrameEvent | PlayerCountEvent | WebRtcTCPRelayDetectedEvent;
+export type PixelStreamingEvent = AfkWarningActivateEvent | AfkWarningUpdateEvent | AfkWarningDeactivateEvent | AfkTimedOutEvent | VideoEncoderAvgQPEvent | WebRtcSdpEvent | WebRtcSdpOfferEvent | WebRtcSdpAnswerEvent | WebRtcAutoConnectEvent | WebRtcConnectingEvent | WebRtcConnectedEvent | WebRtcFailedEvent | WebRtcDisconnectedEvent | DataChannelOpenEvent | DataChannelCloseEvent | DataChannelErrorEvent | VideoInitializedEvent | StreamLoadingEvent | StreamPreConnectEvent | StreamReconnectEvent | StreamPreDisconnectEvent | PlayStreamErrorEvent | PlayStreamEvent | PlayStreamRejectedEvent | LoadFreezeFrameEvent | HideFreezeFrameEvent | StatsReceivedEvent | StreamerListMessageEvent | StreamerIDChangedMessageEvent | LatencyCalculatedEvent | LatencyTestResultEvent | DataChannelLatencyTestResponseEvent | DataChannelLatencyTestResultEvent | SubscribeFailedEvent | InitialSettingsEvent | SettingsChangedEvent | XrSessionStartedEvent | XrSessionEndedEvent | XrFrameEvent | PlayerCountEvent | WebRtcTCPRelayDetectedEvent;
 export declare class PixelStreamingEventEmitter extends EventTarget {
     /**
      * Dispatch a new event.

package/dist/types/VideoPlayer/VideoPlayer.d.ts

@@ -4,7 +4,7 @@ import { Config } from '../Config/Config';
  */
 declare global {
     interface HTMLElement {
-        mozRequestPointerLock(options: PointerLockOptions): Promise<void>;
+        mozRequestPointerLock(): Promise<void>;
     }
 }
 /**

package/dist/types/WebRtcPlayer/WebRtcPlayerController.d.ts

@@ -1,4 +1,4 @@
-import { SignallingProtocol, ITransport, Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+import { SignallingProtocol, ITransport, Messages, KeepaliveMonitor } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { StreamController } from '../VideoPlayer/StreamController';
 import { FreezeFrameController } from '../FreezeFrame/FreezeFrameController';
 import { AFKController } from '../AFK/AFKController';
@@ -66,6 +66,7 @@ export declare class WebRtcPlayerController {
     subscribedStream: string;
     signallingUrlBuilder: () => string;
     autoJoinTimer: ReturnType<typeof setTimeout>;
+    keepalive: KeepaliveMonitor;
     /**
      *
      * @param config - the frontend config object
@@ -180,10 +181,12 @@ export declare class WebRtcPlayerController {
      * @param messageConfig - Config Message received from the signaling server
      */
     handleOnConfigMessage(messageConfig: Messages.config): void;
+    handlePingMessage(pingMessage: Messages.ping): void;
     /**
      * Handles when the signalling server gives us the list of streamer ids.
      */
     handleStreamerListMessage(messageStreamerList: Messages.streamerList): void;
+    handleSubscribeFailedMessage(subscribeFailedMessage: Messages.subscribeFailed): void;
     handleStreamerIDChangedMessage(streamerIDChangedMessage: Messages.streamerIdChanged): void;
     /**
      * Handle the RTC Answer from the signaling server

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

@@ -0,0 +1,49 @@
+export declare 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;
+    clone(): MediaStream;
+    getAudioTracks(): MediaStreamTrack[];
+    getTrackById(trackId: string): MediaStreamTrack | null;
+    getTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    removeTrack(track: MediaStreamTrack): void;
+    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;
+    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;
+    dispatchEvent(event: Event): boolean;
+}
+export declare class MockMediaStreamTrackImpl implements MediaStreamTrack {
+    contentHint: string;
+    enabled: boolean;
+    id: string;
+    kind: string;
+    label: string;
+    muted: boolean;
+    readyState: MediaStreamTrackState;
+    constructor();
+    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>;
+    clone(): MediaStreamTrack;
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    stop(): void;
+    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;
+    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;
+    dispatchEvent(event: Event): boolean;
+}
+export declare const mockMediaStream: () => void;
+export declare const unmockMediaStream: () => void;
+export declare const mockHTMLMediaElement: (options: {
+    ableToPlay: boolean;
+    readyState?: number;
+}) => void;

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,45 +1,47 @@
-{
-    "name": "@epicgames-ps/lib-pixelstreamingfrontend-ue5.5",
-    "version": "0.4.7",
-    "description": "Frontend library for Unreal Engine 5.5 Pixel Streaming",
-    "main": "dist/commonjs/pixelstreamingfrontend.js",
-    "module": "dist/esm/pixelstreamingfrontend.js",
-    "types": "dist/types/pixelstreamingfrontend.d.ts",
-    "sideEffects": false,
-    "scripts": {
-        "compile": "tsc --project tsconfig.esm.json && tsc --project tsconfig.cjs.json",
-        "build": "npm run compile",
-        "build-all": "cd ../../Common && npm install && npm run build && cd ../Frontend/library && npm install && npm run build",
-        "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
-        "test": "jest --detectOpenHandles --coverage=true",
-        "spellcheck": "cspell \"{README.md,.github/*.md,src/**/*.ts}\""
-    },
-    "devDependencies": {
-        "@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",
-        "jest": "^29.7.0",
-        "jest-environment-jsdom": "^29.7.0",
-        "prettier": "3.3.3",
-        "ts-jest": "^29.2.5",
-        "typedoc": "^0.27.4",
-        "typescript": "^5.0.0"
-    },
-    "dependencies": {
-        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.1.6",
-        "@types/webxr": "^0.5.1",
-        "sdp": "^3.1.0"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/EpicGamesExt/PixelStreamingInfrastructure.git"
-    },
-    "author": "Epic Games",
-    "license": "MIT",
-    "publishConfig": {
-        "access": "public"
-    }
-}
+{
+    "name": "@epicgames-ps/lib-pixelstreamingfrontend-ue5.5",
+    "version": "1.0.1",
+    "description": "Frontend library for Unreal Engine 5.5 Pixel Streaming",
+    "main": "dist/cjs/pixelstreamingfrontend.js",
+    "module": "dist/esm/pixelstreamingfrontend.js",
+    "types": "dist/types/pixelstreamingfrontend.d.ts",
+    "sideEffects": false,
+    "scripts": {
+        "clean": "rimraf ./dist",
+        "build:cjs": "tsc --project tsconfig.cjs.json",
+        "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",
+        "test": "jest --detectOpenHandles --coverage=true",
+        "spellcheck": "cspell \"{README.md,.github/*.md,src/**/*.ts}\""
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.20.0",
+        "@types/jest": "^29.5.14",
+        "@types/webxr": "^0.5.21",
+        "cspell": "^8.17.3",
+        "eslint": "^9.20.0",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "^29.7.0",
+        "nodemon": "^3.1.9",
+        "rimraf": "^6.0.1",
+        "ts-jest": "^29.2.5",
+        "typescript": "^5.7.3",
+        "typescript-eslint": "^8.24.0"
+    },
+    "dependencies": {
+        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.2.8",
+        "sdp": "^3.2.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/EpicGamesExt/PixelStreamingInfrastructure.git"
+    },
+    "author": "Epic Games",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    }
+}

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'>;
@@ -59,6 +60,7 @@ export class NumericParameters {
     static WebRTCMaxBitrate = 'WebRTCMaxBitrate' as const;
     static MaxReconnectAttempts = 'MaxReconnectAttempts' as const;
     static StreamerAutoJoinInterval = 'StreamerAutoJoinInterval' as const;
+    static KeepaliveDelay = 'KeepaliveDelay' as const;
 }
 
 export type NumericParametersKeys = Exclude<keyof typeof NumericParameters, 'prototype'>;
@@ -563,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
          */
@@ -761,6 +776,21 @@ export class Config {
                 useUrlParams
             )
         );
+
+        this.numericParameters.set(
+            NumericParameters.KeepaliveDelay,
+            new SettingNumber(
+                NumericParameters.KeepaliveDelay,
+                'Connection Keepalive delay',
+                'Delay between keepalive pings to the signalling server.',
+                0 /*min*/,
+                900000 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.KeepaliveDelay)
+                    ? settings[NumericParameters.KeepaliveDelay]
+                    : 30000 /*value*/,
+                useUrlParams
+            )
+        );
     }
 
     /**

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. */
         }