@azure/msal-browser 3.27.0 → 4.0.0-alpha.0

package/dist/cache/BrowserCacheManager.mjs

@@ -1,13 +1,16 @@
-/*! @azure/msal-browser v3.27.0 2024-11-05 */
+/*! @azure/msal-browser v4.0.0-alpha.0 2024-12-18 */
 'use strict';
-import { CacheManager, CredentialType, CacheHelpers, AccountEntity, createClientAuthError, ClientAuthErrorCodes, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, AuthToken, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
+import { CacheManager, AccountEntity, CredentialType, createClientAuthError, ClientAuthErrorCodes, CacheHelpers, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { BrowserCacheLocation, StaticCacheKeys, InMemoryCacheKeys, TemporaryCacheKeys } from '../utils/BrowserConstants.mjs';
-import { BrowserStorage } from './BrowserStorage.mjs';
+import { LocalStorage } from './LocalStorage.mjs';
+import { SessionStorage } from './SessionStorage.mjs';
 import { MemoryStorage } from './MemoryStorage.mjs';
 import { extractBrowserRequestState } from '../utils/BrowserProtocolUtils.mjs';
 import { base64Decode } from '../encode/Base64Decode.mjs';
 import { base64Encode } from '../encode/Base64Encode.mjs';
+import { CookieStorage } from './CookieStorage.mjs';
+import { getAccountKeys, getTokenKeys } from './CacheHelpers.mjs';
 import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCachedAuthorityError, interactionInProgress } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
@@ -22,179 +25,39 @@ import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCached
 class BrowserCacheManager extends CacheManager {
     constructor(clientId, cacheConfig, cryptoImpl, logger, staticAuthorityOptions, performanceClient) {
         super(clientId, cryptoImpl, logger, staticAuthorityOptions);
-        // Cookie life calculation (hours * minutes * seconds * ms)
-        this.COOKIE_LIFE_MULTIPLIER = 24 * 60 * 60 * 1000;
         this.cacheConfig = cacheConfig;
         this.logger = logger;
         this.internalStorage = new MemoryStorage();
         this.browserStorage = this.setupBrowserStorage(this.cacheConfig.cacheLocation);
-        this.temporaryCacheStorage = this.setupTemporaryCacheStorage(this.cacheConfig.temporaryCacheLocation, this.cacheConfig.cacheLocation);
-        // Migrate cache entries from older versions of MSAL.
-        if (cacheConfig.cacheMigrationEnabled) {
-            this.migrateCacheEntries();
-            this.createKeyMaps();
-        }
+        this.temporaryCacheStorage = this.setupBrowserStorage(this.cacheConfig.temporaryCacheLocation);
+        this.cookieStorage = new CookieStorage();
         this.performanceClient = performanceClient;
     }
+    async initialize() {
+        await this.browserStorage.initialize();
+    }
     /**
      * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured cacheLocation.
      * @param cacheLocation
      */
     setupBrowserStorage(cacheLocation) {
-        switch (cacheLocation) {
-            case BrowserCacheLocation.LocalStorage:
-            case BrowserCacheLocation.SessionStorage:
-                try {
-                    return new BrowserStorage(cacheLocation);
-                }
-                catch (e) {
-                    this.logger.verbose(e);
+        try {
+            switch (cacheLocation) {
+                case BrowserCacheLocation.LocalStorage:
+                    return new LocalStorage(this.clientId);
+                case BrowserCacheLocation.SessionStorage:
+                    return new SessionStorage();
+                case BrowserCacheLocation.MemoryStorage:
+                default:
                     break;
-                }
+            }
+        }
+        catch (e) {
+            this.logger.error(e);
         }
         this.cacheConfig.cacheLocation = BrowserCacheLocation.MemoryStorage;
         return new MemoryStorage();
     }
-    /**
-     * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured temporaryCacheLocation.
-     * @param temporaryCacheLocation
-     * @param cacheLocation
-     */
-    setupTemporaryCacheStorage(temporaryCacheLocation, cacheLocation) {
-        switch (cacheLocation) {
-            case BrowserCacheLocation.LocalStorage:
-            case BrowserCacheLocation.SessionStorage:
-                try {
-                    // Temporary cache items will always be stored in session storage to mitigate problems caused by multiple tabs
-                    return new BrowserStorage(temporaryCacheLocation ||
-                        BrowserCacheLocation.SessionStorage);
-                }
-                catch (e) {
-                    this.logger.verbose(e);
-                    return this.internalStorage;
-                }
-            case BrowserCacheLocation.MemoryStorage:
-            default:
-                return this.internalStorage;
-        }
-    }
-    /**
-     * Migrate all old cache entries to new schema. No rollback supported.
-     * @param storeAuthStateInCookie
-     */
-    migrateCacheEntries() {
-        const idTokenKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ID_TOKEN}`;
-        const clientInfoKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.CLIENT_INFO}`;
-        const errorKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ERROR}`;
-        const errorDescKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ERROR_DESC}`;
-        const idTokenValue = this.browserStorage.getItem(idTokenKey);
-        const clientInfoValue = this.browserStorage.getItem(clientInfoKey);
-        const errorValue = this.browserStorage.getItem(errorKey);
-        const errorDescValue = this.browserStorage.getItem(errorDescKey);
-        const values = [
-            idTokenValue,
-            clientInfoValue,
-            errorValue,
-            errorDescValue,
-        ];
-        const keysToMigrate = [
-            PersistentCacheKeys.ID_TOKEN,
-            PersistentCacheKeys.CLIENT_INFO,
-            PersistentCacheKeys.ERROR,
-            PersistentCacheKeys.ERROR_DESC,
-        ];
-        keysToMigrate.forEach((cacheKey, index) => {
-            const value = values[index];
-            if (value) {
-                this.setTemporaryCache(cacheKey, value, true);
-            }
-        });
-    }
-    /**
-     * Searches all cache entries for MSAL accounts and creates the account key map
-     * This is used to migrate users from older versions of MSAL which did not create the map.
-     * @returns
-     */
-    createKeyMaps() {
-        this.logger.trace("BrowserCacheManager - createKeyMaps called.");
-        const accountKeys = this.getItem(StaticCacheKeys.ACCOUNT_KEYS);
-        const tokenKeys = this.getItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
-        if (accountKeys && tokenKeys) {
-            this.logger.verbose("BrowserCacheManager:createKeyMaps - account and token key maps already exist, skipping migration.");
-            // Key maps already exist, no need to iterate through cache
-            return;
-        }
-        const allKeys = this.browserStorage.getKeys();
-        allKeys.forEach((key) => {
-            if (this.isCredentialKey(key)) {
-                // Get item, parse, validate and write key to map
-                const value = this.getItem(key);
-                if (value) {
-                    const credObj = this.validateAndParseJson(value);
-                    if (credObj && credObj.hasOwnProperty("credentialType")) {
-                        switch (credObj["credentialType"]) {
-                            case CredentialType.ID_TOKEN:
-                                if (CacheHelpers.isIdTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - idToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - idToken with key: ${key} found, saving key to token key map`);
-                                    const idTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, idTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ID_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching idToken schema with value containing idToken credentialType field but value failed IdTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed idToken validation on key: ${key}`);
-                                }
-                                break;
-                            case CredentialType.ACCESS_TOKEN:
-                            case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
-                                if (CacheHelpers.isAccessTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - accessToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - accessToken with key: ${key} found, saving key to token key map`);
-                                    const accessTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, accessTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ACCESS_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching accessToken schema with value containing accessToken credentialType field but value failed AccessTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed accessToken validation on key: ${key}`);
-                                }
-                                break;
-                            case CredentialType.REFRESH_TOKEN:
-                                if (CacheHelpers.isRefreshTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - refreshToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - refreshToken with key: ${key} found, saving key to token key map`);
-                                    const refreshTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, refreshTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.REFRESH_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching refreshToken schema with value containing refreshToken credentialType field but value failed RefreshTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed refreshToken validation on key: ${key}`);
-                                }
-                                break;
-                            // If credentialType isn't one of our predefined ones, it may not be an MSAL cache value. Ignore.
-                        }
-                    }
-                }
-            }
-            if (this.isAccountKey(key)) {
-                const value = this.getItem(key);
-                if (value) {
-                    const accountObj = this.validateAndParseJson(value);
-                    if (accountObj &&
-                        AccountEntity.isAccountEntity(accountObj)) {
-                        this.logger.trace("BrowserCacheManager:createKeyMaps - account found, saving key to account key map");
-                        this.logger.tracePii(`BrowserCacheManager:createKeyMaps - account with key: ${key} found, saving key to account key map`);
-                        this.addAccountKeyToMap(key);
-                    }
-                }
-            }
-        });
-    }
     /**
      * Parses passed value as JSON object, JSON.parse() will throw an error.
      * @param input
@@ -216,38 +79,15 @@ class BrowserCacheManager extends CacheManager {
             return null;
         }
     }
-    /**
-     * fetches the entry from the browser storage based off the key
-     * @param key
-     */
-    getItem(key) {
-        return this.browserStorage.getItem(key);
-    }
-    /**
-     * sets the entry in the browser storage
-     * @param key
-     * @param value
-     */
-    setItem(key, value) {
-        this.browserStorage.setItem(key, value);
-    }
-    /**
-     * fetch the account entity from the platform cache
-     * @param accountKey
-     */
-    getAccount(accountKey, logger) {
-        this.logger.trace("BrowserCacheManager.getAccount called");
-        const accountEntity = this.getCachedAccountEntity(accountKey);
-        return this.updateOutdatedCachedAccount(accountKey, accountEntity, logger);
-    }
     /**
      * Reads account from cache, deserializes it into an account entity and returns it.
      * If account is not found from the key, returns null and removes key from map.
      * @param accountKey
      * @returns
      */
-    getCachedAccountEntity(accountKey) {
-        const serializedAccount = this.getItem(accountKey);
+    getAccount(accountKey) {
+        this.logger.trace("BrowserCacheManager.getAccount called");
+        const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey);
             return null;
@@ -263,10 +103,10 @@ class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    setAccount(account) {
+    async setAccount(account) {
         this.logger.trace("BrowserCacheManager.setAccount called");
         const key = account.generateAccountKey();
-        this.setItem(key, JSON.stringify(account));
+        await this.browserStorage.setUserData(key, JSON.stringify(account));
         this.addAccountKeyToMap(key);
     }
     /**
@@ -274,13 +114,7 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getAccountKeys() {
-        this.logger.trace("BrowserCacheManager.getAccountKeys called");
-        const accountKeys = this.getItem(StaticCacheKeys.ACCOUNT_KEYS);
-        if (accountKeys) {
-            return JSON.parse(accountKeys);
-        }
-        this.logger.verbose("BrowserCacheManager.getAccountKeys - No account keys found");
-        return [];
+        return getAccountKeys(this.browserStorage);
     }
     /**
      * Add a new account to the key map
@@ -293,7 +127,7 @@ class BrowserCacheManager extends CacheManager {
         if (accountKeys.indexOf(key) === -1) {
             // Only add key if it does not already exist in the map
             accountKeys.push(key);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.browserStorage.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
             this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
         }
         else {
@@ -311,7 +145,7 @@ class BrowserCacheManager extends CacheManager {
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.browserStorage.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
             this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed");
         }
         else {
@@ -326,14 +160,6 @@ class BrowserCacheManager extends CacheManager {
         void super.removeAccount(key);
         this.removeAccountKeyFromMap(key);
     }
-    /**
-     * Remove account entity from the platform cache if it's outdated
-     * @param accountKey
-     */
-    removeOutdatedAccount(accountKey) {
-        this.removeItem(accountKey);
-        this.removeAccountKeyFromMap(accountKey);
-    }
     /**
      * Removes given idToken from the cache and from the key map
      * @param key
@@ -363,28 +189,7 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getTokenKeys() {
-        this.logger.trace("BrowserCacheManager.getTokenKeys called");
-        const item = this.getItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
-        if (item) {
-            const tokenKeys = this.validateAndParseJson(item);
-            if (tokenKeys &&
-                tokenKeys.hasOwnProperty("idToken") &&
-                tokenKeys.hasOwnProperty("accessToken") &&
-                tokenKeys.hasOwnProperty("refreshToken")) {
-                return tokenKeys;
-            }
-            else {
-                this.logger.error("BrowserCacheManager.getTokenKeys - Token keys found but in an unknown format. Returning empty key map.");
-            }
-        }
-        else {
-            this.logger.verbose("BrowserCacheManager.getTokenKeys - No token keys found");
-        }
-        return {
-            idToken: [],
-            accessToken: [],
-            refreshToken: [],
-        };
+        return getTokenKeys(this.clientId, this.browserStorage);
     }
     /**
      * Adds the given key to the token key map
@@ -417,7 +222,7 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:addTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
     }
     /**
      * Removes the given key from the token key map
@@ -465,14 +270,14 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:removeTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
     }
     /**
      * generates idToken entity from a string
      * @param idTokenKey
      */
     getIdTokenCredential(idTokenKey) {
-        const value = this.getItem(idTokenKey);
+        const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
             this.removeTokenKey(idTokenKey, CredentialType.ID_TOKEN);
@@ -491,10 +296,10 @@ class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    setIdTokenCredential(idToken) {
+    async setIdTokenCredential(idToken) {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
-        this.setItem(idTokenKey, JSON.stringify(idToken));
+        await this.browserStorage.setUserData(idTokenKey, JSON.stringify(idToken));
         this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN);
     }
     /**
@@ -502,7 +307,7 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      */
     getAccessTokenCredential(accessTokenKey) {
-        const value = this.getItem(accessTokenKey);
+        const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
             this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
@@ -522,10 +327,10 @@ class BrowserCacheManager extends CacheManager {
      * set accessToken credential to the platform cache
      * @param accessToken
      */
-    setAccessTokenCredential(accessToken) {
+    async setAccessTokenCredential(accessToken) {
         this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        this.setItem(accessTokenKey, JSON.stringify(accessToken));
+        await this.browserStorage.setUserData(accessTokenKey, JSON.stringify(accessToken));
         this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
     }
     /**
@@ -533,7 +338,7 @@ class BrowserCacheManager extends CacheManager {
      * @param refreshTokenKey
      */
     getRefreshTokenCredential(refreshTokenKey) {
-        const value = this.getItem(refreshTokenKey);
+        const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
             this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
@@ -553,10 +358,10 @@ class BrowserCacheManager extends CacheManager {
      * set refreshToken credential to the platform cache
      * @param refreshToken
      */
-    setRefreshTokenCredential(refreshToken) {
+    async setRefreshTokenCredential(refreshToken) {
         this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
         const refreshTokenKey = CacheHelpers.generateCredentialKey(refreshToken);
-        this.setItem(refreshTokenKey, JSON.stringify(refreshToken));
+        await this.browserStorage.setUserData(refreshTokenKey, JSON.stringify(refreshToken));
         this.addTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
     }
     /**
@@ -564,7 +369,7 @@ class BrowserCacheManager extends CacheManager {
      * @param appMetadataKey
      */
     getAppMetadata(appMetadataKey) {
-        const value = this.getItem(appMetadataKey);
+        const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
             return null;
@@ -585,14 +390,14 @@ class BrowserCacheManager extends CacheManager {
     setAppMetadata(appMetadata) {
         this.logger.trace("BrowserCacheManager.setAppMetadata called");
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
-        this.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.browserStorage.setItem(appMetadataKey, JSON.stringify(appMetadata));
     }
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
      */
     getServerTelemetry(serverTelemetryKey) {
-        const value = this.getItem(serverTelemetryKey);
+        const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
             return null;
@@ -613,7 +418,7 @@ class BrowserCacheManager extends CacheManager {
      */
     setServerTelemetry(serverTelemetryKey, serverTelemetry) {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.browserStorage.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
     }
     /**
      *
@@ -673,25 +478,9 @@ class BrowserCacheManager extends CacheManager {
      */
     getActiveAccount() {
         const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
-        const activeAccountValueFilters = this.getItem(activeAccountKeyFilters);
+        const activeAccountValueFilters = this.browserStorage.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
-            // if new active account cache type isn't found, it's an old version, so look for that instead
-            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters cache schema found, looking for legacy schema");
-            const activeAccountKeyLocal = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT);
-            const activeAccountValueLocal = this.getItem(activeAccountKeyLocal);
-            if (!activeAccountValueLocal) {
-                this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found");
-                return null;
-            }
-            const activeAccount = this.getAccountInfoFilteredBy({
-                localAccountId: activeAccountValueLocal,
-            });
-            if (activeAccount) {
-                this.logger.trace("BrowserCacheManager.getActiveAccount: Legacy active account cache schema found");
-                this.logger.trace("BrowserCacheManager.getActiveAccount: Adding active account filters cache schema");
-                this.setActiveAccount(activeAccount);
-                return activeAccount;
-            }
+            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters found");
             return null;
         }
         const activeAccountValueObj = this.validateAndParseJson(activeAccountValueFilters);
@@ -712,7 +501,6 @@ class BrowserCacheManager extends CacheManager {
      */
     setActiveAccount(account) {
         const activeAccountKey = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
-        const activeAccountKeyLocal = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT);
         if (account) {
             this.logger.verbose("setActiveAccount: Active account set");
             const activeAccountValue = {
@@ -721,12 +509,10 @@ class BrowserCacheManager extends CacheManager {
                 tenantId: account.tenantId,
             };
             this.browserStorage.setItem(activeAccountKey, JSON.stringify(activeAccountValue));
-            this.browserStorage.setItem(activeAccountKeyLocal, account.localAccountId);
         }
         else {
             this.logger.verbose("setActiveAccount: No account passed, active account not set");
             this.browserStorage.removeItem(activeAccountKey);
-            this.browserStorage.removeItem(activeAccountKeyLocal);
         }
     }
     /**
@@ -734,7 +520,7 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCacheKey
      */
     getThrottlingCache(throttlingCacheKey) {
-        const value = this.getItem(throttlingCacheKey);
+        const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
             return null;
@@ -755,7 +541,7 @@ class BrowserCacheManager extends CacheManager {
      */
     setThrottlingCache(throttlingCacheKey, throttlingCache) {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.browserStorage.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
     }
     /**
      * Gets cache item with given key.
@@ -765,7 +551,7 @@ class BrowserCacheManager extends CacheManager {
     getTemporaryCache(cacheKey, generateKey) {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
         if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.getItemCookie(key);
+            const itemCookie = this.cookieStorage.getItem(key);
             if (itemCookie) {
                 this.logger.trace("BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies");
                 return itemCookie;
@@ -800,7 +586,7 @@ class BrowserCacheManager extends CacheManager {
         this.temporaryCacheStorage.setItem(key, value);
         if (this.cacheConfig.storeAuthStateInCookie) {
             this.logger.trace("BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie");
-            this.setItemCookie(key, value);
+            this.cookieStorage.setItem(key, value, undefined, this.cacheConfig.secureCookies);
         }
     }
     /**
@@ -819,7 +605,7 @@ class BrowserCacheManager extends CacheManager {
         this.temporaryCacheStorage.removeItem(key);
         if (this.cacheConfig.storeAuthStateInCookie) {
             this.logger.trace("BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie");
-            this.clearItemCookie(key);
+            this.cookieStorage.removeItem(key);
         }
     }
     /**
@@ -875,79 +661,6 @@ class BrowserCacheManager extends CacheManager {
             this.logger.warning(`${removedAccessTokens.length} access tokens with claims in the cache keys have been removed from the cache.`);
         }
     }
-    /**
-     * Add value to cookies
-     * @param cookieName
-     * @param cookieValue
-     * @param expires
-     * @deprecated
-     */
-    setItemCookie(cookieName, cookieValue, expires) {
-        let cookieStr = `${encodeURIComponent(cookieName)}=${encodeURIComponent(cookieValue)};path=/;SameSite=Lax;`;
-        if (expires) {
-            const expireTime = this.getCookieExpirationTime(expires);
-            cookieStr += `expires=${expireTime};`;
-        }
-        if (this.cacheConfig.secureCookies) {
-            cookieStr += "Secure;";
-        }
-        document.cookie = cookieStr;
-    }
-    /**
-     * Get one item by key from cookies
-     * @param cookieName
-     * @deprecated
-     */
-    getItemCookie(cookieName) {
-        const name = `${encodeURIComponent(cookieName)}=`;
-        const cookieList = document.cookie.split(";");
-        for (let i = 0; i < cookieList.length; i++) {
-            let cookie = cookieList[i];
-            while (cookie.charAt(0) === " ") {
-                cookie = cookie.substring(1);
-            }
-            if (cookie.indexOf(name) === 0) {
-                return decodeURIComponent(cookie.substring(name.length, cookie.length));
-            }
-        }
-        return Constants.EMPTY_STRING;
-    }
-    /**
-     * Clear all msal-related cookies currently set in the browser. Should only be used to clear temporary cache items.
-     * @deprecated
-     */
-    clearMsalCookies() {
-        const cookiePrefix = `${Constants.CACHE_PREFIX}.${this.clientId}`;
-        const cookieList = document.cookie.split(";");
-        cookieList.forEach((cookie) => {
-            while (cookie.charAt(0) === " ") {
-                // eslint-disable-next-line no-param-reassign
-                cookie = cookie.substring(1);
-            }
-            if (cookie.indexOf(cookiePrefix) === 0) {
-                const cookieKey = cookie.split("=")[0];
-                this.clearItemCookie(cookieKey);
-            }
-        });
-    }
-    /**
-     * Clear an item in the cookies by key
-     * @param cookieName
-     * @deprecated
-     */
-    clearItemCookie(cookieName) {
-        this.setItemCookie(cookieName, Constants.EMPTY_STRING, -1);
-    }
-    /**
-     * Get cookie expiration time
-     * @param cookieLifeDays
-     * @deprecated
-     */
-    getCookieExpirationTime(cookieLifeDays) {
-        const today = new Date();
-        const expr = new Date(today.getTime() + cookieLifeDays * this.COOKIE_LIFE_MULTIPLIER);
-        return expr.toUTCString();
-    }
     /**
      * Prepend msal.<client-id> to each key; Skip for any JSON object as Key (defined schemas do not need the key appended: AccessToken Keys or the upcoming schema)
      * @param key
@@ -956,8 +669,7 @@ class BrowserCacheManager extends CacheManager {
     generateCacheKey(key) {
         const generatedKey = this.validateAndParseJson(key);
         if (!generatedKey) {
-            if (StringUtils.startsWith(key, Constants.CACHE_PREFIX) ||
-                StringUtils.startsWith(key, PersistentCacheKeys.ADAL_ID_TOKEN)) {
+            if (StringUtils.startsWith(key, Constants.CACHE_PREFIX)) {
                 return key;
             }
             return `${Constants.CACHE_PREFIX}.${this.clientId}.${key}`;
@@ -1071,7 +783,6 @@ class BrowserCacheManager extends CacheManager {
             this.logger.infoPii(`BrowserCacheManager.cleanRequestByState: Removing temporary cache items for state: ${cachedState}`);
             this.resetRequestCache(cachedState || Constants.EMPTY_STRING);
         }
-        this.clearMsalCookies();
     }
     /**
      * Looks in temporary cache for any state values with the provided interactionType and removes all temporary cache items for that state
@@ -1099,7 +810,6 @@ class BrowserCacheManager extends CacheManager {
                 this.resetRequestCache(stateValue);
             }
         });
-        this.clearMsalCookies();
         this.setInteractionInProgress(false);
     }
     cacheCodeRequest(authCodeRequest) {
@@ -1185,59 +895,6 @@ class BrowserCacheManager extends CacheManager {
             this.removeTemporaryItem(key);
         }
     }
-    /**
-     * Returns username retrieved from ADAL or MSAL v1 idToken
-     * @deprecated
-     */
-    getLegacyLoginHint() {
-        // Only check for adal/msal token if no SSO params are being used
-        const adalIdTokenString = this.getTemporaryCache(PersistentCacheKeys.ADAL_ID_TOKEN);
-        if (adalIdTokenString) {
-            this.browserStorage.removeItem(PersistentCacheKeys.ADAL_ID_TOKEN);
-            this.logger.verbose("Cached ADAL id token retrieved.");
-        }
-        // Check for cached MSAL v1 id token
-        const msalIdTokenString = this.getTemporaryCache(PersistentCacheKeys.ID_TOKEN, true);
-        if (msalIdTokenString) {
-            this.browserStorage.removeItem(this.generateCacheKey(PersistentCacheKeys.ID_TOKEN));
-            this.logger.verbose("Cached MSAL.js v1 id token retrieved");
-        }
-        const cachedIdTokenString = msalIdTokenString || adalIdTokenString;
-        if (cachedIdTokenString) {
-            const idTokenClaims = AuthToken.extractTokenClaims(cachedIdTokenString, base64Decode);
-            if (idTokenClaims.preferred_username) {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, setting ADAL/MSAL v1 preferred_username as loginHint");
-                return idTokenClaims.preferred_username;
-            }
-            else if (idTokenClaims.upn) {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, setting ADAL/MSAL v1 upn as loginHint");
-                return idTokenClaims.upn;
-            }
-            else {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, however, no account hint claim found. Enable preferred_username or upn id token claim to get SSO.");
-            }
-        }
-        return null;
-    }
-    /**
-     * Updates a credential's cache key if the current cache key is outdated
-     */
-    updateCredentialCacheKey(currentCacheKey, credential) {
-        const updatedCacheKey = CacheHelpers.generateCredentialKey(credential);
-        if (currentCacheKey !== updatedCacheKey) {
-            const cacheItem = this.getItem(currentCacheKey);
-            if (cacheItem) {
-                this.browserStorage.removeItem(currentCacheKey);
-                this.setItem(updatedCacheKey, cacheItem);
-                this.logger.verbose(`Updated an outdated ${credential.credentialType} cache key`);
-                return updatedCacheKey;
-            }
-            else {
-                this.logger.error(`Attempted to update an outdated ${credential.credentialType} cache key but no item matching the outdated key was found in storage`);
-            }
-        }
-        return currentCacheKey;
-    }
     /**
      * Builds credential entities from AuthenticationResult object and saves the resulting credentials to the cache
      * @param result