@azure/msal-browser 2.23.0 → 2.25.0

package/dist/app/ClientApplication.js

@@ -1,11 +1,11 @@
-/*! @azure/msal-browser v2.23.0 2022-04-04 */
+/*! @azure/msal-browser v2.25.0 2022-06-06 */
 'use strict';
 import { __awaiter, __generator, __assign } from '../_virtual/_tslib.js';
 import { CryptoOps } from '../crypto/CryptoOps.js';
-import { Constants, PerformanceEvents, StringUtils, Logger, StubPerformanceClient, DEFAULT_CRYPTO_IMPLEMENTATION, 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,6 +16,10 @@ 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';
@@ -55,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.
@@ -79,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.info("initialize has already been called, exiting early.");
+                            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
@@ -89,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;
@@ -100,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) || Constants.EMPTY_STRING;
-                        redirectClient = new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, 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;
@@ -118,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);
@@ -153,7 +205,7 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenRedirect = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var correlationId, isLoggedIn, redirectClient;
+            var correlationId, isLoggedIn, result, nativeClient, redirectClient;
             var _this = this;
             return __generator(this, function (_a) {
                 correlationId = this.getRequestCorrelationId(request);
@@ -166,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, this.performanceClient, correlationId);
-                return [2 /*return*/, redirectClient.acquireToken(__assign(__assign({}, request), { correlationId: correlationId })).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);
@@ -192,6 +258,7 @@ 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", correlationId);
             this.preflightBrowserEnvironmentCheck(InteractionType.Popup);
@@ -208,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, this.performanceClient, correlationId);
-        return popupClient.acquireToken(__assign(__assign({}, request), { correlationId: correlationId })).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) {
@@ -218,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) {
@@ -226,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);
         });
@@ -249,38 +346,45 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.ssoSilent = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var correlationId, ssoSilentMeasurement, silentIframeClient, silentTokenResult, e_1;
+            var correlationId, validRequest, ssoSilentMeasurement, result, silentIframeClient;
+            var _this = this;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        correlationId = this.getRequestCorrelationId(request);
-                        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, 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, this.performanceClient, correlationId);
-                        return [4 /*yield*/, silentIframeClient.acquireToken(__assign(__assign({}, request), { correlationId: correlationId }))];
-                    case 2:
-                        silentTokenResult = _a.sent();
-                        this.eventHandler.emitEvent(EventType.SSO_SILENT_SUCCESS, InteractionType.Silent, silentTokenResult);
+                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 [2 /*return*/, silentTokenResult];
-                    case 3:
-                        e_1 = _a.sent();
-                        this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e_1);
+                        return response;
+                    }).catch(function (e) {
+                        _this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e);
                         ssoSilentMeasurement.endMeasurement({
                             success: false
                         });
                         ssoSilentMeasurement.flushMeasurement();
-                        throw e_1;
-                    case 4: return [2 /*return*/];
-                }
+                        throw e;
+                    })];
             });
         });
     };
@@ -296,7 +400,7 @@ var ClientApplication = /** @class */ (function () {
      */
     ClientApplication.prototype.acquireTokenByCode = function (request) {
         return __awaiter(this, void 0, void 0, function () {
-            var correlationId, atbcMeasurement, response;
+            var correlationId, atbcMeasurement, hybridAuthCode_1, response;
             var _this = this;
             return __generator(this, function (_a) {
                 correlationId = this.getRequestCorrelationId(request);
@@ -305,41 +409,58 @@ var ClientApplication = /** @class */ (function () {
                 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();
-                    }
-                    response = this.hybridAuthCodeResponses.get(request.code);
-                    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(request.code);
-                            atbcMeasurement.endMeasurement({
-                                success: true
+                    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;
                             });
-                            atbcMeasurement.flushMeasurement();
-                            return result;
-                        })
-                            .catch(function (error) {
-                            _this.hybridAuthCodeResponses.delete(request.code);
-                            _this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, error);
+                            this.hybridAuthCodeResponses.set(hybridAuthCode_1, response);
+                        }
+                        else {
+                            this.logger.verbose("Existing acquireTokenByCode request found", request.correlationId);
                             atbcMeasurement.endMeasurement({
-                                success: false
+                                success: true
                             });
-                            atbcMeasurement.flushMeasurement();
-                            throw error;
-                        });
-                        this.hybridAuthCodeResponses.set(request.code, response);
+                            atbcMeasurement.discardMeasurement();
+                        }
+                        return [2 /*return*/, 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);
-                        atbcMeasurement.endMeasurement({
-                            success: true
-                        });
-                        atbcMeasurement.discardMeasurement();
+                        throw BrowserAuthError.createAuthCodeOrNativeAccountIdRequiredError();
                     }
-                    return [2 /*return*/, response];
                 }
                 catch (e) {
                     this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, e);
@@ -364,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, this.performanceClient, request.correlationId);
+                        silentAuthCodeClient = this.createSilentAuthCodeClient(request.correlationId);
                         return [4 /*yield*/, silentAuthCodeClient.acquireToken(request)];
                     case 1:
                         silentTokenResult = _a.sent();
@@ -393,7 +514,7 @@ var ClientApplication = /** @class */ (function () {
                 BrowserUtils.blockReloadInHiddenIframes();
                 atbrtMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByRefreshToken, request.correlationId);
                 this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, InteractionType.Silent, request);
-                silentRefreshClient = new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, request.correlationId);
+                silentRefreshClient = this.createSilentRefreshClient(request.correlationId);
                 return [2 /*return*/, silentRefreshClient.acquireToken(request)
                         .then(function (result) {
                         atbrtMeasurement.endMeasurement({
@@ -408,7 +529,7 @@ var ClientApplication = /** @class */ (function () {
                         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, _this.performanceClient, request.correlationId);
+                            var silentIframeClient = _this.createSilentIframeClient(request.correlationId);
                             return silentIframeClient.acquireToken(request)
                                 .then(function (result) {
                                 atbrtMeasurement.endMeasurement({
@@ -460,8 +581,8 @@ var ClientApplication = /** @class */ (function () {
             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, this.performanceClient, correlationId);
-                return [2 /*return*/, redirectClient.logout(__assign({ correlationId: correlationId }, logoutRequest))];
+                redirectClient = this.createRedirectClient(correlationId);
+                return [2 /*return*/, redirectClient.logout(logoutRequest)];
             });
         });
     };
@@ -473,8 +594,8 @@ var ClientApplication = /** @class */ (function () {
         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, this.performanceClient, correlationId);
-            return popupClient.logout(__assign({ correlationId: correlationId }, logoutRequest));
+            var popupClient = this.createPopupClient(correlationId);
+            return popupClient.logout(logoutRequest);
         }
         catch (e) {
             // Since this function is syncronous we need to reject
@@ -580,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 &&
@@ -602,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