@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.4.1 → 0.4.3

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

@@ -50,6 +50,7 @@ export declare class WebRtcPlayerController {
     gamePadController: GamepadController;
     coordinateConverter: InputCoordTranslator;
     isUsingSFU: boolean;
+    isUsingSVC: boolean;
     isQualityController: boolean;
     statsTimerHandle: number;
     file: FileTemplate;
@@ -273,6 +274,22 @@ export declare class WebRtcPlayerController {
      * to drop quality as low as needed on the given network link.
      */
     sendEncoderMaxQP(maxQP: number): void;
+    /**
+     * Send the MinQuality encoder setting to the UE Instance.
+     * @param minQuality - The lower bound for quality when encoding
+     * valid values are (0-100) where:
+     * 0 = Worst quality.
+     * 100 = Best quality.
+     */
+    sendEncoderMinQuality(minQuality: number): void;
+    /**
+     * Send the MaxQuality encoder setting to the UE Instance.
+     * @param maxQuality - The upper bound for quality when encoding
+     * valid values are (0-100) where:
+     * 0 = Worst quality.
+     * 100 = Best quality.
+     */
+    sendEncoderMaxQuality(maxQuality: number): void;
     /**
      * Send the { WebRTC.MinBitrate: SomeNumber }} command to UE to set
      * the minimum bitrate that we allow WebRTC to use

package/dist/types/WebXR/WebXRController.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="webxr" />
 import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
 export declare class WebXRController {
     private xrSession;

package/dist/types/pixelstreamingfrontend.d.ts

@@ -1,6 +1,6 @@
 export { WebRtcPlayerController } from './WebRtcPlayer/WebRtcPlayerController';
 export { WebXRController } from './WebXR/WebXRController';
-export { Config, ControlSchemeType, Flags, NumericParameters, TextParameters, OptionParameters, FlagsIds, NumericParametersIds, TextParametersIds, OptionParametersIds, AllSettings } from './Config/Config';
+export { Config, ControlSchemeType, Flags, NumericParameters, TextParameters, OptionParameters, FlagsIds, NumericParametersIds, TextParametersIds, OptionParametersIds, AllSettings, OptionIds, isFlagId, isNumericId, isOptionId, isTextId } from './Config/Config';
 export { SettingBase } from './Config/SettingBase';
 export { SettingFlag } from './Config/SettingFlag';
 export { SettingNumber } from './Config/SettingNumber';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@epicgames-ps/lib-pixelstreamingfrontend-ue5.5",
-    "version": "0.4.1",
+    "version": "0.4.3",
     "description": "Frontend library for Unreal Engine 5.5 Pixel Streaming",
     "main": "dist/commonjs/pixelstreamingfrontend.js",
     "module": "dist/esm/pixelstreamingfrontend.js",
@@ -15,22 +15,22 @@
         "spellcheck": "cspell \"{README.md,.github/*.md,src/**/*.ts}\""
     },
     "devDependencies": {
-        "@types/jest": "27.5.1",
+        "@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": "^27.5.1",
-        "jest-environment-jsdom": "27.5.1",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "^29.7.0",
         "prettier": "3.3.3",
-        "ts-jest": "27.1.5",
-        "typedoc": "^0.23.24",
-        "typescript": "^4.9.4"
+        "ts-jest": "^29.2.5",
+        "typedoc": "^0.27.4",
+        "typescript": "^5.0.0"
     },
     "dependencies": {
+        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.1.4",
         "@types/webxr": "^0.5.1",
-        "@epicgames-ps/lib-pixelstreamingcommon-ue5.5": "^0.1.2",
         "sdp": "^3.1.0"
     },
     "repository": {

package/src/Config/Config.ts

@@ -38,7 +38,7 @@ export class Flags {
 export type FlagsKeys = Exclude<keyof typeof Flags, 'prototype'>;
 export type FlagsIds = (typeof Flags)[FlagsKeys];
 
-const isFlagId = (id: string): id is FlagsIds =>
+export const isFlagId = (id: string): id is FlagsIds =>
     Object.getOwnPropertyNames(Flags).some((name: FlagsKeys) => Flags[name] === id);
 
 /**
@@ -50,6 +50,10 @@ export class NumericParameters {
     static AFKCountdownSecs = 'AFKCountdown' as const;
     static MinQP = 'MinQP' as const;
     static MaxQP = 'MaxQP' as const;
+    static MinQuality = 'MinQuality' as const;
+    static MaxQuality = 'MaxQuality' as const;
+    static CompatQualityMin = 'CompatQualityMin' as const;
+    static CompatQualityMax = 'CompatQualityMax' as const;
     static WebRTCFPS = 'WebRTCFPS' as const;
     static WebRTCMinBitrate = 'WebRTCMinBitrate' as const;
     static WebRTCMaxBitrate = 'WebRTCMaxBitrate' as const;
@@ -60,7 +64,7 @@ export class NumericParameters {
 export type NumericParametersKeys = Exclude<keyof typeof NumericParameters, 'prototype'>;
 export type NumericParametersIds = (typeof NumericParameters)[NumericParametersKeys];
 
-const isNumericId = (id: string): id is NumericParametersIds =>
+export const isNumericId = (id: string): id is NumericParametersIds =>
     Object.getOwnPropertyNames(NumericParameters).some(
         (name: NumericParametersKeys) => NumericParameters[name] === id
     );
@@ -76,7 +80,7 @@ export class TextParameters {
 export type TextParametersKeys = Exclude<keyof typeof TextParameters, 'prototype'>;
 export type TextParametersIds = (typeof TextParameters)[TextParametersKeys];
 
-const isTextId = (id: string): id is TextParametersIds =>
+export const isTextId = (id: string): id is TextParametersIds =>
     Object.getOwnPropertyNames(TextParameters).some(
         (name: TextParametersKeys) => TextParameters[name] === id
     );
@@ -88,12 +92,13 @@ const isTextId = (id: string): id is TextParametersIds =>
 export class OptionParameters {
     static PreferredCodec = 'PreferredCodec' as const;
     static StreamerId = 'StreamerId' as const;
+    static PreferredQuality = 'PreferredQuality' as const;
 }
 
 export type OptionParametersKeys = Exclude<keyof typeof OptionParameters, 'prototype'>;
 export type OptionParametersIds = (typeof OptionParameters)[OptionParametersKeys];
 
-const isOptionId = (id: string): id is OptionParametersIds =>
+export const isOptionId = (id: string): id is OptionParametersIds =>
     Object.getOwnPropertyNames(OptionParameters).some(
         (name: OptionParametersKeys) => OptionParameters[name] === id
     );
@@ -277,6 +282,20 @@ export class Config {
             )
         );
 
+        this.optionParameters.set(
+            OptionParameters.PreferredQuality,
+            new SettingOption(
+                OptionParameters.PreferredQuality,
+                'Preferred Quality',
+                'The preferred quality of the stream (only applicable when using the SFU)',
+                settings && Object.prototype.hasOwnProperty.call(settings, OptionParameters.PreferredQuality)
+                    ? settings[OptionParameters.PreferredQuality]!
+                    : 'Default',
+                ['Default'],
+                useUrlParams
+            )
+        );
+
         /**
          * Boolean parameters
          */
@@ -622,6 +641,66 @@ export class Config {
             )
         );
 
+        this.numericParameters.set(
+            NumericParameters.MinQuality,
+            new SettingNumber(
+                NumericParameters.MinQuality,
+                'Min Quality',
+                'The lower bound for the quality factor of the encoder. 0 = Worst quality, 100 = Best quality.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.MinQuality)
+                    ? settings[NumericParameters.MinQuality]
+                    : 0 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.MaxQuality,
+            new SettingNumber(
+                NumericParameters.MaxQuality,
+                'Max Quality',
+                'The upper bound for the quality factor of the encoder. 0 = Worst quality, 100 = Best quality.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.MaxQuality)
+                    ? settings[NumericParameters.MaxQuality]
+                    : 100 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.CompatQualityMin,
+            new SettingNumber(
+                NumericParameters.CompatQualityMin,
+                'Min Quality',
+                'The lower bound for encoding quality. 0 = Worst, 100 = Best.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.CompatQualityMin)
+                    ? settings[NumericParameters.CompatQualityMin]
+                    : 0 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.CompatQualityMax,
+            new SettingNumber(
+                NumericParameters.CompatQualityMax,
+                'Max Quality',
+                'The upper bound for encoding quality. 0 = Worst, 100 = Best.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.CompatQualityMax)
+                    ? settings[NumericParameters.CompatQualityMax]
+                    : 100 /*value*/,
+                useUrlParams
+            )
+        );
+
         this.numericParameters.set(
             NumericParameters.WebRTCFPS,
             new SettingNumber(

package/src/Config/SettingFlag.ts

@@ -7,8 +7,8 @@ import { SettingBase } from './SettingBase';
  * A boolean flag setting object with a text label.
  */
 export class SettingFlag<CustomIds extends string = FlagsIds> extends SettingBase {
-    id: FlagsIds | CustomIds;
-    onChangeEmit: (changedValue: boolean) => void;
+    override id: FlagsIds | CustomIds;
+    override onChangeEmit: (changedValue: boolean) => void;
 
     constructor(
         id: FlagsIds | CustomIds,
@@ -33,7 +33,7 @@ export class SettingFlag<CustomIds extends string = FlagsIds> extends SettingBas
         this.useUrlParams = useUrlParams;
     }
 
-    protected getValueAsString(): string {
+    protected override getValueAsString(): string {
         return this.flag ? 'true' : 'false';
     }
 

package/src/Config/SettingNumber.ts

@@ -10,8 +10,8 @@ export class SettingNumber<CustomIds extends string = NumericParametersIds> exte
     _min: number | null;
     _max: number | null;
 
-    id: NumericParametersIds | CustomIds;
-    onChangeEmit: (changedValue: number) => void;
+    override id: NumericParametersIds | CustomIds;
+    override onChangeEmit: (changedValue: number) => void;
 
     constructor(
         id: NumericParametersIds | CustomIds,
@@ -41,7 +41,7 @@ export class SettingNumber<CustomIds extends string = NumericParametersIds> exte
         this.useUrlParams = useUrlParams;
     }
 
-    protected getValueAsString(): string {
+    protected override getValueAsString(): string {
         return this.number.toString();
     }
 

package/src/Config/SettingOption.ts

@@ -8,8 +8,8 @@ import { SettingBase } from './SettingBase';
  * An Option setting object with a text label. Allows you to specify an array of options and select one of them.
  */
 export class SettingOption<CustomIds extends string = OptionParametersIds> extends SettingBase {
-    id: OptionParametersIds | CustomIds;
-    onChangeEmit: (changedValue: string) => void;
+    override id: OptionParametersIds | CustomIds;
+    override 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. */
@@ -45,7 +45,7 @@ export class SettingOption<CustomIds extends string = OptionParametersIds> exten
         this.useUrlParams = useUrlParams;
     }
 
-    protected getValueAsString(): string {
+    protected override getValueAsString(): string {
         return this.selected;
     }
 

package/src/Config/SettingText.ts

@@ -7,9 +7,9 @@ import { SettingBase } from './SettingBase';
  * A text setting object with a text label.
  */
 export class SettingText<CustomIds extends string = TextParametersIds> extends SettingBase {
-    id: TextParametersIds | CustomIds;
-    onChangeEmit: (changedValue: string) => void;
-    useUrlParams: boolean;
+    override id: TextParametersIds | CustomIds;
+    override onChangeEmit: (changedValue: string) => void;
+    override useUrlParams: boolean;
 
     constructor(
         id: TextParametersIds | CustomIds,
@@ -33,7 +33,7 @@ export class SettingText<CustomIds extends string = TextParametersIds> extends S
         this.useUrlParams = useUrlParams;
     }
 
-    protected getValueAsString(): string {
+    protected override getValueAsString(): string {
         return this.text;
     }
 

package/src/DataChannel/DataChannelController.ts

@@ -49,7 +49,7 @@ export class DataChannelController {
         this.dataChannel.onopen = (ev: Event) => this.handleOnOpen(ev);
         this.dataChannel.onclose = (ev: Event) => this.handleOnClose(ev);
         this.dataChannel.onmessage = (ev: MessageEvent) => this.handleOnMessage(ev);
-        this.dataChannel.onerror = (ev: MessageEvent) => this.handleOnError(ev);
+        this.dataChannel.onerror = (ev: Event) => this.handleOnError(ev);
     }
 
     /**
@@ -81,7 +81,7 @@ export class DataChannelController {
      * Handles when an error is thrown
      * @param event - Error Event
      */
-    handleOnError(event: MessageEvent) {
+    handleOnError(event: Event) {
         Logger.Info(`Data Channel (${this.label}) error: ${event}`);
         this.onError(this.dataChannel?.label, event);
     }

package/src/DataChannel/InitialSettings.ts

@@ -40,6 +40,8 @@ export class EncoderSettings {
     MaxBitrate?: number;
     MinQP?: number;
     MaxQP?: number;
+    MinQuality?: number;
+    MaxQuality?: number;
     RateControl?: 'CBR' | 'VBR' | 'ConstQP';
     FillerData?: boolean;
     MultiPass?: 'DISABLED' | 'QUARTER' | 'FULL';

package/src/Inputs/MouseControllerHovering.ts

@@ -33,7 +33,7 @@ export class MouseControllerHovering extends MouseController {
         this.onContextMenuListener = this.onContextMenu.bind(this);
     }
 
-    register(): void {
+    override register(): void {
         super.register();
 
         this.videoElementParent.addEventListener('mousemove', this.onMouseMoveListener);
@@ -44,7 +44,7 @@ export class MouseControllerHovering extends MouseController {
         this.videoElementParent.addEventListener('dblclick', this.onMouseDblClickListener);
     }
 
-    unregister(): void {
+    override unregister(): void {
         this.videoElementParent.removeEventListener('mousemove', this.onMouseMoveListener);
         this.videoElementParent.removeEventListener('mousedown', this.onMouseDownListener);
         this.videoElementParent.removeEventListener('mouseup', this.onMouseUpListener);

package/src/Inputs/MouseControllerLocked.ts

@@ -44,7 +44,7 @@ export class MouseControllerLocked extends MouseController {
         this.onMouseMoveListener = this.onMouseMove.bind(this);
     }
 
-    register() {
+    override register() {
         super.register();
 
         this.videoElementParent.requestPointerLock =
@@ -64,7 +64,7 @@ export class MouseControllerLocked extends MouseController {
         this.videoElementParent.addEventListener('dblclick', this.onMouseDblClickListener);
     }
 
-    unregister() {
+    override unregister() {
         const pointerLockElement = document.pointerLockElement || document.mozPointerLockElement;
         if (document.exitPointerLock && pointerLockElement === this.videoElementParent) {
             document.exitPointerLock();

package/src/PeerConnectionController/PeerConnectionController.ts

@@ -428,18 +428,18 @@ export class PeerConnectionController {
                 ) {
                     // Get our preferred codec from the codecs options drop down
                     const preferredRTPCodec = this.preferredCodec.split(' ');
-                    const preferredRTCRtpCodecCapability: RTCRtpCodecCapability = {
+                    const preferredRTCRtpCodecCapability: RTCRtpCodec = {
                         mimeType: 'video/' + preferredRTPCodec[0] /* Name */,
                         clockRate: 90000 /* All current video formats in browsers have 90khz clock rate */,
                         sdpFmtpLine: preferredRTPCodec[1] ? preferredRTPCodec[1] : ''
                     };
 
                     // Populate a list of codecs we will support with our preferred one in the first position
-                    const ourSupportedCodecs: Array<RTCRtpCodecCapability> = [preferredRTCRtpCodecCapability];
+                    const ourSupportedCodecs: Array<RTCRtpCodec> = [preferredRTCRtpCodecCapability];
 
                     // Go through all codecs the browser supports and add them to the list (in any order)
                     RTCRtpReceiver.getCapabilities('video').codecs.forEach(
-                        (browserSupportedCodec: RTCRtpCodecCapability) => {
+                        (browserSupportedCodec: RTCRtpCodec) => {
                             // Don't add our preferred codec again, but add everything else
                             if (browserSupportedCodec.mimeType != preferredRTCRtpCodecCapability.mimeType) {
                                 ourSupportedCodecs.push(browserSupportedCodec);
@@ -626,11 +626,11 @@ export class PeerConnectionController {
         const sections = splitSections(rtcSessionDescription.sdp);
         // discard the session information as we only want media related info
         sections.shift();
-        sections.forEach((mediaSection) => {
+        sections.forEach((mediaSection: any) => {
             const { codecs } = parseRtpParameters(mediaSection);
             // Filter only for VPX / H26X / AV1
             const matcher = /(VP\d|H26\d|AV1).*/;
-            codecs.forEach((c) => {
+            codecs.forEach((c: any) => {
                 const str =
                     c.name +
                     ' ' +

package/src/PixelStreaming/PixelStreaming.ts

@@ -183,19 +183,58 @@ export class PixelStreaming {
             this._webRtcController.setGamePadInputEnabled(isEnabled);
         });
 
-        // encoder settings
+        // direct qp settings
         this.config._addOnNumericSettingChangedListener(NumericParameters.MinQP, (newValue: number) => {
             Logger.Info('--------  Sending MinQP  --------');
             this._webRtcController.sendEncoderMinQP(newValue);
             Logger.Info('-------------------------------------------');
+            const quality = Math.trunc(100 * (1 - newValue / 51));
+            this.config.setNumericSetting(NumericParameters.CompatQualityMax, quality);
         });
 
         this.config._addOnNumericSettingChangedListener(NumericParameters.MaxQP, (newValue: number) => {
-            Logger.Info('--------  Sending encoder settings  --------');
+            Logger.Info('--------  Sending MaxQP  --------');
             this._webRtcController.sendEncoderMaxQP(newValue);
             Logger.Info('-------------------------------------------');
+            const quality = Math.trunc(100 * (1 - newValue / 51));
+            this.config.setNumericSetting(NumericParameters.CompatQualityMin, quality);
         });
 
+        // direct quality factor settings
+        this.config._addOnNumericSettingChangedListener(NumericParameters.MinQuality, (newValue: number) => {
+            Logger.Info('--------  Sending MinQuality  --------');
+            this._webRtcController.sendEncoderMinQuality(newValue);
+            Logger.Info('-------------------------------------------');
+            this.config.setNumericSetting(NumericParameters.CompatQualityMin, newValue);
+        });
+
+        this.config._addOnNumericSettingChangedListener(NumericParameters.MaxQuality, (newValue: number) => {
+            Logger.Info('--------  Sending MaxQuality  --------');
+            this._webRtcController.sendEncoderMaxQuality(newValue);
+            Logger.Info('-------------------------------------------');
+            this.config.setNumericSetting(NumericParameters.CompatQualityMax, newValue);
+        });
+
+        // new quality value that gets scaled to qp for legacy reasons
+        this.config._addOnNumericSettingChangedListener(
+            NumericParameters.CompatQualityMin,
+            (newValue: number) => {
+                newValue = 51 - (newValue / 100) * 51;
+                Logger.Info('--------  Sending MinQP from quality value  --------');
+                this._webRtcController.sendEncoderMaxQP(newValue);
+                Logger.Info('-------------------------------------------');
+            }
+        );
+
+        this.config._addOnNumericSettingChangedListener(
+            NumericParameters.CompatQualityMax,
+            (newValue: number) => {
+                newValue = 51 - (newValue / 100) * 51;
+                Logger.Info('--------  Sending MaxQP from quality value  --------');
+                this._webRtcController.sendEncoderMinQP(newValue);
+                Logger.Info('-------------------------------------------');
+            }
+        );
         // WebRTC settings
         this.config._addOnNumericSettingChangedListener(
             NumericParameters.WebRTCMinBitrate,
@@ -531,20 +570,60 @@ export class PixelStreaming {
         const urlParams = new IURLSearchParams(window.location.search);
         Logger.Info(`using URL parameters ${useUrlParams}`);
         if (settings.EncoderSettings) {
-            this.config.setNumericSetting(
-                NumericParameters.MinQP,
-                // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
-                useUrlParams && urlParams.has(NumericParameters.MinQP)
-                    ? Number.parseFloat(urlParams.get(NumericParameters.MinQP))
-                    : settings.EncoderSettings.MinQP
-            );
+            // here we should either get Min/MaxQP from PS1
+            // or Min/MaxQuality from PS2
+            // we only want to set one set or the other as they converge in CompatQualityMin/Max and
+            // we dont want to have them conflict with default values.
+            if (settings.EncoderSettings.MinQP) {
+                this.config.setNumericSetting(
+                    NumericParameters.MinQP,
+                    // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
+                    useUrlParams && urlParams.has(NumericParameters.MinQP)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MinQP))
+                        : settings.EncoderSettings.MinQP || 0
+                );
 
-            this.config.setNumericSetting(
-                NumericParameters.MaxQP,
-                useUrlParams && urlParams.has(NumericParameters.MaxQP)
-                    ? Number.parseFloat(urlParams.get(NumericParameters.MaxQP))
-                    : settings.EncoderSettings.MaxQP
-            );
+                this.config.setNumericSetting(
+                    NumericParameters.MaxQP,
+                    useUrlParams && urlParams.has(NumericParameters.MaxQP)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MaxQP))
+                        : settings.EncoderSettings.MaxQP || 51
+                );
+            }
+
+            if (settings.EncoderSettings.MinQuality) {
+                this.config.setNumericSetting(
+                    NumericParameters.MinQuality,
+                    // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
+                    useUrlParams && urlParams.has(NumericParameters.MinQuality)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MinQuality))
+                        : settings.EncoderSettings.MinQuality || 0
+                );
+
+                this.config.setNumericSetting(
+                    NumericParameters.MaxQuality,
+                    useUrlParams && urlParams.has(NumericParameters.MaxQuality)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MaxQuality))
+                        : settings.EncoderSettings.MaxQuality || 100
+                );
+            }
+
+            // these two are just used to converge quality and qp and behave slightly differently since they
+            // shouldnt exist in EncoderSettings
+            if (useUrlParams) {
+                if (urlParams.has(NumericParameters.CompatQualityMin)) {
+                    this.config.setNumericSetting(
+                        NumericParameters.CompatQualityMin,
+                        Number.parseFloat(urlParams.get(NumericParameters.CompatQualityMin))
+                    );
+                }
+                if (urlParams.has(NumericParameters.CompatQualityMax)) {
+                    this.config.setNumericSetting(
+                        NumericParameters.CompatQualityMax,
+                        Number.parseFloat(urlParams.get(NumericParameters.CompatQualityMax))
+                    );
+                }
+            }
         }
         if (settings.WebRTCSettings) {
             this.config.setNumericSetting(

package/src/UeInstanceMessage/SendMessageController.ts

@@ -50,6 +50,7 @@ export class SendMessageController {
                             case 'int16':
                             case 'float':
                             case 'double':
+                            default:
                                 return 'number';
                             case 'string':
                                 return 'string';