senza-sdk 4.2.64-2642526.0 → 4.2.64

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

@@ -1,7 +1,8 @@
-import { shaka } from "../interface/senzaShakaPlayer";
-
+import * as shaka from "shaka-player";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
+import moment from "moment";
+
 
 //  Define custom error category
 shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
@@ -31,6 +32,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.
  *
@@ -72,9 +78,9 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @private
      * @type {number}
      * @description Timeout in milliseconds to wait for playing event
-     * @default 3000
+     * @default 4000
      */
-    _playingTimeout = 3000;
+    _playingTimeout = 4000;
 
     /**
      * @private
@@ -89,7 +95,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @description Whether to stop remote player on error
      * @default false
      */
-    _shouldStopRemotePlayerOnError = false;
+    _shouldStopOnRemotePlayerError = false;
 
     /**
      * @private
@@ -181,7 +187,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 +286,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 +304,46 @@ export class SenzaShakaPlayer extends shaka.Player {
             clearTimeout(this._playTimeoutId);
             this._playTimeoutId = null;
         }
+
+    }
+
+    /**
+     * @private
+     * @type {number}
+     * @description Minimum suggested presentation delay in seconds
+     * @default 15
+     */
+    _minSuggestedPresentationDelay = 15;
+
+    /**
+     * Modifies the suggestedPresentationDelay in the manifest text
+     * @private
+     * @param {string} manifestText - The MPD manifest text
+     * @returns {string} - Modified manifest text , or undefined if no modification was done
+     */
+    _updateManifestDelayIfBelowMinimum(manifestText) {
+        // Look for suggestedPresentationDelay attribute
+        const match = manifestText.match(/suggestedPresentationDelay="([^"]+)"/);
+        if (match) {
+            const durationString = match[1];
+            const duration = moment.duration(durationString);
+            const currentDelay = duration.asSeconds();
+
+            sdkLogger.info(`Found suggestedPresentationDelay in manifest: ${currentDelay.toFixed(3)}s`);
+
+            if (currentDelay < this._minSuggestedPresentationDelay) {
+                // Replace the value in the manifest text with 3 decimal places
+                manifestText = manifestText.replace(
+                    /suggestedPresentationDelay="[^"]+"/,
+                    `suggestedPresentationDelay="PT${this._minSuggestedPresentationDelay.toFixed(3)}S"`
+                );
+                sdkLogger.info(`Updated manifest suggestedPresentationDelay to ${this._minSuggestedPresentationDelay.toFixed(3)}s`);
+                return manifestText;
+            }
+        } else {
+            sdkLogger.info("suggestedPresentationDelay is not defined at the manifest");
+        }
+        return undefined;
     }
 
     /**
@@ -325,14 +373,38 @@ export class SenzaShakaPlayer extends shaka.Player {
         const playTimeout = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"]?.playingEventTimeout;
         this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
 
+        // Initialize minSuggestedPresentationDelay from UI settings or use default
+        const uiSettings = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"];
+        if (uiSettings?.minSuggestedPresentationDelay !== undefined) {
+            this._minSuggestedPresentationDelay = uiSettings.minSuggestedPresentationDelay;
+            sdkLogger.info(`Using configured minSuggestedPresentationDelay: ${this._minSuggestedPresentationDelay}s`);
+        }
+
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
             this._attach(videoElement);
             sdkLogger.warn("SenzaShakaPlayer constructor Adding videoElement in the constructor is going to be deprecated in the future. Please use attach method instead.");
         }
 
+        this.configure({
+            manifest: {
+                defaultPresentationDelay: this._minSuggestedPresentationDelay // in seconds
+            }
+        });
+
+        remotePlayer.configure({
+            minSuggestedPresentationDelay: this._minSuggestedPresentationDelay
+        });
+
+        this.addEventListener("buffering", () => {
+            if (this.videoElement) {
+                sdkLogger.info("Buffering at time:", this.videoElement.currentTime);
+            }
+        });
+
     }
 
+
     _attach(videoElement) {
         this.videoElement = videoElement;
 
@@ -556,11 +628,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 +641,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));
     }
 
@@ -608,16 +683,30 @@ export class SenzaShakaPlayer extends shaka.Player {
 
         // This callbakc will be activated when the manifest is loaded. It will trigger load of the remote player.
         // This will ensure that the remote player is loaded only after the manifest is loaded by local player.
-        const responseFilterCallback = async (type) => {
-            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST && !manifestLoadHandled) {
-                manifestLoadHandled = true;
+        const responseFilterCallback = async (type, response) => {
+            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST) {
                 try {
-                    await this._remotePlayerLoad(url, startTime);
-                    remoteLoadResolver();
+                    if (response.data && this._minSuggestedPresentationDelay > 0) {
+                        const manifestText = new TextDecoder().decode(response.data);
+                        const modifiedText = this._updateManifestDelayIfBelowMinimum(manifestText);
+                        if (modifiedText) {
+                            const responseData = new TextEncoder().encode(modifiedText).buffer;
+                            response.data = responseData;
+                        }
+                    }
                 } catch (error) {
-                    remoteLoadRejecter(error);
+                    sdkLogger.error("Error processing manifest:", error);
                 }
 
+                if (!manifestLoadHandled) {
+                    manifestLoadHandled = true;
+                    try {
+                        await this._remotePlayerLoad(url, startTime);
+                        remoteLoadResolver();
+                    } catch (error) {
+                        remoteLoadRejecter(error);
+                    }
+                }
             }
         };
 
@@ -680,14 +769,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 +784,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 +889,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
-}