senza-sdk 4.2.64-70c0747.0 → 4.2.65-90c49ac.0

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

@@ -1,4 +1,3 @@
-import { RemotePlayer as RemotePlayerInterface } from "../interface/remotePlayer";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -83,7 +82,7 @@ function setPlaybackInfo(playbackInfo) {
  * @fires seeked (Not implemented yet)
  * @fires loadedmetadata (Not implemented yet)
  */
-class RemotePlayer extends RemotePlayerInterface {
+class RemotePlayer extends EventTarget {
     constructor() {
         super();
         /**
@@ -1134,8 +1133,13 @@ class RemotePlayer extends RemotePlayerInterface {
 
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
-            sdkLogger.info("application requesting play during seek");
-            this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+            if (lifecycle.state === lifecycle.UiState.FOREGROUND) {
+                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_UI");
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+            } else {
+                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_ABR");
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
+            }
             return Promise.resolve(true);
         }
         /*
@@ -1657,9 +1661,7 @@ class RemotePlayer extends RemotePlayerInterface {
             }
         }
 
-        // Only allow seeking in foreground. Still ignore the initialized local player seeking event above
-        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication &&
-            (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND)) {
+        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication) {
             this._atomicSeek();
         } else {
             sdkLogger.info(`Seeking: skipping seeking event to currentTime: ${playbackPosition}, internalSeek: ${this._isSeekingByPlatform}, localPlayerSeek: ${this._isSeekingByApplication}, state: ${lifecycle.state}`);
@@ -1678,16 +1680,16 @@ class RemotePlayer extends RemotePlayerInterface {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-
-        // Initialize the target playing state unless changed during the seek process
-        // In the future, we should allow for seeking in background. Currently, there's no
-        // way to know when the web application will call moveToForeground (i.e Before/After seek)
-        // Therefore, for now, we will assume the target is either paused or playing in ui unless
-        // specifically receiving a moveToBackground during the process.
-        // if (this._isPlaying && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-        //     this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-        // }
-        this._targetSeekPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        if (this._isPlaying) {
+            if (!lifecycle._inTransitionToForeground && (lifecycle._inTransitionToBackground || lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+                sdkLogger.info("seek in background", this._isPlaying);
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
+            } else {
+                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
+            }
+        } else {
+            this._targetSeekPlayingState = TargetPlayingState.PAUSED;
+        }
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1754,7 +1756,7 @@ class RemotePlayer extends RemotePlayerInterface {
 
         // If in TargetPlayingState.PAUSE, no need to resume.
         // Resume without awaiting to avoid blocking the seek process anymore
-        // In case where we aborted, we don't want to resume playback.
+        // In case where we aborted (new load or unload called), we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
                 if (!this._isAudioSyncEnabled()) {
@@ -1763,6 +1765,8 @@ class RemotePlayer extends RemotePlayerInterface {
                 // resume audio play only if _isAudioSyncEnabled
                 this._play(StreamType.AUDIO);
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
+                // When moving back to background, we need to put the remote player back into play mode
+                this._changePlayMode(true);
                 lifecycle._moveToBackground();
             }
         }

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

@@ -1,5 +1,4 @@
-import { shaka } from "../interface/senzaShakaPlayer";
-
+import * as shaka from "shaka-player";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
 
@@ -31,6 +30,11 @@ class SenzaError extends shaka.util.Error {
 }
 
 
+// Copy the shaka module and replace the Player class with SenzaShakaPlayer
+// if we don't Copy the shaka module, the Player class will be replaced for all the other modules that import shaka
+const senzaShaka = { ...shaka };
+
+
 /**
  * SenzaShakaPlayer subclass of Shaka that handles both local and remote playback.
  *
@@ -74,7 +78,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @description Timeout in milliseconds to wait for playing event
      * @default 3000
      */
-    _playingTimeout = 3000;
+    _playingTimeout = 4000;
 
     /**
      * @private
@@ -89,7 +93,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @description Whether to stop remote player on error
      * @default false
      */
-    _shouldStopRemotePlayerOnError = false;
+    _shouldStopOnRemotePlayerError = false;
 
     /**
      * @private
@@ -181,7 +185,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                 originatesFromRemotePlayer: true
             };
 
-            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+            const response = await this.getNetworkingEngine().request(senzaShaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
             let responseBody = response.data;
             if (response.status < 200 || response.status >= 300) {
@@ -280,13 +284,15 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 
     /**
-     * Handles errors for play promises and remote player events.
+     * Handles errors received by remote player while waiting for the playing event.
+     * The promise returned to the call for video element play will be rejected.
      * @private
      * @param {Error} error - The error object.
        */
     _handlePlayPromiseError(error) {
 
         sdkLogger.error("Error while waiting for playing event:", error);
+
         if (this._playPromiseReject) {
             this._playPromiseReject(error);
             this._playPromiseResolve = null;
@@ -296,6 +302,7 @@ export class SenzaShakaPlayer extends shaka.Player {
             clearTimeout(this._playTimeoutId);
             this._playTimeoutId = null;
         }
+
     }
 
     /**
@@ -556,11 +563,12 @@ export class SenzaShakaPlayer extends shaka.Player {
         const isCritical = this._isErrorCritical(remotePlayerErrorCode);
         const error = this._createSenzaError(remotePlayerErrorCode, message, isCritical);
         const errorMap = new Map();
+        const shouldStopPlayback = this._shouldStopOnRemotePlayerError && this.videoElement && isCritical;
         errorMap.set("detail", error);
 
         // Check if we should stop playback - only for critical errors when configured
-        if (this._shouldStopRemotePlayerOnError &&
-            this.videoElement && isCritical) {
+
+        if (shouldStopPlayback) {
             try {
                 sdkLogger.warn("Stopping local player playback due to critical error");
                 // Stop only local playback
@@ -568,9 +576,11 @@ export class SenzaShakaPlayer extends shaka.Player {
             } catch (stopError) {
                 sdkLogger.error("Error while trying to stop video element playback:", stopError);
             }
+            // Handle error while waiting for play event. If the error is not critical or the system is configured not to stop remote player on error,
+            //  the playback timeout will start the local playback
+            this._handlePlayPromiseError(error);
         }
-        // Handle error while waiting for play event
-        this._handlePlayPromiseError(error);
+
         this.dispatchEvent(new shaka.util.FakeEvent("error", errorMap));
     }
 
@@ -680,14 +690,14 @@ export class SenzaShakaPlayer extends shaka.Player {
     /**
      * Override the configure method to add custom configuration handling
      * Supports the following additional configuration options:
-     * - shouldStopRemotePlayerOnError: boolean - If true, remote player will be stopped on error
+     * - shouldStopOnRemotePlayerError: boolean - If true, local player will be stopped on remote player error
      *
      * @override
      * @param {Object} config - Configuration object to be merged with existing config
-     * @param {boolean} [config.shouldStopRemotePlayerOnError=true] - Whether to stop remote player on error
+     * @param {boolean} [config.shouldStopOnRemotePlayerError=true] - Whether to stop local player on remote player error
      * @example
      * player.configure({
-     *   shouldStopRemotePlayerOnError: false,  // Don't stop remote player on error
+     *   shouldStopOnRemotePlayerError: false,  // Don't stop local playback  on remote player error
      *   // ... other shaka configurations
      * });
      */
@@ -695,12 +705,12 @@ export class SenzaShakaPlayer extends shaka.Player {
         sdkLogger.log("configure player with: ", JSON.stringify(config));
 
         // Handle custom configuration
-        if (config.shouldStopRemotePlayerOnError !== undefined) {
-            this._shouldStopRemotePlayerOnError = !!config.shouldStopRemotePlayerOnError;
+        if (config.shouldStopOnRemotePlayerError !== undefined) {
+            this._shouldStopOnRemotePlayerError = !!config.shouldStopOnRemotePlayerError;
             // Remove our custom config so it doesn't get passed to parent
             // Use rest operator without creating a named variable for the removed property
             // eslint-disable-next-line no-unused-vars
-            const { shouldStopRemotePlayerOnError, ...shakaConfig } = config;
+            const { shouldStopOnRemotePlayerError, ...shakaConfig } = config;
             config = shakaConfig;
         }
 
@@ -800,5 +810,5 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 }
 
-shaka.Player = SenzaShakaPlayer;
-export { shaka };
+senzaShaka.Player = SenzaShakaPlayer;
+export { senzaShaka as shaka };

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

@@ -1,15 +1,10 @@
 import { getPlatformInfo } from "./api";
+import pack from "../package.json";
 import { sessionInfo } from "./SessionInfo";
+const { version } = pack;
 
 const REST_RESPONSE_TIMEOUT_SECONDS = 5;
 
-export function getVersion() {
-    return typeof IMPLEMENTATION_VERSION !== "undefined"
-        // eslint-disable-next-line no-undef
-        ? IMPLEMENTATION_VERSION
-        : "unknown";
-};
-
 export function getFCID() {
     return Math.round(Math.random() * 100000) + "-" + getPlatformInfo().sessionInfo?.connectionId;
 }
@@ -47,7 +42,7 @@ class SdkLogger {
         console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
     }
     withFields(logFields) {
-        return new SdkLogger({ ...this.logFields, ...logFields });
+        return new SdkLogger({...this.logFields, ...logFields});
     }
     formatLogString(data) {
         let logString = "[hs-sdk] " + data.join(" ");
@@ -56,13 +51,9 @@ class SdkLogger {
         }
         return logString;
     }
-    addfields(fields) {
-        this.logFields = { ...this.logFields, ...fields };
-        return this;
-    }
 }
 
-export const sdkLogger = new SdkLogger({ sdkVersion: getVersion(), url: window?.location?.href ?? "" });
+export const sdkLogger = new SdkLogger({sdkVersion: version, url: window?.location?.href ?? ""});
 
 export async function getRestResponse(messageName) {
 
@@ -73,14 +64,14 @@ export async function getRestResponse(messageName) {
 
     return new Promise((resolve, reject) => {
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({ FCID });
+        const logger = sdkLogger.withFields({FCID});
         const message = {
             type: "restRequest",
             name: messageName,
             method: "GET",
             fcid: FCID
         };
-        const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+        const request = {target: "TC", waitForResponse: true, message: JSON.stringify(message)};
         let timeoutHandler = 0;
         const queryId = window.cefQuery({
             request: JSON.stringify(request),

package/src/implementation/api.js

@@ -1,367 +0,0 @@
-import { getFCID, sdkLogger, getVersion } from "./utils.js";
-import { sessionInfo } from "./SessionInfo.js";
-import { lifecycle } from "./lifecycle.js";
-import { alarmManager } from "./alarmManager.js";
-
-let authToken;
-
-const API_VERSION = "1.0";
-let interfaceVersion;
-
-typeof document !== "undefined" && document.addEventListener("keydown", (event) => {
-    sdkLogger.log(`Got ${event.key} key`);
-});
-
-/** @namespace auth
- *@example
- * import { auth } from "senza-sdk";
- **/
-export const auth = {
-
-    /** Should be called upon startup and be embedded in future requests */
-    getToken,
-
-    /** Should be called upon '401' event (unauthorized) */
-    forceTokenUpdate,
-
-    getClientAssertion
-
-};
-
-import { remotePlayer } from "./remotePlayer.js";
-export { remotePlayer };
-
-/** Should be called once to init the library
- *@example
- * import { init } from "senza-sdk";
- * await init();
- **/
-export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFunc) {
-    interfaceVersion = interfaceApiVersion;
-    sdkLogger.addfields({ interfaceVersion });
-    sdkLogger.log(`init. Interface version: ${interfaceVersion}. Implementation version: ${getVersion()}`);
-
-    if (!window.diagnostics) {
-        // ------------------------------------------------------------------------------------------------
-        // -- Do NOT change this log, as ui-streamer is checking this string to detect abnormal behavior --
-        // ------------------------------------------------------------------------------------------------
-        sdkLogger.error("[ init ] window.diagnostics is undefined");
-    }
-
-    if (window.cefQuery) {
-
-        // First, check compatability with ui-streamer api version
-        await new Promise((resolve, reject) => {
-            window.cefQuery({
-                request: "apiVersion " + API_VERSION,
-                persistent: false,
-                onSuccess: () => {
-                    sdkLogger.log("api version compatability check succeeded");
-                    resolve();
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.error("api version compatability check failed: " + msg);
-                    reject(msg);
-                }
-            });
-        });
-
-        const sessionInfoStr = await new Promise((resolve) => {
-            window.cefQuery({
-                request: "sessionInfo",
-                persistent: false,
-                onSuccess: (response) => {
-                    sdkLogger.log("sessionInfo request successfully returned " + response);
-                    resolve(response);
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.error(`sessionInfo request failed: ${code} ${msg}`);
-                }
-            });
-        });
-
-        sessionInfo.setSessionInfoStr(sessionInfoStr);
-        const sessionInfoObj = JSON.parse(sessionInfoStr);
-        authToken = sessionInfoObj?.settings?.webUI?.backendHeaders?.Authorization;
-        sdkLogger.log(`authToken: token = ${authToken}`);
-        // Listen to updateSession event to set the new token
-        document.addEventListener("updateSession", (e) => {
-            authToken = e.detail?.updateObj;
-            sdkLogger.log(`onUpdateSessionEvent: token = ${authToken}`);
-        });
-
-        // Set default alarm timeout using UI-Streamer settings
-        const alarmTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.alarmTimeout;
-        if (alarmTimeout) {
-            alarmManager._setDefaultTimeout(alarmTimeout);
-        }
-
-        // Get trigger event
-        const triggerEventStr = await new Promise((resolve) => {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            const message = { type: "triggerEvent", fcid: FCID };
-            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
-            window.cefQuery({
-                request: JSON.stringify(request),
-                persistent: false,
-                onSuccess: (response) => {
-                    logger.log(`triggerEvent request successfully returned '${response}'`);
-                    resolve(response);
-                },
-                onFailure: (code, msg) => {
-                    logger.error(`triggerEvent request failed: ${code} ${msg}`);
-                    resolve("");
-                }
-            });
-        });
-        let triggerEvent = {};
-        if (triggerEventStr) {
-            try {
-                triggerEvent = JSON.parse(triggerEventStr);
-            } catch (e) {
-                sdkLogger.error(`failed to parse trigger event string ${triggerEventStr}: ${e.message}`);
-            }
-        }
-
-        // Initialize lifecycle first to make sure the state is updated.
-        await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-        await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
-
-        const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
-        if (devSequence) {
-            initSequenceFunc({ lifecycle, remotePlayer });
-            showSequenceFunc(true);
-        }
-
-    } else {
-        authToken = getPlatformInfo().sessionInfo?.settings?.webUI?.backendHeaders?.Authorization;
-        sdkLogger.log(`authToken dummy: token = ${authToken}`);
-    }
-
-    // override window.close() since it's not allowed to close the application this way
-    window.close = () => {
-        sdkLogger.warn("window.close is disabled on Senza platform. Use lifecycle.exitApplication() instead.");
-    };
-
-
-}
-
-// Returns the platform information, including version, pod, pod ip and session info.
-export function getPlatformInfo() {
-    if (typeof window !== "undefined" && window.diagnostics) {
-        try {
-            const platformInfo = window.diagnostics() || {};
-            platformInfo.sessionInfo = sessionInfo.sessionInfoObj;
-            return platformInfo;
-        } catch (e) {
-            sdkLogger.error("Could not get platform info", e.stack);
-        }
-
-    } else {
-        if (typeof window !== "undefined" && !window.diagnostics) {
-            sdkLogger.error("[ getPlatformInfo ] window.diagnostics is undefined");
-        }
-        return {
-            version: "X.X.XX-X",
-            pod: "ui-streamer-X.X.XX-X-QWERT-ASDFG-XXX-XXXXXX-XXXXX",
-            podIP: "0.0.0.0",
-            sessionInfo: {
-                userAgent: "SynamediaSenza/XX.YY.ZZ",
-                connectionId: "dummy",
-                deviceId: "123456789",
-                community: "LocalDev",
-                tenant: "XXXXXX",
-                tenantId: "XXXXXX",
-                manifest: {
-                    transcontainer: "X.X.XX-X"
-                },
-                settings: {
-                    webUI: {
-                        backendHeaders: {
-                            Authorization: "Bearer dummytoken"
-                        }
-                    }
-                },
-                homeSessionInfo: {
-                    tenantId: "XXXXXX",
-                    community: "LocalDev"
-                }
-            }
-        };
-    }
-}
-
-async function getToken() {
-    if (!authToken) {
-        sdkLogger.log("getToken wait for promise updateSession event");
-        return new Promise((resolve) => {
-            // Listen to updateSession event to set the new token
-            document.addEventListener("updateSession", (e) => {
-                authToken = e.detail?.updateObj;
-                sdkLogger.log(`onUpdateSessionEvent: token= ${authToken}`);
-                resolve(authToken);
-            }, { once: true });
-        });
-    }
-    return Promise.resolve(authToken);
-}
-
-function forceTokenUpdate() {
-    authToken = null;
-
-    if (window.cefQuery) {
-        const FCID = getFCID();
-        const logger = sdkLogger.withFields({ FCID });
-        logger.log("forceTokenUpdate: sending updateSessionRequest");
-        const message = {
-            type: "updateSessionRequest",
-            updateKey: "authorization",
-            parentPath: "settings.webUI.backendHeaders.Authorization",
-            fcid: FCID
-        };
-        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
-        window.cefQuery({
-            request: JSON.stringify(request),
-            persistent: false,
-            onSuccess: () => {
-                logger.log("updateSessionRequest successfully sent");
-            },
-            onFailure: (code, msg) => {
-                logger.error(`updateSessionRequest failed: ${code} ${msg}`);
-            }
-        });
-    } else {
-        sdkLogger.error("forceTokenUpdate: window.cefQuery is undefined");
-    }
-}
-
-/** Returns a boolean that indicates whether we are running in an e2e environment, or on local browser */
-export function isRunningE2E() {
-    return !!(typeof window !== "undefined" && window.cefQuery);
-}
-
-/** Call this API once after application startup, when the ui is ready to accept keys/events */
-export function uiReady() {
-    if (window.cefQuery) {
-        window.cefQuery({
-            request: "uiReady",
-            persistent: false,
-            onSuccess: () => {
-                sdkLogger.log("uiReady request successfully sent");
-            },
-            onFailure: (code, msg) => {
-                sdkLogger.error(`uiReady request failed: ${code} ${msg}`);
-            }
-        });
-    } else {
-        sdkLogger.error("uiReady: window.cefQuery is undefined");
-    }
-}
-
-export { lifecycle } from "./lifecycle.js";
-export { deviceManager } from "./deviceManager.js";
-export { platformManager } from "./platformManager.js";
-export { alarmManager };
-export { messageManager } from "./messageManager.js";
-export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
-
-import "./devHelper.js";
-
-/**
- * The function receives a license response and passes it to platform.
- * @param {number} statusCode status code that was received from the license server
- * @param {ArrayBuffer|string} licenseResponse a license response that was received from the license server to be passed to platform.
- * @param {string} fcid a fcid received with the license request
- * @param {string} sessionId a sessionId received with the license request
- * In case of success licenceResponse is of type @type {ArrayBuffer}
- * In case of error licenseResponse is of type @type {string}
- */
-export function writeLicenseResponse(statusCode, licenseResponse, fcid, sessionId) {
-
-    if (statusCode >= 200 && statusCode < 300) {
-        licenseResponse = window.btoa(String.fromCharCode.apply(null, new Uint8Array(licenseResponse))); // to base64
-    }
-
-    if (window.cefQuery) {
-        const message = {
-            type: "updateLicense",
-            sessionId,
-            fcid
-        };
-        message[statusCode >= 200 && statusCode < 300 ? "response" : "error"] = licenseResponse;
-        const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
-        window.cefQuery({
-            request: JSON.stringify(request),
-            persistent: false,
-            onSuccess: () => {
-                sdkLogger.log("updateLicense request successfully sent");
-            },
-            onFailure: (code, msg) => {
-                sdkLogger.error(`updateLicense request failed: ${code} ${msg}`);
-            }
-        });
-    }
-
-}
-
-export class ClientAssertionError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-}
-
-/**
- * @typedef Token
- * @property {string} hostplatform_assertion The client assertion token.
-*/
-
-/**
- * Async function that returns the client assertion
- * @return {Promise<Token>} Promise which is resolved to a client assertion object when getClientAssertion has been successfully performed. * client assertion object contains hostplatform_assertion property which holds the client assertion token.
- * Failure to getClientAssertion for any reason, result in the promise being rejected.
- * Error status codes:
- * Status code 400 - Tenant configuration is missing
- * Status code 0 - General error
- *  @example
- * try {
- *     const client_assertion = await auth.getClientAssertion();
- *     console.log("Client assertion token is", client_assertion.hostplatform_assertion);
- * } catch (e) {
- *     console.error("getClientAssertion failed", e);
- * }
- */
-export function getClientAssertion() {
-    if (window.cefQuery) {
-        sdkLogger.log("getClientAssertion is called");
-
-        return new Promise((resolve, reject) => {
-            window.cefQuery({
-                request: "client_assertion",
-                persistent: false,
-                onSuccess: (response) => {
-                    try {
-                        const json_response = JSON.parse(response);
-                        sdkLogger.log(`client_assertion request successfully returned ${response}`);
-                        resolve(json_response);
-                    } catch (e) {
-                        sdkLogger.error(`Failed to parse client assertion ${response}: ${e.message}`);
-                        reject(new ClientAssertionError(0, "Failed to parse client assertion"));
-                    }
-
-                },
-                onFailure: (code, msg) => {
-                    sdkLogger.log(`client_assertion request failed: ${code} ${msg}`);
-                    reject(new ClientAssertionError(code, msg));
-                }
-            });
-        });
-    }
-    sdkLogger.warn("getClientAssertion is not supported if NOT running e2e");
-}
-
-import * as senzaSDK from "./api.js";
-if (typeof window !== "undefined") {
-    window.senzaSDKImplementation = window.senzaSDKImplementation || senzaSDK; // this is only for testing purposes which allows us to use and test senza APIs in pipeline tests
-}