senza-sdk 4.2.65-d2761c0.0 → 4.3.0

package/src/{lifecycle.js → implementation/lifecycle.js}

@@ -1,4 +1,6 @@
-import { alarmManager, getPlatformInfo } from "./api";
+import { Lifecycle as LifecycleInterface } from "../interface/lifecycle";
+import { getPlatformInfo } from "./api";
+import { alarmManager } from "./alarmManager";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -18,82 +20,7 @@ const DEFAULT_AUTO_BACKGROUND_VIDEO_DELAY = 30;
 const DEFAULT_AUTO_BACKGROUND_UI_DELAY = -1;
 const DEFAULT_AUTO_BACKGROUND_ENABLED = false;
 
-/**
-  * Lifecycle is a singleton class that manages the application lifecycle states.<br>
-  * @fires onstatechange
-  * @fires userinactivity
-  * @fires userdisconnected
- */
-class Lifecycle extends EventTarget {
-
-    /**
-     * @typedef {Object} ConnectReason - The reason the ui app has been loaded
-     * @property {string} UNKNOWN
-     * @property {string} INITIAL_CONNECTION - Indicates that ui app has been loaded for the first time
-     * @property {string} APPLICATION_RELOAD - Indicates that ui app has been reloaded (e.g. after HOME keypress)
-     * @property {string} UI_RELEASE - Indicates that ui app has been reloaded after ui release
-     * @property {string} UI_TERMINATION - Indicates that ui app has been reloaded due to ui termination
-     * @property {string} WEBRTC_ERROR - Indicates that ui app has been reloaded due to webrtc error
-     * @property {string} UI_WATCHDOG - Indicates that ui app has been reloaded due to ui watchdog not receiving ui frames
-     */
-    ConnectReason = Object.freeze({
-        UNKNOWN: "unknown",
-        INITIAL_CONNECTION: "initial_connection",
-        APPLICATION_RELOAD: "reload_app",
-        UI_RELEASE: "ui_release",
-        UI_TERMINATION: "ui_termination",
-        WEBRTC_ERROR: "webrtc_error",
-        UI_WATCHDOG: "ui_watchdog"
-    });
-
-    /**
-     * @typedef {Object} UiState - The ui lifecycle state
-     * @property {string} UNKNOWN - state is unknown at this time
-     * @property {string} FOREGROUND - ui is displayed
-     * @property {string} IN_TRANSITION_TO_FOREGROUND - ui is about to be displayed
-     * @property {string} BACKGROUND - remote player is playing (full screen playback is displayed)
-     * @property {string} IN_TRANSITION_TO_BACKGROUND - remote player is about to be playing
-     */
-    UiState = Object.freeze({
-        UNKNOWN: "unknown",
-        FOREGROUND: "foreground",
-        IN_TRANSITION_TO_FOREGROUND: "inTransitionToForeground",
-        BACKGROUND: "background",
-        IN_TRANSITION_TO_BACKGROUND: "inTransitionToBackground"
-    });
-
-    /**
-     * @event Lifecycle#onstatechange
-     * @description Fired after transition from one state to another.<br>
-     * The flow is: foreground --> inTransitionToBackground --> background --> inTransitionToForeground --> foreground
-     * @property {UiState} state - Indicates the new state.
-     * @example
-     * lifecycle.addEventListener("onstatechange", (e) => {
-     *     console.log("new state is", e.state);
-     * });
-     */
-
-    /**
-     * @event Lifecycle#userinactivity
-     * @description Fired after the ui has been inactive (i.e. no key presses) for a configurable number of seconds.<br>
-     * @property {number} timeout - the number of seconds after which the application will be unloaded.
-     * @example
-     * lifecycle.addEventListener("userinactivity", (e) => {
-     *     console.log(`Application will be unloaded in ${e.timeout} seconds`);
-     * });
-     * @alpha API has not yet been released
-     */
-
-    /**
-     * @event Lifecycle#userdisconnected
-     * @description Fired when the user session ends .
-     * This event is useful for cleaning up application state or saving data before the application closes. Event callback should return promise to ensure that the event is handled before the application is terminated
-     * @example
-     * lifecycle.addEventListener("userdisconnected", () => {
-     *     console.log("User session ended, cleaning up application state");
-     *     // Perform any necessary cleanup here
-     * });
-     */
+class Lifecycle extends LifecycleInterface {
     constructor() {
         super();
 
@@ -102,9 +29,7 @@ class Lifecycle extends EventTarget {
          * @private
          */
         this._isInitialized = false;
-        this._inTransitionToForeground = false;
-        this._inTransitionToBackground = false;
-        this._inTransitionToStandby = false;
+        this._inTransition = false;
 
         /**
          * Event listeners manager for the userdisconnected event
@@ -181,7 +106,8 @@ class Lifecycle extends EventTarget {
         });
     }
 
-    /** @private Initialize the lifecycle
+    /**
+     * @private Initialize the lifecycle
      * @param {Object} uiStreamerSettings - UI-streamer portion of the settings taken from session info
      * @param {Object} [uiStreamerSettings.autoBackground] - Auto background mode configuration
      * @param {boolean} [uiStreamerSettings.autoBackground.enabled=false] - Enable/disable auto background
@@ -278,14 +204,16 @@ class Lifecycle extends EventTarget {
         }
     }
 
-    /** @private Checks if auto background is enabled including overrides.
+    /**
+     * @private Checks if auto background is enabled including overrides.
      * @returns {boolean}
      */
     _isAutoBackgroundEnabled() {
         return this._autoBackgroundOverrides?.enabled ?? this._autoBackground;
     }
 
-    /** @private Gets the auto background video delay including overrides.
+    /**
+     * @private Gets the auto background video delay including overrides.
      * @returns {number}
      */
     _getAutoBackgroundOnVideoDelay() {
@@ -296,7 +224,8 @@ class Lifecycle extends EventTarget {
         return this._autoBackgroundOnVideoDelay;
     }
 
-    /** @private Gets the auto background UI delay including overrides.
+    /**
+     * @private Gets the auto background UI delay including overrides.
      * @returns {number}
      */
     _getAutoBackgroundOnUIDelay() {
@@ -307,15 +236,6 @@ class Lifecycle extends EventTarget {
         return this._autoBackgroundOnUIDelay;
     }
 
-    /**
-     * Configure lifecycle settings
-     * @param {Object} config - Configuration object
-     * @param {Object} [config.autoBackground] - Auto background settings
-     * @param {boolean} [config.autoBackground.enabled] - Enable/disable auto background
-     * @param {Object} [config.autoBackground.timeout] - Timeout settings
-     * @param {number|false} [config.autoBackground.timeout.playing=30] - Timeout in seconds when video is playing, false to disable
-     * @param {number|false} [config.autoBackground.timeout.idle=false] - Timeout in seconds when in UI mode, false to disable
-     */
     configure(config) {
         if (config?.autoBackground) {
             const { enabled, timeout } = config.autoBackground;
@@ -355,15 +275,6 @@ class Lifecycle extends EventTarget {
         }
     }
 
-    /**
-     * Get the current configuration settings
-     * @returns {Object} The current configuration object
-     * @example
-     * const config = lifecycle.getConfiguration();
-     * console.log(config.autoBackground.enabled); // true/false
-     * console.log(config.autoBackground.timeout.playing); // 30
-     * console.log(config.autoBackground.timeout.idle); // false
-     */
     getConfiguration() {
         return {
             autoBackground: {
@@ -377,6 +288,7 @@ class Lifecycle extends EventTarget {
     }
 
     /**
+     * @private
      * This method moves the application into standby mode, i.e. last ui frame is displayed and ui resources are released.
      * It should be called whenever the application wishes to go into standby mode and release resources.
      * @example
@@ -386,7 +298,7 @@ class Lifecycle extends EventTarget {
     // This api is part of epic HSDEV-713
     _moveToUiStandby() {
         if (window.cefQuery) {
-            this._inTransitionToStandby = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", fcid: FCID }) };
@@ -397,12 +309,12 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("[ moveToUiStandby ] moveToUiStandby successfully sent");
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
                         logger.error(`[ moveToUiStandby ] moveToUiStandby failed: ${code} ${msg}`);
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         reject(`moveToUiStandby failed: ${code} ${msg}`);
                     }
                 });
@@ -412,10 +324,6 @@ class Lifecycle extends EventTarget {
         return Promise.resolve(true);
     }
 
-    /**
-     * Getter for returning the ui lifecycle state
-     * @returns {UiState} the current application lifecycle state
-     */
     get state() {
         if (!this._isInitialized) {
             this._state = this.UiState.UNKNOWN;
@@ -423,10 +331,6 @@ class Lifecycle extends EventTarget {
         return this._state;
     }
 
-    /**
-     * Getter for returning the application connection reason
-     * @returns {ConnectReason} the application connection reason
-     */
     get connectReason() {
         if (!this._isInitialized) {
             this._connectReason = this.ConnectReason.UNKNOWN;
@@ -434,11 +338,6 @@ class Lifecycle extends EventTarget {
         return this._connectReason;
     }
 
-    /**
-     * Getter for returning the event that triggered the reloading of the ui after ui has been released
-     * @returns {Object} trigger event
-     * @property {string} type - the type of the trigger event (e.g. keyPressEvent, videoPlaybackEvent)
-     * @property {object} data - data of the event, dependent on its type (e.g. keyPressEvent has data of keyValue) */
     get triggerEvent() {
         if (!this._isInitialized) {
             this._triggerEvent = {};
@@ -446,14 +345,6 @@ class Lifecycle extends EventTarget {
         return this._triggerEvent;
     }
 
-    /**
-     * @deprecated Use `lifecycle.configure()` instead.
-     * Controls the autoBackground feature.<br>
-     * When enabled, the application will automatically move to the background state after a configurable
-     * period of inactivity. Use the `configure` method to set timeouts for video playback and UI states.
-     * @type {boolean}
-     * @see {@link Lifecycle#configure}
-     */
     set autoBackground(enabled) {
         this._autoBackground = enabled;
         if (this._isAutoBackgroundEnabled()) {
@@ -467,14 +358,6 @@ class Lifecycle extends EventTarget {
         return this._autoBackground;
     }
 
-    /**
-     * @deprecated Use `lifecycle.configure()` instead.
-     * The number of seconds of user inactivity before the application moves to the background state while playing video.
-     * Use the `configure` method to set this timeout.
-     * @type {integer}
-     * @default 30
-     * @see {@link Lifecycle#configure}
-     */
     set autoBackgroundDelay(delay) {
         this._autoBackgroundOnVideoDelay = delay;
         if (this._isAutoBackgroundEnabled() && remotePlayer._isPlaying) {
@@ -486,14 +369,6 @@ class Lifecycle extends EventTarget {
         return this._autoBackgroundOnVideoDelay;
     }
 
-    /**
-     * @deprecated Use `lifecycle.configure()` instead.
-     * The number of seconds of user inactivity before the application moves to the background state while in the UI (not playing).
-     * Use the `configure` method to set this timeout.
-     * @type {integer}
-     * @default -1
-     * @see {@link Lifecycle#configure}
-     */
     set autoBackgroundOnUIDelay(delay) {
         this._autoBackgroundOnUIDelay = delay;
         if (this._isAutoBackgroundEnabled() && !remotePlayer._isPlaying) {
@@ -536,26 +411,6 @@ class Lifecycle extends EventTarget {
         this._countdown = null;
     }
 
-    /**
-     * @private
-     */
-    _isInTransition() {
-        return this._inTransitionToForeground || this._inTransitionToBackground || this._inTransitionToStandby;
-    }
-
-
-    /**
-     * @deprecated use lifecycle.state instead.
-     * Async function that returns the ui lifecycle state
-     * @returns {UiState} the current application lifecycle state
-     * @example
-     * try {
-     *     const state = await lifecycle.getState();
-     *     console.log("current state is", state);
-     * } catch (e) {
-     *     console.error("getState failed", e);
-     * }
-     */
     getState() {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
@@ -576,29 +431,16 @@ class Lifecycle extends EventTarget {
         sdkLogger.warn("lifecycle getState is not supported if NOT running e2e");
     }
 
-    /**
-     * Once playback starts on the remote player,
-     * the application is moved from foreground to inTransitionToBackground and eventually to background.
-     * The application will need to call moveToForeground when it receives an event that needs the UI to be displayed again,
-     * for example a key press, a playback end-of-file or a playback error.
-     * @return {Promise} Promise which is resolved when the moveToForeground command has been successfully processed.
-     * Failure to process the moveToForeground command will result in the promise being rejected.
-     */
     moveToForeground() {
         if (window.cefQuery) {
-            const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
+            if (this._inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${this._inTransition}`);
                 return Promise.resolve(false);
             }
-            this._inTransitionToForeground = true;
+            this._inTransition = true;
             alarmManager._moveToForegroundCalled();
             const FCID = getFCID();
             if (this._remotePlayerApiVersion >= 2) {
-                // Only update to playing UI if we started seeking in ABR. But, if we are seeking while already paused, keep the target seek state as is.
-                if (remotePlayer._isSeekingByApplication && remotePlayer._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
-                    remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-                }
                 return new Promise((resolve, reject) => {
                     const FCID = getFCID();
                     const logger = sdkLogger.withFields({ FCID });
@@ -618,14 +460,14 @@ class Lifecycle extends EventTarget {
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
-                            this._inTransitionToForeground = false;
+                            this._inTransition = false;
                             timerId = clearTimer(timerId);
                             resolve(true);
                         },
                         onFailure: (code, msg) => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransitionToForeground = false;
+                            this._inTransition = false;
                             timerId = clearTimer(timerId);
                             reject(new SenzaError(code, msg));
                         }
@@ -634,7 +476,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -649,11 +491,11 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("uiActiveRequest successfully sent");
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         logger.error(`uiActiveRequest failed: ${code} ${msg}`);
                         reject(`uiActiveRequest failed: ${code} ${msg}`);
                     }
@@ -666,6 +508,10 @@ class Lifecycle extends EventTarget {
 
     _moveToBackground() {
         if (window.cefQuery) {
+            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
+                return Promise.resolve(false);
+            }
             // If audio sync is disabled, we only need to sync before remote player starts playing
             if (!isAudioSyncConfigured()) {
                 remotePlayer._syncRemotePlayerWithLocalPlayer();
@@ -677,7 +523,7 @@ class Lifecycle extends EventTarget {
                 return this._moveToUiStandby();
             }
 
-            this._inTransitionToBackground = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
@@ -718,14 +564,14 @@ class Lifecycle extends EventTarget {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play completed successfully after ${duration} ms`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         timerId = clearTimer(timerId);
                         resolve();
                     },
                     onFailure: (code, msg) => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -735,7 +581,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -746,24 +592,13 @@ class Lifecycle extends EventTarget {
         return Promise.resolve(false);
     }
 
-    /**
-     * This method moves the application to the background.
-     * It should be called after remotePlayer.play().
-     * As a consequence, remote player playback will be displayed in full screen.
-     * @example
-     * remotePlayer.load("https://example.com/video.mp4", 0);
-     * remotePlayer.play();
-     * lifecycle.moveToBackground();
-     * @return {Promise} Promise which is resolved when the moveToBackground command has been successfully processed.
-     * Failure to process the moveToBackground command will result in the promise being rejected.
-     */
     moveToBackground() {
         if (window.cefQuery) {
-            const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${inTransition}`);
+            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
                 return Promise.resolve(false);
             }
+
             if (remotePlayer._isSeekingByApplication) {
                 remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
                 return Promise.resolve(true);
@@ -780,13 +615,6 @@ class Lifecycle extends EventTarget {
         return this._moveToBackground();
     }
 
-    /**
-     * Use this api to switch to another tenant (other than the home tenant) which will launch the application associated with the tenantId. The tenantId must be configured in the
-     * Senza platform. Switching to the home tenant should use the exitApplication().
-     * @param {string} tenantId The tenantId to switch
-     * @return {Promise} Promise which is resolved when the switchTenant command has been successfully processed.
-     * Failure to process the switchTenant command will result in the promise being rejected.
-     */
     switchTenant(tenantId) {
         if (tenantId && tenantId.length > 0) {
             if (tenantId === getPlatformInfo().sessionInfo?.tenantId) {
@@ -832,11 +660,6 @@ class Lifecycle extends EventTarget {
         return Promise.reject("SwitchTenant requires a valid tenantId string parameter");
     }
 
-    /**
-     * Use this api to exit the application which will redirect the browser to the home tenant application.
-     * @return {Promise} Promise which is resolved when the exitApplication command has been successfully processed.
-     * Failure to process the exitApplication command will result in the promise being rejected.
-     */
     exitApplication() {
         if (window.cefQuery) {
             return new Promise((resolve, reject) => {
@@ -885,12 +708,6 @@ class Lifecycle extends EventTarget {
         return Promise.reject("exitApplication is not supported if NOT running e2e");
     }
 
-    /**
-     * Add event listener for lifecycle events
-     * @param {string} type - The event type to listen for
-     * @param {Function} listener - The callback function. Listeners for 'userdisconnected' events should return a promise to ensure the event is processed before the application exits.
-     * @param {Object} options - Event listener options
-     */
     addEventListener(type, listener, options) {
         if (type === "userdisconnected") {
             // Use the event manager for userdisconnected events
@@ -901,12 +718,7 @@ class Lifecycle extends EventTarget {
         }
     }
 
-    /**
-     * Remove event listener
-     * @param {string} type - The event type
-     * @param {Function} listener - The callback function to remove
-     * @param {Object} options - Event listener options
-     */
+
     removeEventListener(type, listener, options) {
         if (type === "userdisconnected") {
             // Use the event manager for userdisconnected events

package/src/implementation/messageManager.js

@@ -0,0 +1,55 @@
+import { MessageManager as MessageManagerInterface } from "../interface/messageManager";
+import { getFCID, sdkLogger } from "./utils";
+
+class MessageManager extends MessageManagerInterface {
+
+    constructor() {
+        super();
+        typeof document !== "undefined" && document.addEventListener("hs/externalEvent", (e) => {
+            sdkLogger.log("Got hs/externalEvent", JSON.stringify(e.detail));
+            this.dispatchEvent(new CustomEvent("message", { detail: { eventName: e.detail.eventName, payload: e.detail.payload, fcid: e.detail.fcid } }));
+        });
+    }
+
+    async registerGroups(groups) {
+        sdkLogger.log(`register called for ${groups}`);
+        return new Promise((resolve, reject) => {
+            if (window.cefQuery) {
+                const FCID = getFCID();
+                const logger = sdkLogger.withFields({ FCID });
+                const message = {
+                    type: "registerGroupEvent",
+                    fcid: FCID,
+                    groups
+                };
+                const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
+                window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        logger.log("registerGroupEvent request successfully sent");
+                        resolve(true);
+                    },
+                    onFailure: (code, msg) => {
+                        logger.error(`registerGroupEvent failed: ${code} ${msg}`);
+                        reject(`registerGroupEvent failed: ${code} ${msg}`);
+                    }
+                });
+            } else {
+                sdkLogger.warn("registerGroupEvent is not supported if NOT running e2e");
+                reject("registerGroupEvent is not supported if NOT running e2e");
+            }
+        });
+    }
+}
+
+/**
+ *
+ * @module
+ * @example
+ * import { MessageManager } from "senza-sdk";
+ *
+ * @return {MessageManager} pointer to the MessageManager singleton
+ */
+
+export const messageManager = new MessageManager();

package/src/{platformManager.js → implementation/platformManager.js}

@@ -1,41 +1,23 @@
+import { PlatformManager as PlatformManagerInterface } from "../interface/platformManager";
 import { sdkLogger } from "./utils";
-import {sessionInfo} from "./SessionInfo";
+import { sessionInfo } from "./SessionInfo";
 
-
-/**
- * PlatformManager is a singleton class that manages the platform
- */
-class PlatformManager extends EventTarget {
+class PlatformManager extends PlatformManagerInterface {
 
     constructor() {
         super();
     }
 
-    /**
-     * @returns {Object} appConfig object
-     * @property {String[]} territories - a list of territories configured for the tenant.
-     * if the list is undefined or empty - there are no restrictions.
-     * @example
-     * import { platformManager } from "senza-sdk";
-     * const appConfig = platformManager.appConfig
-     * */
     get appConfig() {
         const sessionInfoObj = sessionInfo.sessionInfoObj;
         const appConfig = sessionInfoObj.homeSessionInfo?.["appConfig"] || {};
-        sdkLogger.info("PlatformManager get appConfig: \n" + JSON.stringify(appConfig, null,2));
+        sdkLogger.info("PlatformManager get appConfig: \n" + JSON.stringify(appConfig, null, 2));
         return appConfig;
     }
 
-    /**
-     *
-     * @param {string} timezone the timezone to set to
-     * the format of the timezone is according to the standard TZ identifier
-     * (e.g. America/Los_Angeles, Asia/Tokyo, Europe/Brussels)
-     * for a full list of TZ identifiers, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-     */
     setTimezone(timezone) {
         if (window.cefQuery) {
-            const request = {message: JSON.stringify({type: "setTimeZone", timezone}), waitForResponse: false, target: "UI-Streamer"};
+            const request = { message: JSON.stringify({ type: "setTimeZone", timezone }), waitForResponse: false, target: "UI-Streamer" };
             window.cefQuery({
                 request: JSON.stringify(request),
                 persistent: false,