@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.2.1 → 0.3.1

package/package.json

@@ -1,49 +1,45 @@
-{
-    "name": "@epicgames-ps/lib-pixelstreamingfrontend-ue5.5",
-    "version": "0.2.1",
-    "description": "Frontend library for Unreal Engine 5.5 Pixel Streaming",
-    "main": "dist/lib-pixelstreamingfrontend.js",
-    "module": "dist/lib-pixelstreamingfrontend.esm.js",
-    "types": "types/pixelstreamingfrontend.d.ts",
-    "sideEffects": false,
-    "scripts": {
-        "compile": "tsc --build --clean && tsc",
-        "build": "webpack --config webpack.prod.js",
-        "build-all": "cd ../../Common && npm install && npm run build && cd ../Frontend/library && npm link ../../Common && webpack --config webpack.prod.js",
-        "build-dev": "cd ../../Common && npm install && npm run build && cd ../Frontend/library && npm link ../../Common && webpack --config webpack.dev.js",
-        "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
-        "test": "jest --detectOpenHandles --coverage=true",
-        "spellcheck": "cspell \"{README.md,.github/*.md,src/**/*.ts}\""
-    },
-    "devDependencies": {
-        "@types/jest": "27.5.1",
-        "@types/webxr": "^0.5.1",
-        "@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": "^27.5.1",
-        "jest-environment-jsdom": "27.5.1",
-        "prettier": "3.3.3",
-        "ts-jest": "27.1.5",
-        "ts-loader": "^9.4.2",
-        "typedoc": "^0.23.24",
-        "typescript": "^4.9.4",
-        "webpack": "^5.75.0",
-        "webpack-cli": "^5.0.1"
-    },
-    "dependencies": {
-        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.0.15",
-        "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": "0.3.1",
+    "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": "27.5.1",
+        "@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": "^27.5.1",
+        "jest-environment-jsdom": "27.5.1",
+        "prettier": "3.3.3",
+        "ts-jest": "27.1.5",
+        "typedoc": "^0.23.24",
+        "typescript": "^4.9.4"
+    },
+    "dependencies": {
+        "@types/webxr": "^0.5.1",
+        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.1.0",
+        "sdp": "^3.1.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/EpicGamesExt/PixelStreamingInfrastructure.git"
+    },
+    "author": "Epic Games",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/readme.md

@@ -11,5 +11,13 @@ See [lib-pixelstreamingfrontend-ui](/Frontend/implementations/typescript) for an
 - Opens a data channel connection sending and receiving custom data (in addition to input).
 
 ### Adding it to your project
-`npm i @epicgames-ps/lib-pixelstreamingfrontend-ue5.4`
+`npm i @epicgames-ps/lib-pixelstreamingfrontend-ue5.5`
 
+### How this library is built
+The NPM packages supports:
+- ES6 module usage
+- CommonJS usage
+- Type definitions
+- Source maps
+
+**Note:** The NPM package does not contain a minified/bundled output, this is up to the user to do this in their application.

package/src/Config/Config.ts

@@ -188,11 +188,77 @@ export class Config {
                 settings && Object.prototype.hasOwnProperty.call(settings, OptionParameters.StreamerId)
                     ? settings[OptionParameters.StreamerId]
                     : '',
-                [],
+                settings && Object.prototype.hasOwnProperty.call(settings, OptionParameters.StreamerId)
+                    ? [settings[OptionParameters.StreamerId]]
+                    : undefined,
                 useUrlParams
             )
         );
 
+        const getBrowserSupportedVideoCodecs = function (): Array<string> {
+            const browserSupportedCodecs: Array<string> = [];
+            // Try get the info needed from the RTCRtpReceiver. This is only available on chrome
+            if (!RTCRtpReceiver.getCapabilities) {
+                Logger.Warning(
+                    'RTCRtpReceiver.getCapabilities API is not available in your browser, defaulting to guess that we support H.264.'
+                );
+                browserSupportedCodecs.push(
+                    'H264 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f'
+                );
+                return browserSupportedCodecs;
+            }
+
+            const matcher = /(VP\d|H26\d|AV1).*/;
+            const codecs = RTCRtpReceiver.getCapabilities('video').codecs;
+            codecs.forEach((codec) => {
+                const str = codec.mimeType.split('/')[1] + ' ' + (codec.sdpFmtpLine || '');
+                const match = matcher.exec(str);
+                if (match !== null) {
+                    browserSupportedCodecs.push(str);
+                }
+            });
+            return browserSupportedCodecs;
+        };
+
+        const getDefaultVideoCodec = function (): string {
+            const videoCodecs = getBrowserSupportedVideoCodecs();
+            // If only one option, then select that.
+            if (videoCodecs.length == 1) {
+                return videoCodecs[0];
+            } else if (videoCodecs.length > 0) {
+                const defaultCodec = videoCodecs[0];
+                for (const codec of videoCodecs) {
+                    if (codec.startsWith('H264')) {
+                        return codec;
+                    }
+                }
+                return defaultCodec;
+            }
+
+            Logger.Error('Could not find any reasonable video codec to assign as a default.');
+            return '';
+        };
+
+        const matchSpecifiedCodecToClosestSupported = function (specifiedCodec: string): string {
+            const browserSupportedCodecs: Array<string> = getBrowserSupportedVideoCodecs();
+
+            // Codec supplied in url param is an exact match for the browser codec.
+            // (e.g. H264 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f)
+            if (browserSupportedCodecs.includes(specifiedCodec)) {
+                return specifiedCodec;
+            }
+
+            // Try to match the start of whatever is passed into the url parameter with what the browser supports
+            for (const browserCodec of browserSupportedCodecs) {
+                if (browserCodec.startsWith(specifiedCodec)) {
+                    return browserCodec;
+                }
+            }
+
+            // If we weren't able to match, just return the codec as from the URL as-is.
+            return specifiedCodec;
+        };
+
         /**
          * Enum Parameters
          */
@@ -202,29 +268,12 @@ export class Config {
                 OptionParameters.PreferredCodec,
                 'Preferred Codec',
                 'The preferred codec to be used during codec negotiation',
-                'H264 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
                 settings && Object.prototype.hasOwnProperty.call(settings, OptionParameters.PreferredCodec)
-                    ? [settings[OptionParameters.PreferredCodec]]
-                    : (function (): Array<string> {
-                          const browserSupportedCodecs: Array<string> = [];
-                          // Try get the info needed from the RTCRtpReceiver. This is only available on chrome
-                          if (!RTCRtpReceiver.getCapabilities) {
-                              browserSupportedCodecs.push('Only available on Chrome');
-                              return browserSupportedCodecs;
-                          }
-
-                          const matcher = /(VP\d|H26\d|AV1).*/;
-                          const codecs = RTCRtpReceiver.getCapabilities('video').codecs;
-                          codecs.forEach((codec) => {
-                              const str = codec.mimeType.split('/')[1] + ' ' + (codec.sdpFmtpLine || '');
-                              const match = matcher.exec(str);
-                              if (match !== null) {
-                                  browserSupportedCodecs.push(str);
-                              }
-                          });
-                          return browserSupportedCodecs;
-                      })(),
-                useUrlParams
+                    ? matchSpecifiedCodecToClosestSupported(settings[OptionParameters.PreferredCodec])
+                    : getDefaultVideoCodec(),
+                getBrowserSupportedVideoCodecs(),
+                useUrlParams,
+                matchSpecifiedCodecToClosestSupported
             )
         );
 
@@ -506,7 +555,7 @@ export class Config {
                 'AFK timeout',
                 'The time (in seconds) it takes for the application to time out if AFK timeout is enabled.',
                 0 /*min*/,
-                600 /*max*/,
+                null /*max*/,
                 settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.AFKTimeoutSecs)
                     ? settings[NumericParameters.AFKTimeoutSecs]
                     : 120 /*value*/,
@@ -521,7 +570,7 @@ export class Config {
                 'AFK countdown',
                 'The time (in seconds) for a user to respond before the stream is ended after an AFK timeout.',
                 10 /*min*/,
-                180 /*max*/,
+                null /*max*/,
                 10 /*value*/,
                 useUrlParams
             )

package/src/Config/SettingNumber.ts

@@ -7,8 +7,8 @@ import { SettingBase } from './SettingBase';
  * A number setting object with a text label. Min and max limit the range of allowed values.
  */
 export class SettingNumber<CustomIds extends string = NumericParametersIds> extends SettingBase {
-    _min: number;
-    _max: number;
+    _min: number | null;
+    _max: number | null;
 
     id: NumericParametersIds | CustomIds;
     onChangeEmit: (changedValue: number) => void;
@@ -17,8 +17,8 @@ export class SettingNumber<CustomIds extends string = NumericParametersIds> exte
         id: NumericParametersIds | CustomIds,
         label: string,
         description: string,
-        min: number,
-        max: number,
+        min: number | null,
+        max: number | null,
         defaultNumber: number,
         useUrlParams: boolean,
         // eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -65,7 +65,15 @@ export class SettingNumber<CustomIds extends string = NumericParametersIds> exte
      * @returns The clamped number.
      */
     public clamp(inNumber: number): number {
-        return Math.max(Math.min(this._max, inNumber), this._min);
+        if (this._min == null && this._max == null) {
+            return inNumber;
+        } else if (this._min == null) {
+            return Math.min(this._max, inNumber);
+        } else if (this._max == null) {
+            return Math.max(this._min, inNumber);
+        } else {
+            return Math.max(Math.min(this._max, inNumber), this._min);
+        }
     }
 
     /**

package/src/Config/SettingOption.ts

@@ -1,5 +1,6 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
+import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import type { OptionParametersIds } from './Config';
 import { SettingBase } from './SettingBase';
 
@@ -11,6 +12,9 @@ export class SettingOption<CustomIds extends string = OptionParametersIds> exten
     onChangeEmit: (changedValue: string) => void;
     _options: Array<string>;
 
+    /* Transforms the url parameter value into something else, by default no transformation is made, the url param is returned as-is. */
+    _urlParamResolver: (urlParamValue: string) => string;
+
     constructor(
         id: OptionParametersIds | CustomIds,
         label: string,
@@ -19,16 +23,24 @@ export class SettingOption<CustomIds extends string = OptionParametersIds> exten
         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. */
         }
     ) {
         super(id, label, description, defaultTextValue, defaultOnChangeListener);
 
-        this.options = options;
+        this._urlParamResolver = defaultUrlParamResolver;
+
         const stringToMatch: string = this.hasURLParam(this.id)
-            ? this.getURLParam(this.id)
+            ? this._urlParamResolver(this.getURLParam(this.id))
             : defaultTextValue;
+
+        this.options = options ?? [stringToMatch];
         this.selected = stringToMatch;
         this.useUrlParams = useUrlParams;
     }
@@ -72,20 +84,26 @@ export class SettingOption<CustomIds extends string = OptionParametersIds> exten
      * @param value Selected option
      */
     public set selected(value: string) {
-        // A user may not specify the full possible value so we instead use the closest match.
-        // eg ?xxx=H264 would select 'H264 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f'
-        let filteredList = this.options.filter((option: string) => option.indexOf(value) !== -1);
-        if (filteredList.length) {
-            this.value = filteredList[0];
+        if (value === undefined) {
             return;
         }
 
-        // A user has specified a codec with a fmtp string but this codec + fmtp line isn't available.
-        // in that case, just use the codec
-        filteredList = this.options.filter((option: string) => option.indexOf(value.split(' ')[0]) !== -1);
-        if (filteredList.length) {
-            this.value = filteredList[0];
-            return;
+        // If options contains the value, then set that as selected
+        if (this.options.includes(value)) {
+            this.value = value;
+        } else {
+            Logger.Error(
+                `Could not set "${value}" as the selected option for ${this.id} because it wasn't one of the options.`
+            );
         }
     }
+
+    /**
+     * Set the url parameter resolver to do some transformation to the string value
+     * that is extracted from the url parameters.
+     * @param urlParam A function that transforms the extracted url parameter string for this setting to something else.
+     */
+    public set urlParamResolver(value: (urlParam: string) => string) {
+        this._urlParamResolver = value;
+    }
 }

package/src/DataChannel/DataChannelLatencyTestController.ts

@@ -30,7 +30,7 @@ export class DataChannelLatencyTestController {
     callback: DataChannelLatencyTestResultCallback;
     records: Map<DataChannelLatencyTestSeq, DataChannelLatencyTestRecord>;
     seq: DataChannelLatencyTestSeq;
-    interval: NodeJS.Timer;
+    intervalHandle: number = undefined;
 
     constructor(sink: DataChannelLatencyTestSink, callback: DataChannelLatencyTestResultCallback) {
         this.sink = sink;
@@ -45,7 +45,7 @@ export class DataChannelLatencyTestController {
         }
         this.startTime = Date.now();
         this.records.clear();
-        this.interval = setInterval(
+        this.intervalHandle = window.setInterval(
             (() => {
                 if (Date.now() - this.startTime >= config.duration) {
                     this.stop();
@@ -59,9 +59,9 @@ export class DataChannelLatencyTestController {
     }
 
     stop() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = undefined;
+        if (this.intervalHandle) {
+            window.clearInterval(this.intervalHandle);
+            this.intervalHandle = undefined;
             this.callback(this.produceResult());
         }
     }
@@ -100,7 +100,7 @@ export class DataChannelLatencyTestController {
     }
 
     isRunning() {
-        return !!this.interval;
+        return !!this.intervalHandle;
     }
 
     receive(response: DataChannelLatencyTestResponse) {

package/src/PeerConnectionController/AggregatedStats.ts

@@ -19,8 +19,6 @@ type RTCStatsTypePS = RTCStatsType | 'stream' | 'media-playout' | 'track';
 export class AggregatedStats {
     inboundVideoStats: InboundVideoStats;
     inboundAudioStats: InboundAudioStats;
-    lastVideoStats: InboundVideoStats;
-    lastAudioStats: InboundAudioStats;
     candidatePairs: Array<CandidatePairStats>;
     DataChannelStats: DataChannelStats;
     localCandidates: Array<CandidateStat>;
@@ -28,7 +26,7 @@ export class AggregatedStats {
     outBoundVideoStats: OutBoundVideoStats;
     sessionStats: SessionStats;
     streamStats: StreamStats;
-    codecs: Map<string, string>;
+    codecs: Map<string, CodecStats>;
     transportStats: RTCTransportStats;
 
     constructor() {
@@ -38,7 +36,7 @@ export class AggregatedStats {
         this.outBoundVideoStats = new OutBoundVideoStats();
         this.sessionStats = new SessionStats();
         this.streamStats = new StreamStats();
-        this.codecs = new Map<string, string>();
+        this.codecs = new Map<string, CodecStats>();
     }
 
     /**
@@ -180,35 +178,39 @@ export class AggregatedStats {
     handleInBoundRTP(stat: InboundRTPStats) {
         switch (stat.kind) {
             case 'video':
-                // Need to convert to unknown first to remove an error around
-                // InboundVideoStats having the bitrate member which isn't found on
-                // the InboundRTPStats
-                this.inboundVideoStats = stat as unknown as InboundVideoStats;
-
-                if (this.lastVideoStats != undefined) {
+                // Calculate bitrate between stat updates
+                if (
+                    stat.bytesReceived > this.inboundVideoStats.bytesReceived &&
+                    stat.timestamp > this.inboundVideoStats.timestamp
+                ) {
                     this.inboundVideoStats.bitrate =
-                        (8 * (this.inboundVideoStats.bytesReceived - this.lastVideoStats.bytesReceived)) /
-                        (this.inboundVideoStats.timestamp - this.lastVideoStats.timestamp);
+                        (8 * (stat.bytesReceived - this.inboundVideoStats.bytesReceived)) /
+                        (stat.timestamp - this.inboundVideoStats.timestamp);
                     this.inboundVideoStats.bitrate = Math.floor(this.inboundVideoStats.bitrate);
                 }
-                this.lastVideoStats = { ...this.inboundVideoStats };
+
+                // Copy members from stat into `this.inboundVideoStats`
+                for (const key in stat) {
+                    (this.inboundVideoStats as any)[key] = (stat as any)[key];
+                }
                 break;
             case 'audio':
-                // Need to convert to unknown first to remove an error around
-                // InboundAudioStats having the bitrate member which isn't found on
-                // the InboundRTPStats
-                this.inboundAudioStats = stat as unknown as InboundAudioStats;
-
-                if (this.lastAudioStats != undefined) {
+                if (
+                    stat.bytesReceived > this.inboundAudioStats.bytesReceived &&
+                    stat.timestamp > this.inboundAudioStats.timestamp
+                ) {
                     this.inboundAudioStats.bitrate =
-                        (8 * (this.inboundAudioStats.bytesReceived - this.lastAudioStats.bytesReceived)) /
-                        (this.inboundAudioStats.timestamp - this.lastAudioStats.timestamp);
+                        (8 * (stat.bytesReceived - this.inboundAudioStats.bytesReceived)) /
+                        (stat.timestamp - this.inboundAudioStats.timestamp);
                     this.inboundAudioStats.bitrate = Math.floor(this.inboundAudioStats.bitrate);
                 }
-                this.lastAudioStats = { ...this.inboundAudioStats };
+                // Copy members from stat into `this.inboundAudioStats`
+                for (const key in stat) {
+                    (this.inboundAudioStats as any)[key] = (stat as any)[key];
+                }
                 break;
             default:
-                Logger.Info('Kind is not handled');
+                Logger.Error(`Kind should be audio or video, we got ${stat.kind} - that's unsupported.`);
                 break;
         }
     }
@@ -255,10 +257,7 @@ export class AggregatedStats {
 
     handleCodec(stat: CodecStats) {
         const codecId = stat.id;
-        const codecType = `${stat.mimeType.replace('video/', '').replace('audio/', '')}${
-            stat.sdpFmtpLine ? ` ${stat.sdpFmtpLine}` : ''
-        }`;
-        this.codecs.set(codecId, codecType);
+        this.codecs.set(codecId, stat);
     }
 
     handleSessionStatistics(

package/src/PeerConnectionController/PeerConnectionController.ts

@@ -5,6 +5,7 @@ import { Config, OptionParameters, Flags } from '../Config/Config';
 import { AggregatedStats } from './AggregatedStats';
 import { parseRtpParameters, splitSections } from 'sdp';
 import { RTCUtils } from '../Util/RTCUtils';
+import { CodecStats } from './CodecStats';
 
 /**
  * Handles the Peer Connection
@@ -150,21 +151,49 @@ export class PeerConnectionController {
      * Generate Aggregated Stats and then fire a onVideo Stats event
      */
     generateStats() {
-        const statsHandler = (StatsData: RTCStatsReport) => {
-            this.aggregatedStats.processStats(StatsData);
-        };
-
-        const audioPromise = this.peerConnection?.getStats(this.audioTrack).then(statsHandler);
-        const videoPromise = this.peerConnection?.getStats(this.videoTrack).then(statsHandler);
+        const audioPromise = this.audioTrack
+            ? this.peerConnection?.getStats(this.audioTrack).then((statsData: RTCStatsReport) => {
+                  this.aggregatedStats.processStats(statsData);
+              })
+            : Promise.resolve();
+        const videoPromise = this.videoTrack
+            ? this.peerConnection?.getStats(this.videoTrack).then((statsData: RTCStatsReport) => {
+                  this.aggregatedStats.processStats(statsData);
+              })
+            : Promise.resolve();
 
         Promise.allSettled([audioPromise, videoPromise]).then(() => {
             this.onVideoStats(this.aggregatedStats);
             // Update the preferred codec selection based on what was actually negotiated
             if (this.updateCodecSelection && !!this.aggregatedStats.inboundVideoStats.codecId) {
-                this.config.setOptionSettingValue(
-                    OptionParameters.PreferredCodec,
-                    this.aggregatedStats.codecs.get(this.aggregatedStats.inboundVideoStats.codecId)
+                // Construct the qualified codec name from the mimetype and fmtp
+                const codecStats: CodecStats = this.aggregatedStats.codecs.get(
+                    this.aggregatedStats.inboundVideoStats.codecId
                 );
+                const codecShortname = codecStats.mimeType.replace('video/', '');
+                let fullCodecName = codecShortname;
+                if (codecStats.sdpFmtpLine && codecStats.sdpFmtpLine.trim() !== '') {
+                    fullCodecName = `${codecShortname} ${codecStats.sdpFmtpLine.trim()}`;
+                }
+
+                const allBrowserCodecs: string[] = this.config.getSettingOption(
+                    OptionParameters.PreferredCodec
+                ).options;
+
+                // The list of codecs directly contains the one that was negotiated, select that
+                if (allBrowserCodecs.includes(fullCodecName)) {
+                    this.config.setOptionSettingValue(OptionParameters.PreferredCodec, fullCodecName);
+                    return;
+                }
+
+                // If we couldn't match on the full name, try to match on just the codec shortname
+                const filteredList = allBrowserCodecs.filter(
+                    (option: string) => option.indexOf(codecShortname) !== -1
+                );
+                if (filteredList.length > 0) {
+                    this.config.setOptionSettingValue(OptionParameters.PreferredCodec, filteredList[0]);
+                    return;
+                }
             }
         });
     }

package/src/WebRtcPlayer/WebRtcPlayerController.ts

@@ -273,7 +273,7 @@ export class WebRtcPlayerController {
         this.isReconnecting = false;
 
         this.config._addOnOptionSettingChangedListener(OptionParameters.StreamerId, (streamerid) => {
-            if (streamerid === '') {
+            if (streamerid === undefined || streamerid === '') {
                 return;
             }
 

package/src/pixelstreamingfrontend.ts

@@ -25,7 +25,12 @@ 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 {
+    EncoderSettings,
+    InitialSettings,
+    WebRTCSettings,
+    PixelStreamingSettings
+} from './DataChannel/InitialSettings';
 export { AggregatedStats } from './PeerConnectionController/AggregatedStats';
 export {
     InputCoordTranslator,
@@ -38,5 +43,6 @@ export { CandidateStat } from './PeerConnectionController/CandidateStat';
 export { DataChannelStats } from './PeerConnectionController/DataChannelStats';
 export { InboundAudioStats, InboundVideoStats } from './PeerConnectionController/InboundRTPStats';
 export { OutBoundVideoStats } from './PeerConnectionController/OutBoundRTPStats';
+export * from './DataChannel/DataChannelLatencyTestResults';
 export * from './Util/EventEmitter';
 export * from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist/commonjs",
+        "module": "commonjs",
+        "declaration": true,
+        "declarationDir": "./dist/types"
+    }
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist/esm",
+        "module": "ES6"
+    }
+}

package/tsconfig.json

@@ -1,16 +1,14 @@
 {
     "compilerOptions": {
-        "outDir": "./types",
+        "outDir": "./dist",
         "noImplicitAny": true,
-        "module": "es6",
         "esModuleInterop": true,
         "target": "ES6",
-        "moduleResolution": "node",
+        "moduleResolution": "nodenext",
         "sourceMap": true,
-        "allowJs": true,
-        "declaration": true
+        "allowJs": true
     },
-    "lib": ["es2015"],
+    "lib": ["ES6"],
     "include": ["./src/*.ts"],
     "exclude": ["./src/**/*.test.ts"],
     "typedocOptions": {