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

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.2",
     "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]
+                    : false,
+                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/Inputs/KeyboardController.ts

@@ -19,7 +19,7 @@ export class KeyboardController implements IInputController {
     onKeyDownListener: (event: KeyboardEvent) => void;
     onKeyUpListener: (event: KeyboardEvent) => void;
     onKeyPressListener: (event: KeyboardEvent) => void;
-    onCompositionEndListener: (event: KeyboardEvent) => void;
+    onCompositionEndListener: (event: CompositionEvent) => void;
 
     constructor(streamMessageController: StreamMessageController, config: Config, activeKeys: ActiveKeys) {
         this.streamMessageController = streamMessageController;
@@ -54,15 +54,19 @@ export class KeyboardController implements IInputController {
         }
 
         const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
-        toStreamerHandlers.get('KeyDown')([this.getKeycode(keyboardEvent), keyboardEvent.repeat ? 1 : 0]);
+        toStreamerHandlers.get('KeyDown')?.([this.getKeycode(keyboardEvent)!, keyboardEvent.repeat ? 1 : 0]);
         const activeKeys = this.activeKeys.getActiveKeys();
         activeKeys.push(keyCode);
+
         // Backspace is not considered a keypress in JavaScript but we need it
         // to be so characters may be deleted in a UE text entry field.
+        // since keypress is deprecated we really should be sending all keys to keypress
+        // or we change everything to handle the deprecation of these parts
         if (keyCode === SpecialKeyCodes.backSpace) {
-            document.dispatchEvent(
+            this.handleOnKeyPress(
                 new KeyboardEvent('keypress', {
-                    charCode: SpecialKeyCodes.backSpace
+                    charCode: SpecialKeyCodes.backSpace,
+                    keyCode: SpecialKeyCodes.backSpace
                 })
             );
         }
@@ -79,7 +83,7 @@ export class KeyboardController implements IInputController {
         }
 
         const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
-        toStreamerHandlers.get('KeyUp')([keyCode]);
+        toStreamerHandlers.get('KeyUp')?.([keyCode]);
 
         if (this.config.isFlagEnabled(Flags.SuppressBrowserKeys) && this.isKeyCodeBrowserKey(keyCode)) {
             keyboardEvent.preventDefault();
@@ -93,7 +97,7 @@ export class KeyboardController implements IInputController {
         }
 
         const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
-        toStreamerHandlers.get('KeyPress')([keyCode]);
+        toStreamerHandlers.get('KeyPress')?.([keyCode]);
     }
 
     private handleOnCompositionEnd(compositionEvent: CompositionEvent) {
@@ -132,8 +136,10 @@ export class KeyboardController implements IInputController {
         // If we don't have keyCode property because browser API is deprecated then use KeyboardEvent.code instead.
         // See: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode#constants_for_keycode_value
         if (!('keyCode' in keyboardEvent)) {
-            // Convert KeyboardEvent.code string into integer-based key code for backwards compatibility reasons.
+            // this type assertion here is required because if 'keyCode' doesnt exist in keyboardEvent then
+            // it cannot be a KeyboardEvent and so it gets narrowed to 'never'
             const event = keyboardEvent as KeyboardEvent;
+            // Convert KeyboardEvent.code string into integer-based key code for backwards compatibility reasons.
             if (event.code in CodeToKeyCode) {
                 return CodeToKeyCode[event.code];
             } else {