first commit

wangzhibo

2026-05-09 53418655c061ac26f66058253f39200aced1ab1d

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
/*! @azure/msal-browser v5.7.0 2026-04-16 */
'use strict';
import { AuthorizeProtocol, ServerError, invokeAsync, PerformanceEvents, CcsCredentialType } from '@azure/msal-common/browser';
import { AuthClientAcquireToken } from '../telemetry/BrowserPerformanceEvents.mjs';
import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
import { userCancelled } from '../error/BrowserAuthErrorCodes.mjs';
 
/* 
 * Copyright (c) Microsoft Corporation. All rights reserved. 
 * Licensed under the MIT License. 
 */ 
/** 
 * Abstract class which defines operations for a browser interaction handling class. 
 */ 
class InteractionHandler { 
    constructor(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient) { 
        this.authModule = authCodeModule; 
        this.browserStorage = storageImpl; 
        this.authCodeRequest = authCodeRequest; 
        this.logger = logger; 
        this.performanceClient = performanceClient; 
    } 
    /** 
     * Function to handle response parameters from hash. 
     * @param locationHash 
     */ 
    async handleCodeResponse(response, request, apiId) { 
        let authCodeResponse; 
        try { 
            authCodeResponse = AuthorizeProtocol.getAuthorizationCodePayload(response, request.state); 
        } 
        catch (e) { 
            if (e instanceof ServerError && 
                e.subError === userCancelled) { 
                // Translate server error caused by user closing native prompt to corresponding first class MSAL error 
                throw createBrowserAuthError(userCancelled); 
            } 
            else { 
                throw e; 
            } 
        } 
        return invokeAsync(this.handleCodeResponseFromServer.bind(this), PerformanceEvents.HandleCodeResponseFromServer, this.logger, this.performanceClient, request.correlationId)(authCodeResponse, request, apiId); 
    } 
    /** 
     * Process auth code response from AAD 
     * @param authCodeResponse 
     * @param request 
     * @param validateNonce 
     * @returns 
     */ 
    async handleCodeResponseFromServer(authCodeResponse, request, apiId, validateNonce = true) { 
        this.logger.trace("0mf2hb", request.correlationId); 
        // Assign code to request 
        this.authCodeRequest.code = authCodeResponse.code; 
        // Nonce validation not needed when redirect not involved (e.g. hybrid spa, renewing token via rt) 
        if (validateNonce) { 
            // TODO: Assigning "response nonce" to "request nonce" is confusing. Refactor the function doing validation to accept request nonce directly 
            authCodeResponse.nonce = request.nonce || undefined; 
        } 
        authCodeResponse.state = request.state; 
        // Add CCS parameters if available 
        if (authCodeResponse.client_info) { 
            this.authCodeRequest.clientInfo = authCodeResponse.client_info; 
        } 
        else { 
            const ccsCred = this.createCcsCredentials(request); 
            if (ccsCred) { 
                this.authCodeRequest.ccsCredential = ccsCred; 
            } 
        } 
        // Acquire token with retrieved code. 
        const tokenResponse = (await invokeAsync(this.authModule.acquireToken.bind(this.authModule), AuthClientAcquireToken, this.logger, this.performanceClient, request.correlationId)(this.authCodeRequest, apiId, authCodeResponse)); 
        return tokenResponse; 
    } 
    /** 
     * Build ccs creds if available 
     */ 
    createCcsCredentials(request) { 
        if (request.account) { 
            return { 
                credential: request.account.homeAccountId, 
                type: CcsCredentialType.HOME_ACCOUNT_ID, 
            }; 
        } 
        else if (request.loginHint) { 
            return { 
                credential: request.loginHint, 
                type: CcsCredentialType.UPN, 
            }; 
        } 
        return null; 
    } 
}
 
export { InteractionHandler };
//# sourceMappingURL=InteractionHandler.mjs.map