@azure/msal-browser 3.4.0 → 3.5.1-beta.0

package/dist/interaction_client/StandardInteractionClient.mjs

@@ -1,256 +1,234 @@
-/*! @azure/msal-browser v3.4.0 2023-10-30 */
+/*! @azure/msal-browser v3.5.1-beta.0 2023-11-14 */
 'use strict';
 import { PerformanceEvents, invokeAsync, Constants, UrlString, AuthorizationCodeClient, Authority, AuthorityFactory, ProtocolUtils } from '@azure/msal-common';
 import { BaseInteractionClient } from './BaseInteractionClient.mjs';
 import { BrowserConstants } from '../utils/BrowserConstants.mjs';
 import { version } from '../packageMetadata.mjs';
-import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
-import { BrowserProtocolUtils } from '../utils/BrowserProtocolUtils.mjs';
 import { getCurrentUri } from '../utils/BrowserUtils.mjs';
 import { generatePkceCodes } from '../crypto/PkceGenerator.mjs';
 import { createNewGuid } from '../crypto/BrowserCrypto.mjs';
-import { noStateInHash, unableToParseState, stateInteractionTypeMismatch } from '../error/BrowserAuthErrorCodes.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Defines the class structure and helper functions used by the "standard", non-brokered auth flows (popup, redirect, silent (RT), silent (iframe))
- */
-class StandardInteractionClient extends BaseInteractionClient {
-    /**
-     * Generates an auth code request tied to the url request.
-     * @param request
-     */
-    async initializeAuthorizationCodeRequest(request) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientInitializeAuthorizationCodeRequest, request.correlationId);
-        const generatedPkceParams = await invokeAsync(generatePkceCodes, PerformanceEvents.GeneratePkceCodes, this.logger, this.performanceClient, this.correlationId)(this.performanceClient, this.logger, this.correlationId);
-        const authCodeRequest = {
-            ...request,
-            redirectUri: request.redirectUri,
-            code: Constants.EMPTY_STRING,
-            codeVerifier: generatedPkceParams.verifier,
-        };
-        request.codeChallenge = generatedPkceParams.challenge;
-        request.codeChallengeMethod = Constants.S256_CODE_CHALLENGE_METHOD;
-        return authCodeRequest;
-    }
-    /**
-     * Initializer for the logout request.
-     * @param logoutRequest
-     */
-    initializeLogoutRequest(logoutRequest) {
-        this.logger.verbose("initializeLogoutRequest called", logoutRequest?.correlationId);
-        const validLogoutRequest = {
-            correlationId: this.correlationId || createNewGuid(),
-            ...logoutRequest,
-        };
-        /**
-         * Set logout_hint to be login_hint from ID Token Claims if present
-         * and logoutHint attribute wasn't manually set in logout request
-         */
-        if (logoutRequest) {
-            // If logoutHint isn't set and an account was passed in, try to extract logoutHint from ID Token Claims
-            if (!logoutRequest.logoutHint) {
-                if (logoutRequest.account) {
-                    const logoutHint = this.getLogoutHintFromIdTokenClaims(logoutRequest.account);
-                    if (logoutHint) {
-                        this.logger.verbose("Setting logoutHint to login_hint ID Token Claim value for the account provided");
-                        validLogoutRequest.logoutHint = logoutHint;
-                    }
-                }
-                else {
-                    this.logger.verbose("logoutHint was not set and account was not passed into logout request, logoutHint will not be set");
-                }
-            }
-            else {
-                this.logger.verbose("logoutHint has already been set in logoutRequest");
-            }
-        }
-        else {
-            this.logger.verbose("logoutHint will not be set since no logout request was configured");
-        }
-        /*
-         * Only set redirect uri if logout request isn't provided or the set uri isn't null.
-         * Otherwise, use passed uri, config, or current page.
-         */
-        if (!logoutRequest || logoutRequest.postLogoutRedirectUri !== null) {
-            if (logoutRequest && logoutRequest.postLogoutRedirectUri) {
-                this.logger.verbose("Setting postLogoutRedirectUri to uri set on logout request", validLogoutRequest.correlationId);
-                validLogoutRequest.postLogoutRedirectUri =
-                    UrlString.getAbsoluteUrl(logoutRequest.postLogoutRedirectUri, getCurrentUri());
-            }
-            else if (this.config.auth.postLogoutRedirectUri === null) {
-                this.logger.verbose("postLogoutRedirectUri configured as null and no uri set on request, not passing post logout redirect", validLogoutRequest.correlationId);
-            }
-            else if (this.config.auth.postLogoutRedirectUri) {
-                this.logger.verbose("Setting postLogoutRedirectUri to configured uri", validLogoutRequest.correlationId);
-                validLogoutRequest.postLogoutRedirectUri =
-                    UrlString.getAbsoluteUrl(this.config.auth.postLogoutRedirectUri, getCurrentUri());
-            }
-            else {
-                this.logger.verbose("Setting postLogoutRedirectUri to current page", validLogoutRequest.correlationId);
-                validLogoutRequest.postLogoutRedirectUri =
-                    UrlString.getAbsoluteUrl(getCurrentUri(), getCurrentUri());
-            }
-        }
-        else {
-            this.logger.verbose("postLogoutRedirectUri passed as null, not setting post logout redirect uri", validLogoutRequest.correlationId);
-        }
-        return validLogoutRequest;
-    }
-    /**
-     * Parses login_hint ID Token Claim out of AccountInfo object to be used as
-     * logout_hint in end session request.
-     * @param account
-     */
-    getLogoutHintFromIdTokenClaims(account) {
-        const idTokenClaims = account.idTokenClaims;
-        if (idTokenClaims) {
-            if (idTokenClaims.login_hint) {
-                return idTokenClaims.login_hint;
-            }
-            else {
-                this.logger.verbose("The ID Token Claims tied to the provided account do not contain a login_hint claim, logoutHint will not be added to logout request");
-            }
-        }
-        else {
-            this.logger.verbose("The provided account does not contain ID Token Claims, logoutHint will not be added to logout request");
-        }
-        return null;
-    }
-    /**
-     * Creates an Authorization Code Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    async createAuthCodeClient(serverTelemetryManager, authorityUrl, requestAzureCloudOptions) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientCreateAuthCodeClient, this.correlationId);
-        // Create auth module.
-        const clientConfig = await invokeAsync(this.getClientConfiguration.bind(this), PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.logger, this.performanceClient, this.correlationId)(serverTelemetryManager, authorityUrl, requestAzureCloudOptions);
-        return new AuthorizationCodeClient(clientConfig, this.performanceClient);
-    }
-    /**
-     * Creates a Client Configuration object with the given request authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param requestAuthority
-     * @param requestCorrelationId
-     */
-    async getClientConfiguration(serverTelemetryManager, requestAuthority, requestAzureCloudOptions) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
-        const discoveredAuthority = await invokeAsync(this.getDiscoveredAuthority.bind(this), PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority, this.logger, this.performanceClient, this.correlationId)(requestAuthority, requestAzureCloudOptions);
-        const logger = this.config.system.loggerOptions;
-        return {
-            authOptions: {
-                clientId: this.config.auth.clientId,
-                authority: discoveredAuthority,
-                clientCapabilities: this.config.auth.clientCapabilities,
-            },
-            systemOptions: {
-                tokenRenewalOffsetSeconds: this.config.system.tokenRenewalOffsetSeconds,
-                preventCorsPreflight: true,
-            },
-            loggerOptions: {
-                loggerCallback: logger.loggerCallback,
-                piiLoggingEnabled: logger.piiLoggingEnabled,
-                logLevel: logger.logLevel,
-                correlationId: this.correlationId,
-            },
-            cacheOptions: {
-                claimsBasedCachingEnabled: this.config.cache.claimsBasedCachingEnabled,
-            },
-            cryptoInterface: this.browserCrypto,
-            networkInterface: this.networkClient,
-            storageInterface: this.browserStorage,
-            serverTelemetryManager: serverTelemetryManager,
-            libraryInfo: {
-                sku: BrowserConstants.MSAL_SKU,
-                version: version,
-                cpu: Constants.EMPTY_STRING,
-                os: Constants.EMPTY_STRING,
-            },
-            telemetry: this.config.telemetry,
-        };
-    }
-    /**
-     * @param hash
-     * @param interactionType
-     */
-    validateAndExtractStateFromHash(serverParams, interactionType, requestCorrelationId) {
-        this.logger.verbose("validateAndExtractStateFromHash called", requestCorrelationId);
-        if (!serverParams.state) {
-            throw createBrowserAuthError(noStateInHash);
-        }
-        const platformStateObj = BrowserProtocolUtils.extractBrowserRequestState(this.browserCrypto, serverParams.state);
-        if (!platformStateObj) {
-            throw createBrowserAuthError(unableToParseState);
-        }
-        if (platformStateObj.interactionType !== interactionType) {
-            throw createBrowserAuthError(stateInteractionTypeMismatch);
-        }
-        this.logger.verbose("Returning state from hash", requestCorrelationId);
-        return serverParams.state;
-    }
-    /**
-     * Used to get a discovered version of the default authority.
-     * @param requestAuthority
-     * @param requestCorrelationId
-     */
-    async getDiscoveredAuthority(requestAuthority, requestAzureCloudOptions) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority, this.correlationId);
-        const authorityOptions = {
-            protocolMode: this.config.auth.protocolMode,
-            OIDCOptions: this.config.auth.OIDCOptions,
-            knownAuthorities: this.config.auth.knownAuthorities,
-            cloudDiscoveryMetadata: this.config.auth.cloudDiscoveryMetadata,
-            authorityMetadata: this.config.auth.authorityMetadata,
-            skipAuthorityMetadataCache: this.config.auth.skipAuthorityMetadataCache,
-        };
-        // build authority string based on auth params, precedence - azureCloudInstance + tenant >> authority
-        const userAuthority = requestAuthority
-            ? requestAuthority
-            : this.config.auth.authority;
-        // fall back to the authority from config
-        const builtAuthority = Authority.generateAuthority(userAuthority, requestAzureCloudOptions || this.config.auth.azureCloudOptions);
-        return await invokeAsync(AuthorityFactory.createDiscoveredInstance.bind(AuthorityFactory), PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance, this.logger, this.performanceClient, this.correlationId)(builtAuthority, this.config.system.networkClient, this.browserStorage, authorityOptions, this.logger, this.performanceClient, this.correlationId);
-    }
-    /**
-     * Helper to initialize required request parameters for interactive APIs and ssoSilent()
-     * @param request
-     * @param interactionType
-     */
-    async initializeAuthorizationRequest(request, interactionType) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, this.correlationId);
-        const redirectUri = this.getRedirectUri(request.redirectUri);
-        const browserState = {
-            interactionType: interactionType,
-        };
-        const state = ProtocolUtils.setRequestState(this.browserCrypto, (request && request.state) || Constants.EMPTY_STRING, browserState);
-        const baseRequest = await invokeAsync(this.initializeBaseRequest.bind(this), PerformanceEvents.InitializeBaseRequest, this.logger, this.performanceClient, this.correlationId)(request);
-        const validatedRequest = {
-            ...baseRequest,
-            redirectUri: redirectUri,
-            state: state,
-            nonce: request.nonce || createNewGuid(),
-            responseMode: this.config.auth.OIDCOptions
-                .serverResponseType,
-        };
-        const account = request.account || this.browserStorage.getActiveAccount();
-        if (account) {
-            this.logger.verbose("Setting validated request account", this.correlationId);
-            this.logger.verbosePii(`Setting validated request account: ${account.homeAccountId}`, this.correlationId);
-            validatedRequest.account = account;
-        }
-        // Check for ADAL/MSAL v1 SSO
-        if (!validatedRequest.loginHint && !account) {
-            const legacyLoginHint = this.browserStorage.getLegacyLoginHint();
-            if (legacyLoginHint) {
-                validatedRequest.loginHint = legacyLoginHint;
-            }
-        }
-        return validatedRequest;
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Defines the class structure and helper functions used by the "standard", non-brokered auth flows (popup, redirect, silent (RT), silent (iframe))
+ */
+class StandardInteractionClient extends BaseInteractionClient {
+    /**
+     * Generates an auth code request tied to the url request.
+     * @param request
+     */
+    async initializeAuthorizationCodeRequest(request) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientInitializeAuthorizationCodeRequest, this.correlationId);
+        const generatedPkceParams = await invokeAsync(generatePkceCodes, PerformanceEvents.GeneratePkceCodes, this.logger, this.performanceClient, this.correlationId)(this.performanceClient, this.logger, this.correlationId);
+        const authCodeRequest = {
+            ...request,
+            redirectUri: request.redirectUri,
+            code: Constants.EMPTY_STRING,
+            codeVerifier: generatedPkceParams.verifier,
+        };
+        request.codeChallenge = generatedPkceParams.challenge;
+        request.codeChallengeMethod = Constants.S256_CODE_CHALLENGE_METHOD;
+        return authCodeRequest;
+    }
+    /**
+     * Initializer for the logout request.
+     * @param logoutRequest
+     */
+    initializeLogoutRequest(logoutRequest) {
+        this.logger.verbose("initializeLogoutRequest called", logoutRequest?.correlationId);
+        const validLogoutRequest = {
+            correlationId: this.correlationId || createNewGuid(),
+            ...logoutRequest,
+        };
+        /**
+         * Set logout_hint to be login_hint from ID Token Claims if present
+         * and logoutHint attribute wasn't manually set in logout request
+         */
+        if (logoutRequest) {
+            // If logoutHint isn't set and an account was passed in, try to extract logoutHint from ID Token Claims
+            if (!logoutRequest.logoutHint) {
+                if (logoutRequest.account) {
+                    const logoutHint = this.getLogoutHintFromIdTokenClaims(logoutRequest.account);
+                    if (logoutHint) {
+                        this.logger.verbose("Setting logoutHint to login_hint ID Token Claim value for the account provided");
+                        validLogoutRequest.logoutHint = logoutHint;
+                    }
+                }
+                else {
+                    this.logger.verbose("logoutHint was not set and account was not passed into logout request, logoutHint will not be set");
+                }
+            }
+            else {
+                this.logger.verbose("logoutHint has already been set in logoutRequest");
+            }
+        }
+        else {
+            this.logger.verbose("logoutHint will not be set since no logout request was configured");
+        }
+        /*
+         * Only set redirect uri if logout request isn't provided or the set uri isn't null.
+         * Otherwise, use passed uri, config, or current page.
+         */
+        if (!logoutRequest || logoutRequest.postLogoutRedirectUri !== null) {
+            if (logoutRequest && logoutRequest.postLogoutRedirectUri) {
+                this.logger.verbose("Setting postLogoutRedirectUri to uri set on logout request", validLogoutRequest.correlationId);
+                validLogoutRequest.postLogoutRedirectUri =
+                    UrlString.getAbsoluteUrl(logoutRequest.postLogoutRedirectUri, getCurrentUri());
+            }
+            else if (this.config.auth.postLogoutRedirectUri === null) {
+                this.logger.verbose("postLogoutRedirectUri configured as null and no uri set on request, not passing post logout redirect", validLogoutRequest.correlationId);
+            }
+            else if (this.config.auth.postLogoutRedirectUri) {
+                this.logger.verbose("Setting postLogoutRedirectUri to configured uri", validLogoutRequest.correlationId);
+                validLogoutRequest.postLogoutRedirectUri =
+                    UrlString.getAbsoluteUrl(this.config.auth.postLogoutRedirectUri, getCurrentUri());
+            }
+            else {
+                this.logger.verbose("Setting postLogoutRedirectUri to current page", validLogoutRequest.correlationId);
+                validLogoutRequest.postLogoutRedirectUri =
+                    UrlString.getAbsoluteUrl(getCurrentUri(), getCurrentUri());
+            }
+        }
+        else {
+            this.logger.verbose("postLogoutRedirectUri passed as null, not setting post logout redirect uri", validLogoutRequest.correlationId);
+        }
+        return validLogoutRequest;
+    }
+    /**
+     * Parses login_hint ID Token Claim out of AccountInfo object to be used as
+     * logout_hint in end session request.
+     * @param account
+     */
+    getLogoutHintFromIdTokenClaims(account) {
+        const idTokenClaims = account.idTokenClaims;
+        if (idTokenClaims) {
+            if (idTokenClaims.login_hint) {
+                return idTokenClaims.login_hint;
+            }
+            else {
+                this.logger.verbose("The ID Token Claims tied to the provided account do not contain a login_hint claim, logoutHint will not be added to logout request");
+            }
+        }
+        else {
+            this.logger.verbose("The provided account does not contain ID Token Claims, logoutHint will not be added to logout request");
+        }
+        return null;
+    }
+    /**
+     * Creates an Authorization Code Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    async createAuthCodeClient(serverTelemetryManager, authorityUrl, requestAzureCloudOptions) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientCreateAuthCodeClient, this.correlationId);
+        // Create auth module.
+        const clientConfig = await invokeAsync(this.getClientConfiguration.bind(this), PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.logger, this.performanceClient, this.correlationId)(serverTelemetryManager, authorityUrl, requestAzureCloudOptions);
+        return new AuthorizationCodeClient(clientConfig, this.performanceClient);
+    }
+    /**
+     * Creates a Client Configuration object with the given request authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param requestAuthority
+     * @param requestCorrelationId
+     */
+    async getClientConfiguration(serverTelemetryManager, requestAuthority, requestAzureCloudOptions) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
+        const discoveredAuthority = await invokeAsync(this.getDiscoveredAuthority.bind(this), PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority, this.logger, this.performanceClient, this.correlationId)(requestAuthority, requestAzureCloudOptions);
+        const logger = this.config.system.loggerOptions;
+        return {
+            authOptions: {
+                clientId: this.config.auth.clientId,
+                authority: discoveredAuthority,
+                clientCapabilities: this.config.auth.clientCapabilities,
+            },
+            systemOptions: {
+                tokenRenewalOffsetSeconds: this.config.system.tokenRenewalOffsetSeconds,
+                preventCorsPreflight: true,
+            },
+            loggerOptions: {
+                loggerCallback: logger.loggerCallback,
+                piiLoggingEnabled: logger.piiLoggingEnabled,
+                logLevel: logger.logLevel,
+                correlationId: this.correlationId,
+            },
+            cacheOptions: {
+                claimsBasedCachingEnabled: this.config.cache.claimsBasedCachingEnabled,
+            },
+            cryptoInterface: this.browserCrypto,
+            networkInterface: this.networkClient,
+            storageInterface: this.browserStorage,
+            serverTelemetryManager: serverTelemetryManager,
+            libraryInfo: {
+                sku: BrowserConstants.MSAL_SKU,
+                version: version,
+                cpu: Constants.EMPTY_STRING,
+                os: Constants.EMPTY_STRING,
+            },
+            telemetry: this.config.telemetry,
+        };
+    }
+    /**
+     * Used to get a discovered version of the default authority.
+     * @param requestAuthority
+     * @param requestCorrelationId
+     */
+    async getDiscoveredAuthority(requestAuthority, requestAzureCloudOptions) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority, this.correlationId);
+        const authorityOptions = {
+            protocolMode: this.config.auth.protocolMode,
+            OIDCOptions: this.config.auth.OIDCOptions,
+            knownAuthorities: this.config.auth.knownAuthorities,
+            cloudDiscoveryMetadata: this.config.auth.cloudDiscoveryMetadata,
+            authorityMetadata: this.config.auth.authorityMetadata,
+            skipAuthorityMetadataCache: this.config.auth.skipAuthorityMetadataCache,
+        };
+        // build authority string based on auth params, precedence - azureCloudInstance + tenant >> authority
+        const userAuthority = requestAuthority
+            ? requestAuthority
+            : this.config.auth.authority;
+        // fall back to the authority from config
+        const builtAuthority = Authority.generateAuthority(userAuthority, requestAzureCloudOptions || this.config.auth.azureCloudOptions);
+        return await invokeAsync(AuthorityFactory.createDiscoveredInstance.bind(AuthorityFactory), PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance, this.logger, this.performanceClient, this.correlationId)(builtAuthority, this.config.system.networkClient, this.browserStorage, authorityOptions, this.logger, this.performanceClient, this.correlationId);
+    }
+    /**
+     * Helper to initialize required request parameters for interactive APIs and ssoSilent()
+     * @param request
+     * @param interactionType
+     */
+    async initializeAuthorizationRequest(request, interactionType) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, this.correlationId);
+        const redirectUri = this.getRedirectUri(request.redirectUri);
+        const browserState = {
+            interactionType: interactionType,
+        };
+        const state = ProtocolUtils.setRequestState(this.browserCrypto, (request && request.state) || Constants.EMPTY_STRING, browserState);
+        const baseRequest = await invokeAsync(this.initializeBaseRequest.bind(this), PerformanceEvents.InitializeBaseRequest, this.logger, this.performanceClient, this.correlationId)(request);
+        const validatedRequest = {
+            ...baseRequest,
+            redirectUri: redirectUri,
+            state: state,
+            nonce: request.nonce || createNewGuid(),
+            responseMode: this.config.auth.OIDCOptions
+                .serverResponseType,
+        };
+        const account = request.account || this.browserStorage.getActiveAccount();
+        if (account) {
+            this.logger.verbose("Setting validated request account", this.correlationId);
+            this.logger.verbosePii(`Setting validated request account: ${account.homeAccountId}`, this.correlationId);
+            validatedRequest.account = account;
+        }
+        // Check for ADAL/MSAL v1 SSO
+        if (!validatedRequest.loginHint && !account) {
+            const legacyLoginHint = this.browserStorage.getLegacyLoginHint();
+            if (legacyLoginHint) {
+                validatedRequest.loginHint = legacyLoginHint;
+            }
+        }
+        return validatedRequest;
+    }
 }
 
 export { StandardInteractionClient };

package/dist/interaction_client/StandardInteractionClient.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"StandardInteractionClient.mjs","sources":["../../src/interaction_client/StandardInteractionClient.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;AAKA;AAqBA;AACA;AACA;;;AAyBO;+BAC+C,SAAA,qBACrC,CAAA;AA2Bb;;;AAGG;IACH,MAAS,kCACL,CAAA,OAAc,EAAE;AAgGpB,QAAA,IAAA,CAAA,iBAAA,CAAA,mBAAA,CAAA,iBAAA,CAAA,2DAAA,EAAA,OAAA,CAAA,aAAA,CAAA,CAAA;;;;AAIG,YAAA,WAAA,EAAA,OAAA,CAAA,WAAA;YACM;AAqBT,YAAA,YAAA,EAAA,mBAAA,CAAA,QAAA;;;;AAIG,QAAA,OAAA,eAAA,CAAA;AACa,KAAA;AAuBhB;;;;;AAKG,QAAA,IAAA,CAAA,MAAA,CAAA,OAAA,CAAA,gCAAA,EAAA,aAAA,EAAA,aAAA,CAAA,CAAA;AACa,QAAA,MAAA,kBAAA,GAAA;AAqDhB,YAAA,aAAA,EAAA,IAAA,CAAA,aAAA,IAAA,aAAA,EAAA;;;AAGG;AACH;AAkCA;;;;AAIG,YAAA,IAAA,CAAA,aAAA,CAAA,UAAA,EAAA;AACa,gBAAA,IAAA,aAAA,CAAA,OACZ,EAAA;AA4CJ,oBAAA,MAAA,UAAA,GAAA,IAAA,CAAA,8BAAA,CAAA,aAAA,CAAA,OAAA,CAAA,CAAA;;;;AAIG,qBAAA;AACa,iBAAA;AA4DnB,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"StandardInteractionClient.mjs","sources":["../../src/interaction_client/StandardInteractionClient.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;AAKA;AAoBA;AACA;AACA;AAcA;AACI;;;AAGG;;AA6BH;;;AAGG,QAAA,IAAA,CAAA,iBAAA,CAAA,mBAAA,CAAA,iBAAA,CAAA,2DAAA,EAAA,IAAA,CAAA,aAAA,CAAA,CAAA;QACM,MAAC,4BACN,WAAgB,CAAA,iBAAiB,mBACX,CAAA,iBAAA,EAAA,IAAA,CAAA,MAAA,EAAA,IAAA,CAAA,iBAAA,EAAA,IAAA,CAAA,aAAA,CAAA,CAAA,IAAA,CAAA,iBAAA,EAAA,IAAA,CAAA,MAAA,EAAA,IAAA,CAAA,aAAA,CAAA,CAAA;AA+F1B,QAAA,MAAA,eAAA,GAAA;;;;AAIG,YAAA,YAAA,EAAA,mBAAA,CAAA,QAAA;SACM,CAAA;AAqBT,QAAA,OAAA,CAAA,aAAA,GAAA,mBAAA,CAAA,SAAA,CAAA;;;;AAIG;AACa;AAuBhB;;;;;AAKG,YAAA,aAAA,EAAA,IAAA,CAAA,aAAA,IAAA,aAAA,EAAA;AACa,YAAA,GAAA,aAAA;AAqDhB,SAAA,CAAA;;;;AAIG;AACa,QAAA,IAAA,aAAA,EAAA;AA6ChB;;;;AAIG,oBAAA,IAAA,UAAA,EAAA;AACa,wBAAA,IAAA,CAAA,MAAA,CAAA,OAAA,CAA8B,gFAEV,CAAA,CAAA;AA0DvC,wBAAA,kBAAA,CAAA,UAAA,GAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/interaction_handler/InteractionHandler.d.ts

@@ -1,34 +1,34 @@
-import { AuthorizationCodePayload, CommonAuthorizationCodeRequest, AuthorizationCodeClient, CcsCredential, Logger, IPerformanceClient } from "@azure/msal-common";
-import { BrowserCacheManager } from "../cache/BrowserCacheManager";
-import { AuthenticationResult } from "../response/AuthenticationResult";
-import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
-/**
- * Abstract class which defines operations for a browser interaction handling class.
- */
-export declare class InteractionHandler {
-    protected authModule: AuthorizationCodeClient;
-    protected browserStorage: BrowserCacheManager;
-    protected authCodeRequest: CommonAuthorizationCodeRequest;
-    protected logger: Logger;
-    protected performanceClient: IPerformanceClient;
-    constructor(authCodeModule: AuthorizationCodeClient, storageImpl: BrowserCacheManager, authCodeRequest: CommonAuthorizationCodeRequest, logger: Logger, performanceClient: IPerformanceClient);
-    /**
-     * Function to handle response parameters from hash.
-     * @param locationHash
-     */
-    handleCodeResponseFromHash(locationHash: string, request: AuthorizationUrlRequest): Promise<AuthenticationResult>;
-    /**
-     * Process auth code response from AAD
-     * @param authCodeResponse
-     * @param state
-     * @param authority
-     * @param networkModule
-     * @returns
-     */
-    handleCodeResponseFromServer(authCodeResponse: AuthorizationCodePayload, request: AuthorizationUrlRequest, validateNonce?: boolean): Promise<AuthenticationResult>;
-    /**
-     * Build ccs creds if available
-     */
-    protected createCcsCredentials(request: AuthorizationUrlRequest): CcsCredential | null;
-}
+import { AuthorizationCodePayload, CommonAuthorizationCodeRequest, AuthorizationCodeClient, CcsCredential, Logger, IPerformanceClient, ServerAuthorizationCodeResponse } from "@azure/msal-common";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager";
+import { AuthenticationResult } from "../response/AuthenticationResult";
+import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
+/**
+ * Abstract class which defines operations for a browser interaction handling class.
+ */
+export declare class InteractionHandler {
+    protected authModule: AuthorizationCodeClient;
+    protected browserStorage: BrowserCacheManager;
+    protected authCodeRequest: CommonAuthorizationCodeRequest;
+    protected logger: Logger;
+    protected performanceClient: IPerformanceClient;
+    constructor(authCodeModule: AuthorizationCodeClient, storageImpl: BrowserCacheManager, authCodeRequest: CommonAuthorizationCodeRequest, logger: Logger, performanceClient: IPerformanceClient);
+    /**
+     * Function to handle response parameters from hash.
+     * @param locationHash
+     */
+    handleCodeResponse(response: ServerAuthorizationCodeResponse, request: AuthorizationUrlRequest): Promise<AuthenticationResult>;
+    /**
+     * Process auth code response from AAD
+     * @param authCodeResponse
+     * @param state
+     * @param authority
+     * @param networkModule
+     * @returns
+     */
+    handleCodeResponseFromServer(authCodeResponse: AuthorizationCodePayload, request: AuthorizationUrlRequest, validateNonce?: boolean): Promise<AuthenticationResult>;
+    /**
+     * Build ccs creds if available
+     */
+    protected createCcsCredentials(request: AuthorizationUrlRequest): CcsCredential | null;
+}
 //# sourceMappingURL=InteractionHandler.d.ts.map

package/dist/interaction_handler/InteractionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InteractionHandler.d.ts","sourceRoot":"","sources":["../../src/interaction_handler/InteractionHandler.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,wBAAwB,EACxB,8BAA8B,EAC9B,uBAAuB,EACvB,aAAa,EACb,MAAM,EAEN,kBAAkB,EAIrB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAKnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E;;GAEG;AACH,qBAAa,kBAAkB;IAC3B,SAAS,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC9C,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC9C,SAAS,CAAC,eAAe,EAAE,8BAA8B,CAAC;IAC1D,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,iBAAiB,EAAE,kBAAkB,CAAC;gBAG5C,cAAc,EAAE,uBAAuB,EACvC,WAAW,EAAE,mBAAmB,EAChC,eAAe,EAAE,8BAA8B,EAC/C,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,kBAAkB;IASzC;;;OAGG;IACG,0BAA0B,CAC5B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,uBAAuB,GACjC,OAAO,CAAC,oBAAoB,CAAC;IAuChC;;;;;;;OAOG;IACG,4BAA4B,CAC9B,gBAAgB,EAAE,wBAAwB,EAC1C,OAAO,EAAE,uBAAuB,EAChC,aAAa,GAAE,OAAc,GAC9B,OAAO,CAAC,oBAAoB,CAAC;IAoDhC;;OAEG;IACH,SAAS,CAAC,oBAAoB,CAC1B,OAAO,EAAE,uBAAuB,GACjC,aAAa,GAAG,IAAI;CAe1B"}
+{"version":3,"file":"InteractionHandler.d.ts","sourceRoot":"","sources":["../../src/interaction_handler/InteractionHandler.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,wBAAwB,EACxB,8BAA8B,EAC9B,uBAAuB,EACvB,aAAa,EACb,MAAM,EAEN,kBAAkB,EAIlB,+BAA+B,EAClC,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAKnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E;;GAEG;AACH,qBAAa,kBAAkB;IAC3B,SAAS,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC9C,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC9C,SAAS,CAAC,eAAe,EAAE,8BAA8B,CAAC;IAC1D,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,iBAAiB,EAAE,kBAAkB,CAAC;gBAG5C,cAAc,EAAE,uBAAuB,EACvC,WAAW,EAAE,mBAAmB,EAChC,eAAe,EAAE,8BAA8B,EAC/C,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,kBAAkB;IASzC;;;OAGG;IACG,kBAAkB,CACpB,QAAQ,EAAE,+BAA+B,EACzC,OAAO,EAAE,uBAAuB,GACjC,OAAO,CAAC,oBAAoB,CAAC;IAmChC;;;;;;;OAOG;IACG,4BAA4B,CAC9B,gBAAgB,EAAE,wBAAwB,EAC1C,OAAO,EAAE,uBAAuB,EAChC,aAAa,GAAE,OAAc,GAC9B,OAAO,CAAC,oBAAoB,CAAC;IAoDhC;;OAEG;IACH,SAAS,CAAC,oBAAoB,CAC1B,OAAO,EAAE,uBAAuB,GACjC,aAAa,GAAG,IAAI;CAe1B"}