@azure/msal-browser 3.20.0 → 3.21.0

package/dist/controllers/NestedAppAuthController.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.20.0 2024-07-23 */
+/*! @azure/msal-browser v3.21.0 2024-08-13 */
 'use strict';
 import { DEFAULT_CRYPTO_IMPLEMENTATION, buildStaticAuthorityOptions, PerformanceEvents, TimeUtils, OIDC_DEFAULT_SCOPES, AccountEntity } from '@azure/msal-common';
 import { InteractionType, DEFAULT_REQUEST } from '../utils/BrowserConstants.mjs';
@@ -10,478 +10,478 @@ import { EventType } from '../event/EventType.mjs';
 import { BrowserCacheManager, DEFAULT_BROWSER_CACHE_MANAGER } from '../cache/BrowserCacheManager.mjs';
 import { getAccount, setActiveAccount, getAllAccounts, getAccountByUsername, getAccountByHomeId, getAccountByLocalId, getActiveAccount } from '../cache/AccountManager.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class NestedAppAuthController {
-    constructor(operatingContext) {
-        this.operatingContext = operatingContext;
-        const proxy = this.operatingContext.getBridgeProxy();
-        if (proxy !== undefined) {
-            this.bridgeProxy = proxy;
-        }
-        else {
-            throw new Error("unexpected: bridgeProxy is undefined");
-        }
-        // Set the configuration.
-        this.config = operatingContext.getConfig();
-        // Initialize logger
-        this.logger = this.operatingContext.getLogger();
-        // Initialize performance client
-        this.performanceClient = this.config.telemetry.client;
-        // Initialize the crypto class.
-        this.browserCrypto = operatingContext.isBrowserEnvironment()
-            ? new CryptoOps(this.logger, this.performanceClient)
-            : DEFAULT_CRYPTO_IMPLEMENTATION;
-        // Initialize the browser storage class.
-        this.browserStorage = this.operatingContext.isBrowserEnvironment()
-            ? new BrowserCacheManager(this.config.auth.clientId, this.config.cache, this.browserCrypto, this.logger, buildStaticAuthorityOptions(this.config.auth))
-            : DEFAULT_BROWSER_CACHE_MANAGER(this.config.auth.clientId, this.logger);
-        this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
-        this.nestedAppAuthAdapter = new NestedAppAuthAdapter(this.config.auth.clientId, this.config.auth.clientCapabilities, this.browserCrypto, this.logger);
-        // Set the active account if available
-        const accountContext = this.bridgeProxy.getAccountContext();
-        if (accountContext) {
-            const cachedAccount = getAccount(accountContext, this.logger, this.browserStorage);
-            setActiveAccount(cachedAccount, this.browserStorage);
-        }
-    }
-    /**
-     * Returns the event handler instance
-     * @returns EventHandler
-     */
-    getEventHandler() {
-        return this.eventHandler;
-    }
-    /**
-     * Factory function to create a new instance of NestedAppAuthController
-     * @param operatingContext
-     * @returns Promise<IController>
-     */
-    static async createController(operatingContext) {
-        const controller = new NestedAppAuthController(operatingContext);
-        return Promise.resolve(controller);
-    }
-    /**
-     * Specific implementation of initialize function for NestedAppAuthController
-     * @returns
-     */
-    initialize() {
-        // do nothing not required by this controller
-        return Promise.resolve();
-    }
-    /**
-     * Validate the incoming request and add correlationId if not present
-     * @param request
-     * @returns
-     */
-    ensureValidRequest(request) {
-        if (request?.correlationId) {
-            return request;
-        }
-        return {
-            ...request,
-            correlationId: this.browserCrypto.createNewGuid(),
-        };
-    }
-    /**
-     * Internal implementation of acquireTokenInteractive flow
-     * @param request
-     * @returns
-     */
-    async acquireTokenInteractive(request) {
-        const validRequest = this.ensureValidRequest(request);
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Popup, validRequest);
-        const atPopupMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPopup, validRequest.correlationId);
-        atPopupMeasurement?.add({ nestedAppAuthRequest: true });
-        try {
-            const naaRequest = this.nestedAppAuthAdapter.toNaaTokenRequest(validRequest);
-            const reqTimestamp = TimeUtils.nowSeconds();
-            const response = await this.bridgeProxy.getTokenInteractive(naaRequest);
-            const result = this.nestedAppAuthAdapter.fromNaaTokenResponse(naaRequest, response, reqTimestamp);
-            // cache the tokens in the response
-            await this.hydrateCache(result, request);
-            this.browserStorage.setActiveAccount(result.account);
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
-            atPopupMeasurement.add({
-                accessTokenSize: result.accessToken.length,
-                idTokenSize: result.idToken.length,
-            });
-            atPopupMeasurement.end({
-                success: true,
-                requestId: result.requestId,
-            });
-            return result;
-        }
-        catch (e) {
-            const error = this.nestedAppAuthAdapter.fromBridgeError(e);
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Popup, null, e);
-            atPopupMeasurement.end({
-                success: false,
-            }, e);
-            throw error;
-        }
-    }
-    /**
-     * Internal implementation of acquireTokenSilent flow
-     * @param request
-     * @returns
-     */
-    async acquireTokenSilentInternal(request) {
-        const validRequest = this.ensureValidRequest(request);
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, validRequest);
-        // Look for tokens in the cache first
-        const result = await this.acquireTokenFromCache(validRequest);
-        if (result) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
-            return result;
-        }
-        // proceed with acquiring tokens via the host
-        const ssoSilentMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SsoSilent, validRequest.correlationId);
-        ssoSilentMeasurement?.increment({
-            visibilityChangeCount: 0,
-        });
-        ssoSilentMeasurement?.add({
-            nestedAppAuthRequest: true,
-        });
-        try {
-            const naaRequest = this.nestedAppAuthAdapter.toNaaTokenRequest(validRequest);
-            const reqTimestamp = TimeUtils.nowSeconds();
-            const response = await this.bridgeProxy.getTokenSilent(naaRequest);
-            const result = this.nestedAppAuthAdapter.fromNaaTokenResponse(naaRequest, response, reqTimestamp);
-            // cache the tokens in the response
-            await this.hydrateCache(result, request);
-            this.browserStorage.setActiveAccount(result.account);
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
-            ssoSilentMeasurement?.add({
-                accessTokenSize: result.accessToken.length,
-                idTokenSize: result.idToken.length,
-            });
-            ssoSilentMeasurement?.end({
-                success: true,
-                requestId: result.requestId,
-            });
-            return result;
-        }
-        catch (e) {
-            const error = this.nestedAppAuthAdapter.fromBridgeError(e);
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, e);
-            ssoSilentMeasurement?.end({
-                success: false,
-            }, e);
-            throw error;
-        }
-    }
-    /**
-     * acquires tokens from cache
-     * @param request
-     * @returns
-     */
-    async acquireTokenFromCache(request) {
-        const atsMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenSilent, request.correlationId);
-        atsMeasurement?.add({
-            nestedAppAuthRequest: true,
-        });
-        const result = await this.acquireTokenFromCacheInternal(request);
-        if (result) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
-            atsMeasurement?.add({
-                accessTokenSize: result?.accessToken.length,
-                idTokenSize: result?.idToken.length,
-            });
-            atsMeasurement?.end({
-                success: true,
-            });
-            return result;
-        }
-        this.logger.error("Cached tokens are not found for the account, proceeding with silent token request.");
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null);
-        atsMeasurement?.end({
-            success: false,
-        });
-        return null;
-    }
-    /**
-     *
-     * @param request
-     * @returns
-     */
-    async acquireTokenFromCacheInternal(request) {
-        const accountContext = this.bridgeProxy.getAccountContext();
-        let currentAccount = null;
-        if (accountContext) {
-            const hubAccount = getAccount(accountContext, this.logger, this.browserStorage);
-            // always prioritize for hub account context, the reqirement of `request.account` will be removed soon
-            currentAccount = hubAccount || request.account;
-        }
-        // fall back to brokering if no cached account is found
-        if (!currentAccount) {
-            this.logger.verbose("No active account found, falling back to the host");
-            return Promise.resolve(null);
-        }
-        this.logger.verbose("active account found, attempting to acquire token silently");
-        const authRequest = {
-            ...request,
-            correlationId: request.correlationId || this.browserCrypto.createNewGuid(),
-            authority: request.authority || currentAccount.environment,
-            scopes: request.scopes?.length
-                ? request.scopes
-                : [...OIDC_DEFAULT_SCOPES],
-        };
-        // fetch access token and check for expiry
-        const tokenKeys = this.browserStorage.getTokenKeys();
-        const cachedAccessToken = this.browserStorage.getAccessToken(currentAccount, authRequest, tokenKeys, currentAccount.tenantId, this.performanceClient, authRequest.correlationId);
-        // If there is no access token, log it and return null
-        if (!cachedAccessToken) {
-            this.logger.verbose("No cached access token found");
-            return Promise.resolve(null);
-            // If access token has expired, remove the token from cache and return null
-        }
-        else if (TimeUtils.wasClockTurnedBack(cachedAccessToken.cachedAt) ||
-            TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.system.tokenRenewalOffsetSeconds)) {
-            this.logger.verbose("Cached access token has expired, deleting all related tokens from cache");
-            const accountEntity = AccountEntity.createFromAccountInfo(currentAccount);
-            await this.browserStorage.removeAccountContext(accountEntity);
-            return Promise.resolve(null);
-        }
-        const cachedIdToken = this.browserStorage.getIdToken(currentAccount, tokenKeys, currentAccount.tenantId, this.performanceClient, authRequest.correlationId);
-        if (!cachedIdToken) {
-            this.logger.verbose("No cached id token found");
-            return Promise.resolve(null);
-        }
-        return this.nestedAppAuthAdapter.toAuthenticationResultFromCache(currentAccount, cachedIdToken, cachedAccessToken, authRequest, authRequest.correlationId);
-    }
-    /**
-     * acquireTokenPopup flow implementation
-     * @param request
-     * @returns
-     */
-    async acquireTokenPopup(request) {
-        return this.acquireTokenInteractive(request);
-    }
-    /**
-     * acquireTokenRedirect flow is not supported in nested app auth
-     * @param request
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    acquireTokenRedirect(request) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    /**
-     * acquireTokenSilent flow implementation
-     * @param silentRequest
-     * @returns
-     */
-    async acquireTokenSilent(silentRequest) {
-        return this.acquireTokenSilentInternal(silentRequest);
-    }
-    /**
-     * Hybrid flow is not currently supported in nested app auth
-     * @param request
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    acquireTokenByCode(request // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    /**
-     * acquireTokenNative flow is not currently supported in nested app auth
-     * @param request
-     * @param apiId
-     * @param accountId
-     */
-    acquireTokenNative(request, apiId, // eslint-disable-line @typescript-eslint/no-unused-vars
-    accountId // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    /**
-     * acquireTokenByRefreshToken flow is not currently supported in nested app auth
-     * @param commonRequest
-     * @param silentRequest
-     */
-    acquireTokenByRefreshToken(commonRequest, // eslint-disable-line @typescript-eslint/no-unused-vars
-    silentRequest // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    /**
-     * Adds event callbacks to array
-     * @param callback
-     */
-    addEventCallback(callback) {
-        return this.eventHandler.addEventCallback(callback);
-    }
-    /**
-     * Removes callback with provided id from callback array
-     * @param callbackId
-     */
-    removeEventCallback(callbackId) {
-        this.eventHandler.removeEventCallback(callbackId);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    addPerformanceCallback(callback) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    removePerformanceCallback(callbackId) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    enableAccountStorageEvents() {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    disableAccountStorageEvents() {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    // #region Account APIs
-    /**
-     * Returns all the accounts in the cache that match the optional filter. If no filter is provided, all accounts are returned.
-     * @param accountFilter - (Optional) filter to narrow down the accounts returned
-     * @returns Array of AccountInfo objects in cache
-     */
-    getAllAccounts(accountFilter) {
-        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnv(), accountFilter);
-    }
-    /**
-     * Returns the first account found in the cache that matches the account filter passed in.
-     * @param accountFilter
-     * @returns The first account found in the cache matching the provided filter or null if no account could be found.
-     */
-    getAccount(accountFilter) {
-        return getAccount(accountFilter, this.logger, this.browserStorage);
-    }
-    /**
-     * Returns the signed in account matching username.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found.
-     * This API is provided for convenience but getAccountById should be used for best reliability
-     * @param username
-     * @returns The account object stored in MSAL
-     */
-    getAccountByUsername(username) {
-        return getAccountByUsername(username, this.logger, this.browserStorage);
-    }
-    /**
-     * Returns the signed in account matching homeAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param homeAccountId
-     * @returns The account object stored in MSAL
-     */
-    getAccountByHomeId(homeAccountId) {
-        return getAccountByHomeId(homeAccountId, this.logger, this.browserStorage);
-    }
-    /**
-     * Returns the signed in account matching localAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param localAccountId
-     * @returns The account object stored in MSAL
-     */
-    getAccountByLocalId(localAccountId) {
-        return getAccountByLocalId(localAccountId, this.logger, this.browserStorage);
-    }
-    /**
-     * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
-     * @param account
-     */
-    setActiveAccount(account) {
-        /*
-         * StandardController uses this to allow the developer to set the active account
-         * in the nested app auth scenario the active account is controlled by the app hosting the nested app
-         */
-        return setActiveAccount(account, this.browserStorage);
-    }
-    /**
-     * Gets the currently active account
-     */
-    getActiveAccount() {
-        return getActiveAccount(this.browserStorage);
-    }
-    // #endregion
-    handleRedirectPromise(hash // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        return Promise.resolve(null);
-    }
-    loginPopup(request // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        return this.acquireTokenInteractive(request || DEFAULT_REQUEST);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    loginRedirect(request) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    logout(logoutRequest) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    logoutRedirect(logoutRequest // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    logoutPopup(logoutRequest // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    ssoSilent(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    request) {
-        return this.acquireTokenSilentInternal(request);
-    }
-    getTokenCache() {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    /**
-     * Returns the logger instance
-     */
-    getLogger() {
-        return this.logger;
-    }
-    /**
-     * Replaces the default logger set in configurations with new Logger with new configurations
-     * @param logger Logger instance
-     */
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    initializeWrapperLibrary(sku, version) {
-        /*
-         * Standard controller uses this to set the sku and version of the wrapper library in the storage
-         * we do nothing here
-         */
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    setNavigationClient(navigationClient) {
-        this.logger.warning("setNavigationClient is not supported in nested app auth");
-    }
-    getConfiguration() {
-        return this.config;
-    }
-    isBrowserEnv() {
-        return this.operatingContext.isBrowserEnvironment();
-    }
-    getBrowserCrypto() {
-        return this.browserCrypto;
-    }
-    getPerformanceClient() {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    getRedirectResponse() {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async clearCache(logoutRequest) {
-        throw NestedAppAuthError.createUnsupportedError();
-    }
-    async hydrateCache(result, request) {
-        this.logger.verbose("hydrateCache called");
-        const accountEntity = AccountEntity.createFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
-        this.browserStorage.setAccount(accountEntity);
-        return this.browserStorage.hydrateCache(result, request);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class NestedAppAuthController {
+    constructor(operatingContext) {
+        this.operatingContext = operatingContext;
+        const proxy = this.operatingContext.getBridgeProxy();
+        if (proxy !== undefined) {
+            this.bridgeProxy = proxy;
+        }
+        else {
+            throw new Error("unexpected: bridgeProxy is undefined");
+        }
+        // Set the configuration.
+        this.config = operatingContext.getConfig();
+        // Initialize logger
+        this.logger = this.operatingContext.getLogger();
+        // Initialize performance client
+        this.performanceClient = this.config.telemetry.client;
+        // Initialize the crypto class.
+        this.browserCrypto = operatingContext.isBrowserEnvironment()
+            ? new CryptoOps(this.logger, this.performanceClient)
+            : DEFAULT_CRYPTO_IMPLEMENTATION;
+        // Initialize the browser storage class.
+        this.browserStorage = this.operatingContext.isBrowserEnvironment()
+            ? new BrowserCacheManager(this.config.auth.clientId, this.config.cache, this.browserCrypto, this.logger, buildStaticAuthorityOptions(this.config.auth))
+            : DEFAULT_BROWSER_CACHE_MANAGER(this.config.auth.clientId, this.logger);
+        this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
+        this.nestedAppAuthAdapter = new NestedAppAuthAdapter(this.config.auth.clientId, this.config.auth.clientCapabilities, this.browserCrypto, this.logger);
+        // Set the active account if available
+        const accountContext = this.bridgeProxy.getAccountContext();
+        if (accountContext) {
+            const cachedAccount = getAccount(accountContext, this.logger, this.browserStorage);
+            setActiveAccount(cachedAccount, this.browserStorage);
+        }
+    }
+    /**
+     * Returns the event handler instance
+     * @returns EventHandler
+     */
+    getEventHandler() {
+        return this.eventHandler;
+    }
+    /**
+     * Factory function to create a new instance of NestedAppAuthController
+     * @param operatingContext
+     * @returns Promise<IController>
+     */
+    static async createController(operatingContext) {
+        const controller = new NestedAppAuthController(operatingContext);
+        return Promise.resolve(controller);
+    }
+    /**
+     * Specific implementation of initialize function for NestedAppAuthController
+     * @returns
+     */
+    initialize() {
+        // do nothing not required by this controller
+        return Promise.resolve();
+    }
+    /**
+     * Validate the incoming request and add correlationId if not present
+     * @param request
+     * @returns
+     */
+    ensureValidRequest(request) {
+        if (request?.correlationId) {
+            return request;
+        }
+        return {
+            ...request,
+            correlationId: this.browserCrypto.createNewGuid(),
+        };
+    }
+    /**
+     * Internal implementation of acquireTokenInteractive flow
+     * @param request
+     * @returns
+     */
+    async acquireTokenInteractive(request) {
+        const validRequest = this.ensureValidRequest(request);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Popup, validRequest);
+        const atPopupMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPopup, validRequest.correlationId);
+        atPopupMeasurement?.add({ nestedAppAuthRequest: true });
+        try {
+            const naaRequest = this.nestedAppAuthAdapter.toNaaTokenRequest(validRequest);
+            const reqTimestamp = TimeUtils.nowSeconds();
+            const response = await this.bridgeProxy.getTokenInteractive(naaRequest);
+            const result = this.nestedAppAuthAdapter.fromNaaTokenResponse(naaRequest, response, reqTimestamp);
+            // cache the tokens in the response
+            await this.hydrateCache(result, request);
+            this.browserStorage.setActiveAccount(result.account);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
+            atPopupMeasurement.add({
+                accessTokenSize: result.accessToken.length,
+                idTokenSize: result.idToken.length,
+            });
+            atPopupMeasurement.end({
+                success: true,
+                requestId: result.requestId,
+            });
+            return result;
+        }
+        catch (e) {
+            const error = this.nestedAppAuthAdapter.fromBridgeError(e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Popup, null, e);
+            atPopupMeasurement.end({
+                success: false,
+            }, e);
+            throw error;
+        }
+    }
+    /**
+     * Internal implementation of acquireTokenSilent flow
+     * @param request
+     * @returns
+     */
+    async acquireTokenSilentInternal(request) {
+        const validRequest = this.ensureValidRequest(request);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, validRequest);
+        // Look for tokens in the cache first
+        const result = await this.acquireTokenFromCache(validRequest);
+        if (result) {
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
+            return result;
+        }
+        // proceed with acquiring tokens via the host
+        const ssoSilentMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SsoSilent, validRequest.correlationId);
+        ssoSilentMeasurement?.increment({
+            visibilityChangeCount: 0,
+        });
+        ssoSilentMeasurement?.add({
+            nestedAppAuthRequest: true,
+        });
+        try {
+            const naaRequest = this.nestedAppAuthAdapter.toNaaTokenRequest(validRequest);
+            const reqTimestamp = TimeUtils.nowSeconds();
+            const response = await this.bridgeProxy.getTokenSilent(naaRequest);
+            const result = this.nestedAppAuthAdapter.fromNaaTokenResponse(naaRequest, response, reqTimestamp);
+            // cache the tokens in the response
+            await this.hydrateCache(result, request);
+            this.browserStorage.setActiveAccount(result.account);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
+            ssoSilentMeasurement?.add({
+                accessTokenSize: result.accessToken.length,
+                idTokenSize: result.idToken.length,
+            });
+            ssoSilentMeasurement?.end({
+                success: true,
+                requestId: result.requestId,
+            });
+            return result;
+        }
+        catch (e) {
+            const error = this.nestedAppAuthAdapter.fromBridgeError(e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, e);
+            ssoSilentMeasurement?.end({
+                success: false,
+            }, e);
+            throw error;
+        }
+    }
+    /**
+     * acquires tokens from cache
+     * @param request
+     * @returns
+     */
+    async acquireTokenFromCache(request) {
+        const atsMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenSilent, request.correlationId);
+        atsMeasurement?.add({
+            nestedAppAuthRequest: true,
+        });
+        const result = await this.acquireTokenFromCacheInternal(request);
+        if (result) {
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, result);
+            atsMeasurement?.add({
+                accessTokenSize: result?.accessToken.length,
+                idTokenSize: result?.idToken.length,
+            });
+            atsMeasurement?.end({
+                success: true,
+            });
+            return result;
+        }
+        this.logger.error("Cached tokens are not found for the account, proceeding with silent token request.");
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null);
+        atsMeasurement?.end({
+            success: false,
+        });
+        return null;
+    }
+    /**
+     *
+     * @param request
+     * @returns
+     */
+    async acquireTokenFromCacheInternal(request) {
+        const accountContext = this.bridgeProxy.getAccountContext();
+        let currentAccount = null;
+        if (accountContext) {
+            const hubAccount = getAccount(accountContext, this.logger, this.browserStorage);
+            // always prioritize for hub account context, the reqirement of `request.account` will be removed soon
+            currentAccount = hubAccount || request.account;
+        }
+        // fall back to brokering if no cached account is found
+        if (!currentAccount) {
+            this.logger.verbose("No active account found, falling back to the host");
+            return Promise.resolve(null);
+        }
+        this.logger.verbose("active account found, attempting to acquire token silently");
+        const authRequest = {
+            ...request,
+            correlationId: request.correlationId || this.browserCrypto.createNewGuid(),
+            authority: request.authority || currentAccount.environment,
+            scopes: request.scopes?.length
+                ? request.scopes
+                : [...OIDC_DEFAULT_SCOPES],
+        };
+        // fetch access token and check for expiry
+        const tokenKeys = this.browserStorage.getTokenKeys();
+        const cachedAccessToken = this.browserStorage.getAccessToken(currentAccount, authRequest, tokenKeys, currentAccount.tenantId, this.performanceClient, authRequest.correlationId);
+        // If there is no access token, log it and return null
+        if (!cachedAccessToken) {
+            this.logger.verbose("No cached access token found");
+            return Promise.resolve(null);
+            // If access token has expired, remove the token from cache and return null
+        }
+        else if (TimeUtils.wasClockTurnedBack(cachedAccessToken.cachedAt) ||
+            TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.system.tokenRenewalOffsetSeconds)) {
+            this.logger.verbose("Cached access token has expired, deleting all related tokens from cache");
+            const accountEntity = AccountEntity.createFromAccountInfo(currentAccount);
+            await this.browserStorage.removeAccountContext(accountEntity);
+            return Promise.resolve(null);
+        }
+        const cachedIdToken = this.browserStorage.getIdToken(currentAccount, tokenKeys, currentAccount.tenantId, this.performanceClient, authRequest.correlationId);
+        if (!cachedIdToken) {
+            this.logger.verbose("No cached id token found");
+            return Promise.resolve(null);
+        }
+        return this.nestedAppAuthAdapter.toAuthenticationResultFromCache(currentAccount, cachedIdToken, cachedAccessToken, authRequest, authRequest.correlationId);
+    }
+    /**
+     * acquireTokenPopup flow implementation
+     * @param request
+     * @returns
+     */
+    async acquireTokenPopup(request) {
+        return this.acquireTokenInteractive(request);
+    }
+    /**
+     * acquireTokenRedirect flow is not supported in nested app auth
+     * @param request
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    acquireTokenRedirect(request) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    /**
+     * acquireTokenSilent flow implementation
+     * @param silentRequest
+     * @returns
+     */
+    async acquireTokenSilent(silentRequest) {
+        return this.acquireTokenSilentInternal(silentRequest);
+    }
+    /**
+     * Hybrid flow is not currently supported in nested app auth
+     * @param request
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    acquireTokenByCode(request // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    /**
+     * acquireTokenNative flow is not currently supported in nested app auth
+     * @param request
+     * @param apiId
+     * @param accountId
+     */
+    acquireTokenNative(request, apiId, // eslint-disable-line @typescript-eslint/no-unused-vars
+    accountId // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    /**
+     * acquireTokenByRefreshToken flow is not currently supported in nested app auth
+     * @param commonRequest
+     * @param silentRequest
+     */
+    acquireTokenByRefreshToken(commonRequest, // eslint-disable-line @typescript-eslint/no-unused-vars
+    silentRequest // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    /**
+     * Adds event callbacks to array
+     * @param callback
+     */
+    addEventCallback(callback) {
+        return this.eventHandler.addEventCallback(callback);
+    }
+    /**
+     * Removes callback with provided id from callback array
+     * @param callbackId
+     */
+    removeEventCallback(callbackId) {
+        this.eventHandler.removeEventCallback(callbackId);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    addPerformanceCallback(callback) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    removePerformanceCallback(callbackId) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    enableAccountStorageEvents() {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    disableAccountStorageEvents() {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    // #region Account APIs
+    /**
+     * Returns all the accounts in the cache that match the optional filter. If no filter is provided, all accounts are returned.
+     * @param accountFilter - (Optional) filter to narrow down the accounts returned
+     * @returns Array of AccountInfo objects in cache
+     */
+    getAllAccounts(accountFilter) {
+        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnv(), accountFilter);
+    }
+    /**
+     * Returns the first account found in the cache that matches the account filter passed in.
+     * @param accountFilter
+     * @returns The first account found in the cache matching the provided filter or null if no account could be found.
+     */
+    getAccount(accountFilter) {
+        return getAccount(accountFilter, this.logger, this.browserStorage);
+    }
+    /**
+     * Returns the signed in account matching username.
+     * (the account object is created at the time of successful login)
+     * or null when no matching account is found.
+     * This API is provided for convenience but getAccountById should be used for best reliability
+     * @param username
+     * @returns The account object stored in MSAL
+     */
+    getAccountByUsername(username) {
+        return getAccountByUsername(username, this.logger, this.browserStorage);
+    }
+    /**
+     * Returns the signed in account matching homeAccountId.
+     * (the account object is created at the time of successful login)
+     * or null when no matching account is found
+     * @param homeAccountId
+     * @returns The account object stored in MSAL
+     */
+    getAccountByHomeId(homeAccountId) {
+        return getAccountByHomeId(homeAccountId, this.logger, this.browserStorage);
+    }
+    /**
+     * Returns the signed in account matching localAccountId.
+     * (the account object is created at the time of successful login)
+     * or null when no matching account is found
+     * @param localAccountId
+     * @returns The account object stored in MSAL
+     */
+    getAccountByLocalId(localAccountId) {
+        return getAccountByLocalId(localAccountId, this.logger, this.browserStorage);
+    }
+    /**
+     * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
+     * @param account
+     */
+    setActiveAccount(account) {
+        /*
+         * StandardController uses this to allow the developer to set the active account
+         * in the nested app auth scenario the active account is controlled by the app hosting the nested app
+         */
+        return setActiveAccount(account, this.browserStorage);
+    }
+    /**
+     * Gets the currently active account
+     */
+    getActiveAccount() {
+        return getActiveAccount(this.browserStorage);
+    }
+    // #endregion
+    handleRedirectPromise(hash // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        return Promise.resolve(null);
+    }
+    loginPopup(request // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        return this.acquireTokenInteractive(request || DEFAULT_REQUEST);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    loginRedirect(request) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    logout(logoutRequest) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    logoutRedirect(logoutRequest // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    logoutPopup(logoutRequest // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    ssoSilent(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    request) {
+        return this.acquireTokenSilentInternal(request);
+    }
+    getTokenCache() {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    /**
+     * Returns the logger instance
+     */
+    getLogger() {
+        return this.logger;
+    }
+    /**
+     * Replaces the default logger set in configurations with new Logger with new configurations
+     * @param logger Logger instance
+     */
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    initializeWrapperLibrary(sku, version) {
+        /*
+         * Standard controller uses this to set the sku and version of the wrapper library in the storage
+         * we do nothing here
+         */
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    setNavigationClient(navigationClient) {
+        this.logger.warning("setNavigationClient is not supported in nested app auth");
+    }
+    getConfiguration() {
+        return this.config;
+    }
+    isBrowserEnv() {
+        return this.operatingContext.isBrowserEnvironment();
+    }
+    getBrowserCrypto() {
+        return this.browserCrypto;
+    }
+    getPerformanceClient() {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    getRedirectResponse() {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async clearCache(logoutRequest) {
+        throw NestedAppAuthError.createUnsupportedError();
+    }
+    async hydrateCache(result, request) {
+        this.logger.verbose("hydrateCache called");
+        const accountEntity = AccountEntity.createFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
+        this.browserStorage.setAccount(accountEntity);
+        return this.browserStorage.hydrateCache(result, request);
+    }
 }
 
 export { NestedAppAuthController };