@azure/msal-browser 2.22.1 → 2.24.0

package/dist/app/ClientApplication.js

@@ -1,11 +1,11 @@
-/*! @azure/msal-browser v2.22.1 2022-03-07 */
+/*! @azure/msal-browser v2.24.0 2022-05-02 */
 'use strict';
-import { __awaiter, __generator } from '../_virtual/_tslib.js';
+import { __awaiter, __generator, __assign } from '../_virtual/_tslib.js';
 import { CryptoOps } from '../crypto/CryptoOps.js';
-import { StringUtils, Logger, DEFAULT_CRYPTO_IMPLEMENTATION, Constants, ServerError, InteractionRequiredAuthError } from '@azure/msal-common';
+import { Constants, PerformanceEvents, PromptValue, StringUtils, Logger, StubPerformanceClient, DEFAULT_CRYPTO_IMPLEMENTATION, ServerError, InteractionRequiredAuthError } from '@azure/msal-common';
 import { BrowserCacheManager, DEFAULT_BROWSER_CACHE_MANAGER } from '../cache/BrowserCacheManager.js';
 import { buildConfiguration } from '../config/Configuration.js';
-import { InteractionType, TemporaryCacheKeys, ApiId, BrowserCacheLocation, BrowserConstants } from '../utils/BrowserConstants.js';
+import { InteractionType, ApiId, TemporaryCacheKeys, BrowserCacheLocation, BrowserConstants } from '../utils/BrowserConstants.js';
 import { BrowserUtils } from '../utils/BrowserUtils.js';
 import { name, version } from '../packageMetadata.js';
 import { EventType } from '../event/EventType.js';
@@ -16,8 +16,13 @@ import { RedirectClient } from '../interaction_client/RedirectClient.js';
 import { SilentIframeClient } from '../interaction_client/SilentIframeClient.js';
 import { SilentRefreshClient } from '../interaction_client/SilentRefreshClient.js';
 import { TokenCache } from '../cache/TokenCache.js';
+import { NativeInteractionClient } from '../interaction_client/NativeInteractionClient.js';
+import { NativeMessageHandler } from '../broker/nativeBroker/NativeMessageHandler.js';
+import { NativeAuthError } from '../error/NativeAuthError.js';
+import { SilentCacheClient } from '../interaction_client/SilentCacheClient.js';
 import { SilentAuthCodeClient } from '../interaction_client/SilentAuthCodeClient.js';
 import { BrowserAuthError } from '../error/BrowserAuthError.js';
+import { BrowserPerformanceClient } from '../telemetry/BrowserPerformanceClient.js';
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -54,6 +59,7 @@ var ClientApplication = /** @class */ (function () {
         this.isBrowserEnvironment = typeof window !== "undefined";
         // Set the configuration.
         this.config = buildConfiguration(configuration, this.isBrowserEnvironment);
+        this.initialized = false;
         // Initialize logger
         this.logger = new Logger(this.config.system.loggerOptions, name, version);
         // Initialize the network module class.
@@ -64,8 +70,12 @@ var ClientApplication = /** @class */ (function () {
         this.redirectResponse = new Map();
         // Initial hybrid spa map
         this.hybridAuthCodeResponses = new Map();
+        // Initialize performance client
+        this.performanceClient = this.isBrowserEnvironment ?
+            new BrowserPerformanceClient(this.config.auth.clientId, this.config.auth.authority, this.logger, name, version, this.config.telemetry.application) :
+            new StubPerformanceClient(this.config.auth.clientId, this.config.auth.authority, this.logger, name, version, this.config.telemetry.application);
         // Initialize the crypto class.
-        this.browserCrypto = this.isBrowserEnvironment ? new CryptoOps(this.logger) : DEFAULT_CRYPTO_IMPLEMENTATION;
+        this.browserCrypto = this.isBrowserEnvironment ? new CryptoOps(this.logger, this.performanceClient) : DEFAULT_CRYPTO_IMPLEMENTATION;
         this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
         // Initialize the browser storage class.
         this.browserStorage = this.isBrowserEnvironment ?
@@ -74,6 +84,42 @@ var ClientApplication = /** @class */ (function () {
         // Initialize the token cache
         this.tokenCache = new TokenCache(this.config, this.browserStorage, this.logger, this.browserCrypto);
     }
+    /**
+     * Initializer function to perform async startup tasks such as connecting to WAM extension
+     */
+    ClientApplication.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.logger.trace("initialize called");
+                        if (this.initialized) {
+                            this.logger.warning("initialize has already been called. This function only needs to be run once.");
+                            return [2 /*return*/];
+                        }
+                        this.eventHandler.emitEvent(EventType.INITIALIZE_START);
+                        if (!this.config.system.allowNativeBroker) return [3 /*break*/, 4];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        _a = this;
+                        return [4 /*yield*/, NativeMessageHandler.createProvider(this.logger, this.config.system.nativeBrokerHandshakeTimeout)];
+                    case 2:
+                        _a.nativeExtensionProvider = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _b.sent();
+                        this.logger.verbose(e_1);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this.initialized = true;
+                        this.eventHandler.emitEvent(EventType.INITIALIZE_END);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     // #region Redirect Flow
     /**
      * Event handler function which allows users to fire events after the PublicClientApplication object
@@ -84,10 +130,12 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.handleRedirectPromise = function (hash) {
         return __awaiter(this, void 0, void 0, function () {
-            var loggedInAccounts, redirectResponseKey, response, correlationId, redirectClient;
+            var loggedInAccounts, redirectResponseKey, response, request, redirectResponse, nativeClient, correlationId, redirectClient;
             var _this = this;
             return __generator(this, function (_a) {
                 this.logger.verbose("handleRedirectPromise called");
+                // Block token acquisition before initialize has been called if native brokering is enabled
+                BrowserUtils.blockNativeBrokerCalledBeforeInitialized(this.config.system.allowNativeBroker, this.initialized);
                 loggedInAccounts = this.getAllAccounts();
                 if (this.isBrowserEnvironment) {
                     redirectResponseKey = hash || Constants.EMPTY_STRING;
@@ -95,10 +143,20 @@ var ClientApplication = /** @class */ (function () {
                     if (typeof response === "undefined") {
                         this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
                         this.logger.verbose("handleRedirectPromise has been called for the first time, storing the promise");
-                        correlationId = this.browserStorage.getTemporaryCache(TemporaryCacheKeys.CORRELATION_ID, true) || "";
-                        redirectClient = new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, correlationId);
-                        response = redirectClient.handleRedirectPromise(hash)
-                            .then(function (result) {
+                        request = this.browserStorage.getCachedNativeRequest();
+                        redirectResponse = void 0;
+                        if (request && NativeMessageHandler.isNativeAvailable(this.config, this.logger, this.nativeExtensionProvider) && this.nativeExtensionProvider && !hash) {
+                            this.logger.trace("handleRedirectPromise - acquiring token from native platform");
+                            nativeClient = new NativeInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.handleRedirectPromise, this.performanceClient, this.nativeExtensionProvider, request.accountId, request.correlationId);
+                            redirectResponse = nativeClient.handleRedirectPromise();
+                        }
+                        else {
+                            this.logger.trace("handleRedirectPromise - acquiring token from web flow");
+                            correlationId = this.browserStorage.getTemporaryCache(TemporaryCacheKeys.CORRELATION_ID, true) || Constants.EMPTY_STRING;
+                            redirectClient = this.createRedirectClient(correlationId);
+                            redirectResponse = redirectClient.handleRedirectPromise(hash);
+                        }
+                        response = redirectResponse.then(function (result) {
                             if (result) {
                                 // Emit login event if number of accounts change
                                 var isLoggingIn = loggedInAccounts.length < _this.getAllAccounts().length;
@@ -113,8 +171,7 @@ var ClientApplication = /** @class */ (function () {
                             }
                             _this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
                             return result;
-                        })
-                            .catch(function (e) {
+                        }).catch(function (e) {
                             // Emit login event if there is an account
                             if (loggedInAccounts.length > 0) {
                                 _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, e);
@@ -148,11 +205,11 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenRedirect = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var isLoggedIn, redirectClient;
+            var correlationId, isLoggedIn, result, nativeClient, redirectClient;
             var _this = this;
             return __generator(this, function (_a) {
-                // Preflight request
-                this.logger.verbose("acquireTokenRedirect called");
+                correlationId = this.getRequestCorrelationId(request);
+                this.logger.verbose("acquireTokenRedirect called", correlationId);
                 this.preflightBrowserEnvironmentCheck(InteractionType.Redirect);
                 isLoggedIn = this.getAllAccounts().length > 0;
                 if (isLoggedIn) {
@@ -161,8 +218,22 @@ var ClientApplication = /** @class */ (function () {
                 else {
                     this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Redirect, request);
                 }
-                redirectClient = new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, request.correlationId);
-                return [2 /*return*/, redirectClient.acquireToken(request).catch(function (e) {
+                if (this.nativeExtensionProvider && this.canUseNative(request)) {
+                    nativeClient = new NativeInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenRedirect, this.performanceClient, this.nativeExtensionProvider, this.getNativeAccountId(request), request.correlationId);
+                    result = nativeClient.acquireTokenRedirect(request).catch(function (e) {
+                        if (e instanceof NativeAuthError && e.isFatal()) {
+                            _this.nativeExtensionProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
+                            var redirectClient = _this.createRedirectClient(request.correlationId);
+                            return redirectClient.acquireToken(request);
+                        }
+                        throw e;
+                    });
+                }
+                else {
+                    redirectClient = this.createRedirectClient(request.correlationId);
+                    result = redirectClient.acquireToken(request);
+                }
+                return [2 /*return*/, result.catch(function (e) {
                         // If logged in, emit acquire token events
                         if (isLoggedIn) {
                             _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, e);
@@ -186,8 +257,10 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenPopup = function (request) {
         var _this = this;
+        var correlationId = this.getRequestCorrelationId(request);
+        var atPopupMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPopup, correlationId);
         try {
-            this.logger.verbose("acquireTokenPopup called", request.correlationId);
+            this.logger.verbose("acquireTokenPopup called", correlationId);
             this.preflightBrowserEnvironmentCheck(InteractionType.Popup);
         }
         catch (e) {
@@ -202,8 +275,30 @@ var ClientApplication = /** @class */ (function () {
         else {
             this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Popup, request);
         }
-        var popupClient = new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, request.correlationId);
-        return popupClient.acquireToken(request).then(function (result) {
+        var result;
+        if (this.canUseNative(request)) {
+            result = this.acquireTokenNative(request, ApiId.acquireTokenPopup).then(function (response) {
+                _this.browserStorage.setInteractionInProgress(false);
+                atPopupMeasurement.endMeasurement({
+                    success: true,
+                    isNativeBroker: true
+                });
+                atPopupMeasurement.flushMeasurement();
+                return response;
+            }).catch(function (e) {
+                if (e instanceof NativeAuthError && e.isFatal()) {
+                    _this.nativeExtensionProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
+                    var popupClient = _this.createPopupClient(request.correlationId);
+                    return popupClient.acquireToken(request);
+                }
+                throw e;
+            });
+        }
+        else {
+            var popupClient = this.createPopupClient(request.correlationId);
+            result = popupClient.acquireToken(request);
+        }
+        return result.then(function (result) {
             // If logged in, emit acquire token events
             var isLoggingIn = loggedInAccounts.length < _this.getAllAccounts().length;
             if (isLoggingIn) {
@@ -212,6 +307,10 @@ var ClientApplication = /** @class */ (function () {
             else {
                 _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
             }
+            atPopupMeasurement.endMeasurement({
+                success: true
+            });
+            atPopupMeasurement.flushMeasurement();
             return result;
         }).catch(function (e) {
             if (loggedInAccounts.length > 0) {
@@ -220,6 +319,10 @@ var ClientApplication = /** @class */ (function () {
             else {
                 _this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Popup, null, e);
             }
+            atPopupMeasurement.endMeasurement({
+                success: false
+            });
+            atPopupMeasurement.flushMeasurement();
             // Since this function is syncronous we need to reject
             return Promise.reject(e);
         });
@@ -243,28 +346,45 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.ssoSilent = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var silentIframeClient, silentTokenResult, e_1;
+            var correlationId, validRequest, ssoSilentMeasurement, result, silentIframeClient;
+            var _this = this;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.preflightBrowserEnvironmentCheck(InteractionType.Silent);
-                        this.logger.verbose("ssoSilent called", request.correlationId);
-                        this.eventHandler.emitEvent(EventType.SSO_SILENT_START, InteractionType.Silent, request);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        silentIframeClient = new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, request.correlationId);
-                        return [4 /*yield*/, silentIframeClient.acquireToken(request)];
-                    case 2:
-                        silentTokenResult = _a.sent();
-                        this.eventHandler.emitEvent(EventType.SSO_SILENT_SUCCESS, InteractionType.Silent, silentTokenResult);
-                        return [2 /*return*/, silentTokenResult];
-                    case 3:
-                        e_1 = _a.sent();
-                        this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e_1);
-                        throw e_1;
-                    case 4: return [2 /*return*/];
+                correlationId = this.getRequestCorrelationId(request);
+                validRequest = __assign(__assign({}, request), { prompt: PromptValue.NONE, correlationId: correlationId });
+                this.preflightBrowserEnvironmentCheck(InteractionType.Silent);
+                ssoSilentMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SsoSilent, correlationId);
+                this.logger.verbose("ssoSilent called", correlationId);
+                this.eventHandler.emitEvent(EventType.SSO_SILENT_START, InteractionType.Silent, validRequest);
+                if (this.canUseNative(validRequest)) {
+                    result = this.acquireTokenNative(validRequest, ApiId.ssoSilent).catch(function (e) {
+                        // If native token acquisition fails for availability reasons fallback to standard flow
+                        if (e instanceof NativeAuthError && e.isFatal()) {
+                            _this.nativeExtensionProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
+                            var silentIframeClient = _this.createSilentIframeClient(validRequest.correlationId);
+                            return silentIframeClient.acquireToken(validRequest);
+                        }
+                        throw e;
+                    });
                 }
+                else {
+                    silentIframeClient = this.createSilentIframeClient(validRequest.correlationId);
+                    result = silentIframeClient.acquireToken(validRequest);
+                }
+                return [2 /*return*/, result.then(function (response) {
+                        _this.eventHandler.emitEvent(EventType.SSO_SILENT_SUCCESS, InteractionType.Silent, response);
+                        ssoSilentMeasurement.endMeasurement({
+                            success: true
+                        });
+                        ssoSilentMeasurement.flushMeasurement();
+                        return response;
+                    }).catch(function (e) {
+                        _this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e);
+                        ssoSilentMeasurement.endMeasurement({
+                            success: false
+                        });
+                        ssoSilentMeasurement.flushMeasurement();
+                        throw e;
+                    })];
             });
         });
     };
@@ -280,38 +400,73 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenByCode = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
+            var correlationId, atbcMeasurement, hybridAuthCode_1, response;
             var _this = this;
             return __generator(this, function (_a) {
+                correlationId = this.getRequestCorrelationId(request);
                 this.preflightBrowserEnvironmentCheck(InteractionType.Silent);
-                this.logger.trace("acquireTokenByCode called", request.correlationId);
+                this.logger.trace("acquireTokenByCode called", correlationId);
                 this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_START, InteractionType.Silent, request);
+                atbcMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByCode, request.correlationId);
                 try {
-                    if (!request.code) {
-                        throw BrowserAuthError.createAuthCodeRequiredError();
+                    if (request.code) {
+                        hybridAuthCode_1 = request.code;
+                        response = this.hybridAuthCodeResponses.get(hybridAuthCode_1);
+                        if (!response) {
+                            this.logger.verbose("Initiating new acquireTokenByCode request", correlationId);
+                            response = this.acquireTokenByCodeAsync(__assign(__assign({}, request), { correlationId: correlationId }))
+                                .then(function (result) {
+                                _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS, InteractionType.Silent, result);
+                                _this.hybridAuthCodeResponses.delete(hybridAuthCode_1);
+                                atbcMeasurement.endMeasurement({
+                                    success: true
+                                });
+                                atbcMeasurement.flushMeasurement();
+                                return result;
+                            })
+                                .catch(function (error) {
+                                _this.hybridAuthCodeResponses.delete(hybridAuthCode_1);
+                                _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, error);
+                                atbcMeasurement.endMeasurement({
+                                    success: false
+                                });
+                                atbcMeasurement.flushMeasurement();
+                                throw error;
+                            });
+                            this.hybridAuthCodeResponses.set(hybridAuthCode_1, response);
+                        }
+                        else {
+                            this.logger.verbose("Existing acquireTokenByCode request found", request.correlationId);
+                            atbcMeasurement.endMeasurement({
+                                success: true
+                            });
+                            atbcMeasurement.discardMeasurement();
+                        }
+                        return [2 /*return*/, response];
                     }
-                    response = this.hybridAuthCodeResponses.get(request.code);
-                    if (!response) {
-                        this.logger.verbose("Initiating new acquireTokenByCode request", request.correlationId);
-                        response = this.acquireTokenByCodeAsync(request)
-                            .then(function (result) {
-                            _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS, InteractionType.Silent, result);
-                            _this.hybridAuthCodeResponses.delete(request.code);
-                            return result;
-                        })
-                            .catch(function (error) {
-                            _this.hybridAuthCodeResponses.delete(request.code);
-                            throw error;
-                        });
-                        this.hybridAuthCodeResponses.set(request.code, response);
+                    else if (request.nativeAccountId) {
+                        if (this.canUseNative(request, request.nativeAccountId)) {
+                            return [2 /*return*/, this.acquireTokenNative(request, ApiId.acquireTokenByCode, request.nativeAccountId).catch(function (e) {
+                                    // If native token acquisition fails for availability reasons fallback to standard flow
+                                    if (e instanceof NativeAuthError && e.isFatal()) {
+                                        _this.nativeExtensionProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
+                                    }
+                                    throw e;
+                                })];
+                        }
+                        else {
+                            throw BrowserAuthError.createUnableToAcquireTokenFromNativePlatformError();
+                        }
                     }
                     else {
-                        this.logger.verbose("Existing acquireTokenByCode request found", request.correlationId);
+                        throw BrowserAuthError.createAuthCodeOrNativeAccountIdRequiredError();
                     }
-                    return [2 /*return*/, response];
                 }
                 catch (e) {
                     this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, e);
+                    atbcMeasurement.endMeasurement({
+                        success: false
+                    });
                     throw e;
                 }
                 return [2 /*return*/];
@@ -330,7 +485,7 @@ var ClientApplication = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         this.logger.trace("acquireTokenByCodeAsync called", request.correlationId);
-                        silentAuthCodeClient = new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, request.correlationId);
+                        silentAuthCodeClient = this.createSilentAuthCodeClient(request.correlationId);
                         return [4 /*yield*/, silentAuthCodeClient.acquireToken(request)];
                     case 1:
                         silentTokenResult = _a.sent();
@@ -352,22 +507,47 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenByRefreshToken = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var silentRefreshClient;
+            var atbrtMeasurement, silentRefreshClient;
             var _this = this;
             return __generator(this, function (_a) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, InteractionType.Silent, request);
                 // block the reload if it occurred inside a hidden iframe
                 BrowserUtils.blockReloadInHiddenIframes();
-                silentRefreshClient = new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, request.correlationId);
-                return [2 /*return*/, silentRefreshClient.acquireToken(request).catch(function (e) {
+                atbrtMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByRefreshToken, request.correlationId);
+                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, InteractionType.Silent, request);
+                silentRefreshClient = this.createSilentRefreshClient(request.correlationId);
+                return [2 /*return*/, silentRefreshClient.acquireToken(request)
+                        .then(function (result) {
+                        atbrtMeasurement.endMeasurement({
+                            success: true,
+                            fromCache: result.fromCache
+                        });
+                        return result;
+                    })
+                        .catch(function (e) {
                         var isServerError = e instanceof ServerError;
                         var isInteractionRequiredError = e instanceof InteractionRequiredAuthError;
                         var isInvalidGrantError = (e.errorCode === BrowserConstants.INVALID_GRANT_ERROR);
                         if (isServerError && isInvalidGrantError && !isInteractionRequiredError) {
                             _this.logger.verbose("Refresh token expired or invalid, attempting acquire token by iframe", request.correlationId);
-                            var silentIframeClient = new SilentIframeClient(_this.config, _this.browserStorage, _this.browserCrypto, _this.logger, _this.eventHandler, _this.navigationClient, ApiId.acquireTokenSilent_authCode, request.correlationId);
-                            return silentIframeClient.acquireToken(request);
+                            var silentIframeClient = _this.createSilentIframeClient(request.correlationId);
+                            return silentIframeClient.acquireToken(request)
+                                .then(function (result) {
+                                atbrtMeasurement.endMeasurement({
+                                    success: true,
+                                    fromCache: result.fromCache
+                                });
+                                return result;
+                            })
+                                .catch(function (error) {
+                                atbrtMeasurement.endMeasurement({
+                                    success: false
+                                });
+                                throw error;
+                            });
                         }
+                        atbrtMeasurement.endMeasurement({
+                            success: false
+                        });
                         throw e;
                     })];
             });
@@ -382,9 +562,11 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.logout = function (logoutRequest) {
         return __awaiter(this, void 0, void 0, function () {
+            var correlationId;
             return __generator(this, function (_a) {
-                this.logger.warning("logout API is deprecated and will be removed in msal-browser v3.0.0. Use logoutRedirect instead.");
-                return [2 /*return*/, this.logoutRedirect(logoutRequest)];
+                correlationId = this.getRequestCorrelationId(logoutRequest);
+                this.logger.warning("logout API is deprecated and will be removed in msal-browser v3.0.0. Use logoutRedirect instead.", correlationId);
+                return [2 /*return*/, this.logoutRedirect(__assign({ correlationId: correlationId }, logoutRequest))];
             });
         });
     };
@@ -395,10 +577,11 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.logoutRedirect = function (logoutRequest) {
         return __awaiter(this, void 0, void 0, function () {
-            var redirectClient;
+            var correlationId, redirectClient;
             return __generator(this, function (_a) {
+                correlationId = this.getRequestCorrelationId(logoutRequest);
                 this.preflightBrowserEnvironmentCheck(InteractionType.Redirect);
-                redirectClient = new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, logoutRequest === null || logoutRequest === void 0 ? void 0 : logoutRequest.correlationId);
+                redirectClient = this.createRedirectClient(correlationId);
                 return [2 /*return*/, redirectClient.logout(logoutRequest)];
             });
         });
@@ -409,8 +592,9 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.logoutPopup = function (logoutRequest) {
         try {
+            var correlationId = this.getRequestCorrelationId(logoutRequest);
             this.preflightBrowserEnvironmentCheck(InteractionType.Popup);
-            var popupClient = new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, logoutRequest === null || logoutRequest === void 0 ? void 0 : logoutRequest.correlationId);
+            var popupClient = this.createPopupClient(correlationId);
             return popupClient.logout(logoutRequest);
         }
         catch (e) {
@@ -517,6 +701,8 @@ var ClientApplication = /** @class */ (function () {
         BrowserUtils.blockReloadInHiddenIframes();
         // Block redirectUri opened in a popup from calling MSAL APIs
         BrowserUtils.blockAcquireTokenInPopups();
+        // Block token acquisition before initialize has been called if native brokering is enabled
+        BrowserUtils.blockNativeBrokerCalledBeforeInitialized(this.config.system.allowNativeBroker, this.initialized);
         // Block redirects if memory storage is enabled but storeAuthStateInCookie is not
         if (interactionType === InteractionType.Redirect &&
             this.config.cache.cacheLocation === BrowserCacheLocation.MemoryStorage &&
@@ -539,6 +725,98 @@ var ClientApplication = /** @class */ (function () {
         // Set interaction in progress temporary cache or throw if alread set.
         this.browserStorage.setInteractionInProgress(true);
     };
+    /**
+     * Acquire a token from native device (e.g. WAM)
+     * @param request
+     */
+    ClientApplication.prototype.acquireTokenNative = function (request, apiId, accountId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nativeClient;
+            return __generator(this, function (_a) {
+                this.logger.trace("acquireTokenNative called");
+                if (!this.nativeExtensionProvider) {
+                    throw BrowserAuthError.createNativeConnectionNotEstablishedError();
+                }
+                nativeClient = new NativeInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, apiId, this.performanceClient, this.nativeExtensionProvider, accountId || this.getNativeAccountId(request), request.correlationId);
+                return [2 /*return*/, nativeClient.acquireToken(request)];
+            });
+        });
+    };
+    /**
+     * Returns boolean indicating if this request can use the native broker
+     * @param request
+     */
+    ClientApplication.prototype.canUseNative = function (request, accountId) {
+        this.logger.trace("canUseNative called");
+        if (!NativeMessageHandler.isNativeAvailable(this.config, this.logger, this.nativeExtensionProvider, request.authenticationScheme)) {
+            this.logger.trace("canUseNative: isNativeAvailable returned false, returning false");
+            return false;
+        }
+        if (request.prompt) {
+            switch (request.prompt) {
+                case PromptValue.NONE:
+                case PromptValue.CONSENT:
+                    this.logger.trace("canUseNative: prompt is compatible with native flow");
+                    break;
+                default:
+                    this.logger.trace("canUseNative: prompt = " + request.prompt + " is not compatible with native flow, returning false");
+                    return false;
+            }
+        }
+        if (!accountId && !this.getNativeAccountId(request)) {
+            this.logger.trace("canUseNative: nativeAccountId is not available, returning false");
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Get the native accountId from the account
+     * @param request
+     * @returns
+     */
+    ClientApplication.prototype.getNativeAccountId = function (request) {
+        var account = request.account || this.browserStorage.getAccountInfoByHints(request.loginHint, request.sid) || this.getActiveAccount();
+        return account && account.nativeAccountId || "";
+    };
+    /**
+     * Returns new instance of the Popup Interaction Client
+     * @param correlationId
+     */
+    ClientApplication.prototype.createPopupClient = function (correlationId) {
+        return new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
+    /**
+     * Returns new instance of the Popup Interaction Client
+     * @param correlationId
+     */
+    ClientApplication.prototype.createRedirectClient = function (correlationId) {
+        return new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
+    /**
+     * Returns new instance of the Silent Iframe Interaction Client
+     * @param correlationId
+     */
+    ClientApplication.prototype.createSilentIframeClient = function (correlationId) {
+        return new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
+    /**
+     * Returns new instance of the Silent Cache Interaction Client
+     */
+    ClientApplication.prototype.createSilentCacheClient = function (correlationId) {
+        return new SilentCacheClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
+    /**
+     * Returns new instance of the Silent Refresh Interaction Client
+     */
+    ClientApplication.prototype.createSilentRefreshClient = function (correlationId) {
+        return new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
+    /**
+     * Returns new instance of the Silent AuthCode Interaction Client
+     */
+    ClientApplication.prototype.createSilentAuthCodeClient = function (correlationId) {
+        return new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, this.performanceClient, this.nativeExtensionProvider, correlationId);
+    };
     /**
      * Adds event callbacks to array
      * @param callback
@@ -553,6 +831,24 @@ var ClientApplication = /** @class */ (function () {
     ClientApplication.prototype.removeEventCallback = function (callbackId) {
         this.eventHandler.removeEventCallback(callbackId);
     };
+    /**
+     * Registers a callback to receive performance events.
+     *
+     * @param {PerformanceCallbackFunction} callback
+     * @returns {string}
+     */
+    ClientApplication.prototype.addPerformanceCallback = function (callback) {
+        return this.performanceClient.addPerformanceCallback(callback);
+    };
+    /**
+     * Removes a callback registered with addPerformanceCallback.
+     *
+     * @param {string} callbackId
+     * @returns {boolean}
+     */
+    ClientApplication.prototype.removePerformanceCallback = function (callbackId) {
+        return this.performanceClient.removePerformanceCallback(callbackId);
+    };
     /**
      * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
      */
@@ -606,6 +902,26 @@ var ClientApplication = /** @class */ (function () {
     ClientApplication.prototype.getConfiguration = function () {
         return this.config;
     };
+    /**
+     * Generates a correlation id for a request if none is provided.
+     *
+     * @protected
+     * @param {?Partial<BaseAuthRequest>} [request]
+     * @returns {string}
+     */
+    ClientApplication.prototype.getRequestCorrelationId = function (request) {
+        if (request === null || request === void 0 ? void 0 : request.correlationId) {
+            return request.correlationId;
+        }
+        if (this.isBrowserEnvironment) {
+            return this.browserCrypto.createNewGuid();
+        }
+        /*
+         * Included for fallback for non-browser environments,
+         * and to ensure this method always returns a string.
+         */
+        return Constants.EMPTY_STRING;
+    };
     return ClientApplication;
 }());