@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/interaction_client/SilentAuthCodeClient.d.ts

@@ -1,23 +1,23 @@
-import { AuthenticationResult, ICrypto, Logger, IPerformanceClient } from "@azure/msal-common";
-import { StandardInteractionClient } from "./StandardInteractionClient";
-import { BrowserConfiguration } from "../config/Configuration";
-import { BrowserCacheManager } from "../cache/BrowserCacheManager";
-import { EventHandler } from "../event/EventHandler";
-import { INavigationClient } from "../navigation/INavigationClient";
-import { ApiId } from "../utils/BrowserConstants";
-import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest";
-import { NativeMessageHandler } from "../broker/nativeBroker/NativeMessageHandler";
-export declare class SilentAuthCodeClient extends StandardInteractionClient {
-    private apiId;
-    constructor(config: BrowserConfiguration, storageImpl: BrowserCacheManager, browserCrypto: ICrypto, logger: Logger, eventHandler: EventHandler, navigationClient: INavigationClient, apiId: ApiId, performanceClient: IPerformanceClient, nativeMessageHandler?: NativeMessageHandler, correlationId?: string);
-    /**
-     * Acquires a token silently by redeeming an authorization code against the /token endpoint
-     * @param request
-     */
-    acquireToken(request: AuthorizationCodeRequest): Promise<AuthenticationResult>;
-    /**
-     * Currently Unsupported
-     */
-    logout(): Promise<void>;
-}
+import { AuthenticationResult, ICrypto, Logger, IPerformanceClient } from "@azure/msal-common";
+import { StandardInteractionClient } from "./StandardInteractionClient";
+import { BrowserConfiguration } from "../config/Configuration";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager";
+import { EventHandler } from "../event/EventHandler";
+import { INavigationClient } from "../navigation/INavigationClient";
+import { ApiId } from "../utils/BrowserConstants";
+import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest";
+import { NativeMessageHandler } from "../broker/nativeBroker/NativeMessageHandler";
+export declare class SilentAuthCodeClient extends StandardInteractionClient {
+    private apiId;
+    constructor(config: BrowserConfiguration, storageImpl: BrowserCacheManager, browserCrypto: ICrypto, logger: Logger, eventHandler: EventHandler, navigationClient: INavigationClient, apiId: ApiId, performanceClient: IPerformanceClient, nativeMessageHandler?: NativeMessageHandler, correlationId?: string);
+    /**
+     * Acquires a token silently by redeeming an authorization code against the /token endpoint
+     * @param request
+     */
+    acquireToken(request: AuthorizationCodeRequest): Promise<AuthenticationResult>;
+    /**
+     * Currently Unsupported
+     */
+    logout(): Promise<void>;
+}
 //# sourceMappingURL=SilentAuthCodeClient.d.ts.map

package/dist/interaction_client/SilentAuthCodeClient.js

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { PerformanceEvents, Constants, AuthError } from '@azure/msal-common';
 import { StandardInteractionClient } from './StandardInteractionClient.js';
@@ -7,67 +7,67 @@ import { InteractionType } from '../utils/BrowserConstants.js';
 import { SilentHandler } from '../interaction_handler/SilentHandler.js';
 import { HybridSpaAuthorizationCodeClient } from './HybridSpaAuthorizationCodeClient.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class SilentAuthCodeClient extends StandardInteractionClient {
-    constructor(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, apiId, performanceClient, nativeMessageHandler, correlationId) {
-        super(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, performanceClient, nativeMessageHandler, correlationId);
-        this.apiId = apiId;
-    }
-    /**
-     * Acquires a token silently by redeeming an authorization code against the /token endpoint
-     * @param request
-     */
-    async acquireToken(request) {
-        this.logger.trace("SilentAuthCodeClient.acquireToken called");
-        // Auth code payload is required
-        if (!request.code) {
-            throw BrowserAuthError.createAuthCodeRequiredError();
-        }
-        // Create silent request
-        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, request.correlationId);
-        const silentRequest = await this.initializeAuthorizationRequest(request, InteractionType.Silent);
-        this.browserStorage.updateCacheEntries(silentRequest.state, silentRequest.nonce, silentRequest.authority, silentRequest.loginHint || Constants.EMPTY_STRING, silentRequest.account || null);
-        const serverTelemetryManager = this.initializeServerTelemetryManager(this.apiId);
-        try {
-            // Create auth code request (PKCE not needed)
-            const authCodeRequest = {
-                ...silentRequest,
-                code: request.code,
-            };
-            // Initialize the client
-            this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, request.correlationId);
-            const clientConfig = await this.getClientConfiguration(serverTelemetryManager, silentRequest.authority);
-            const authClient = new HybridSpaAuthorizationCodeClient(clientConfig);
-            this.logger.verbose("Auth code client created");
-            // Create silent handler
-            const silentHandler = new SilentHandler(authClient, this.browserStorage, authCodeRequest, this.logger, this.config.system, this.performanceClient);
-            // Handle auth code parameters from request
-            return silentHandler.handleCodeResponseFromServer({
-                code: request.code,
-                msgraph_host: request.msGraphHost,
-                cloud_graph_host_name: request.cloudGraphHostName,
-                cloud_instance_host_name: request.cloudInstanceHostName,
-            }, silentRequest.state, authClient.authority, this.networkClient, false);
-        }
-        catch (e) {
-            if (e instanceof AuthError) {
-                e.setCorrelationId(this.correlationId);
-                serverTelemetryManager.cacheFailedRequest(e);
-            }
-            this.browserStorage.cleanRequestByState(silentRequest.state);
-            throw e;
-        }
-    }
-    /**
-     * Currently Unsupported
-     */
-    logout() {
-        // Synchronous so we must reject
-        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SilentAuthCodeClient extends StandardInteractionClient {
+    constructor(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, apiId, performanceClient, nativeMessageHandler, correlationId) {
+        super(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, performanceClient, nativeMessageHandler, correlationId);
+        this.apiId = apiId;
+    }
+    /**
+     * Acquires a token silently by redeeming an authorization code against the /token endpoint
+     * @param request
+     */
+    async acquireToken(request) {
+        this.logger.trace("SilentAuthCodeClient.acquireToken called");
+        // Auth code payload is required
+        if (!request.code) {
+            throw BrowserAuthError.createAuthCodeRequiredError();
+        }
+        // Create silent request
+        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest, request.correlationId);
+        const silentRequest = await this.initializeAuthorizationRequest(request, InteractionType.Silent);
+        this.browserStorage.updateCacheEntries(silentRequest.state, silentRequest.nonce, silentRequest.authority, silentRequest.loginHint || Constants.EMPTY_STRING, silentRequest.account || null);
+        const serverTelemetryManager = this.initializeServerTelemetryManager(this.apiId);
+        try {
+            // Create auth code request (PKCE not needed)
+            const authCodeRequest = {
+                ...silentRequest,
+                code: request.code,
+            };
+            // Initialize the client
+            this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, request.correlationId);
+            const clientConfig = await this.getClientConfiguration(serverTelemetryManager, silentRequest.authority);
+            const authClient = new HybridSpaAuthorizationCodeClient(clientConfig);
+            this.logger.verbose("Auth code client created");
+            // Create silent handler
+            const silentHandler = new SilentHandler(authClient, this.browserStorage, authCodeRequest, this.logger, this.config.system, this.performanceClient);
+            // Handle auth code parameters from request
+            return silentHandler.handleCodeResponseFromServer({
+                code: request.code,
+                msgraph_host: request.msGraphHost,
+                cloud_graph_host_name: request.cloudGraphHostName,
+                cloud_instance_host_name: request.cloudInstanceHostName,
+            }, silentRequest.state, authClient.authority, this.networkClient, false);
+        }
+        catch (e) {
+            if (e instanceof AuthError) {
+                e.setCorrelationId(this.correlationId);
+                serverTelemetryManager.cacheFailedRequest(e);
+            }
+            this.browserStorage.cleanRequestByState(silentRequest.state);
+            throw e;
+        }
+    }
+    /**
+     * Currently Unsupported
+     */
+    logout() {
+        // Synchronous so we must reject
+        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
+    }
 }
 
 export { SilentAuthCodeClient };

package/dist/interaction_client/SilentCacheClient.d.ts

@@ -1,22 +1,22 @@
-import { StandardInteractionClient } from "./StandardInteractionClient";
-import { CommonSilentFlowRequest, AuthenticationResult, SilentFlowClient, ServerTelemetryManager, AccountInfo, AzureCloudOptions } from "@azure/msal-common";
-import { SilentRequest } from "../request/SilentRequest";
-export declare class SilentCacheClient extends StandardInteractionClient {
-    /**
-     * Returns unexpired tokens from the cache, if available
-     * @param silentRequest
-     */
-    acquireToken(silentRequest: CommonSilentFlowRequest): Promise<AuthenticationResult>;
-    /**
-     * Currently Unsupported
-     */
-    logout(): Promise<void>;
-    /**
-     * Creates an Silent Flow Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    protected createSilentFlowClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, azureCloudOptions?: AzureCloudOptions): Promise<SilentFlowClient>;
-    initializeSilentRequest(request: SilentRequest, account: AccountInfo): Promise<CommonSilentFlowRequest>;
-}
+import { StandardInteractionClient } from "./StandardInteractionClient";
+import { CommonSilentFlowRequest, AuthenticationResult, SilentFlowClient, ServerTelemetryManager, AccountInfo, AzureCloudOptions } from "@azure/msal-common";
+import { SilentRequest } from "../request/SilentRequest";
+export declare class SilentCacheClient extends StandardInteractionClient {
+    /**
+     * Returns unexpired tokens from the cache, if available
+     * @param silentRequest
+     */
+    acquireToken(silentRequest: CommonSilentFlowRequest): Promise<AuthenticationResult>;
+    /**
+     * Currently Unsupported
+     */
+    logout(): Promise<void>;
+    /**
+     * Creates an Silent Flow Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    protected createSilentFlowClient(serverTelemetryManager: ServerTelemetryManager, authorityUrl?: string, azureCloudOptions?: AzureCloudOptions): Promise<SilentFlowClient>;
+    initializeSilentRequest(request: SilentRequest, account: AccountInfo): Promise<CommonSilentFlowRequest>;
+}
 //# sourceMappingURL=SilentCacheClient.d.ts.map

package/dist/interaction_client/SilentCacheClient.js

@@ -1,76 +1,76 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { StandardInteractionClient } from './StandardInteractionClient.js';
 import { PerformanceEvents, AuthError, SilentFlowClient } from '@azure/msal-common';
 import { ApiId } from '../utils/BrowserConstants.js';
 import { BrowserAuthError, BrowserAuthErrorMessage } from '../error/BrowserAuthError.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class SilentCacheClient extends StandardInteractionClient {
-    /**
-     * Returns unexpired tokens from the cache, if available
-     * @param silentRequest
-     */
-    async acquireToken(silentRequest) {
-        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentCacheClientAcquireToken, silentRequest.correlationId);
-        // Telemetry manager only used to increment cacheHits here
-        const serverTelemetryManager = this.initializeServerTelemetryManager(ApiId.acquireTokenSilent_silentFlow);
-        const silentAuthClient = await this.createSilentFlowClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
-        this.logger.verbose("Silent auth client created");
-        try {
-            const cachedToken = await silentAuthClient.acquireCachedToken(silentRequest);
-            acquireTokenMeasurement.endMeasurement({
-                success: true,
-                fromCache: true,
-            });
-            return cachedToken;
-        }
-        catch (error) {
-            if (error instanceof BrowserAuthError &&
-                error.errorCode ===
-                    BrowserAuthErrorMessage.signingKeyNotFoundInStorage.code) {
-                this.logger.verbose("Signing keypair for bound access token not found. Refreshing bound access token and generating a new crypto keypair.");
-            }
-            acquireTokenMeasurement.endMeasurement({
-                errorCode: (error instanceof AuthError && error.errorCode) ||
-                    undefined,
-                subErrorCode: (error instanceof AuthError && error.subError) || undefined,
-                success: false,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Currently Unsupported
-     */
-    logout() {
-        // Synchronous so we must reject
-        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
-    }
-    /**
-     * Creates an Silent Flow Client with the given authority, or the default authority.
-     * @param serverTelemetryManager
-     * @param authorityUrl
-     */
-    async createSilentFlowClient(serverTelemetryManager, authorityUrl, azureCloudOptions) {
-        // Create auth module.
-        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
-        const clientConfig = await this.getClientConfiguration(serverTelemetryManager, authorityUrl, azureCloudOptions);
-        return new SilentFlowClient(clientConfig, this.performanceClient);
-    }
-    async initializeSilentRequest(request, account) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.InitializeSilentRequest, this.correlationId);
-        this.performanceClient.setPreQueueTime(PerformanceEvents.InitializeBaseRequest, this.correlationId);
-        return {
-            ...request,
-            ...(await this.initializeBaseRequest(request)),
-            account: account,
-            forceRefresh: request.forceRefresh || false,
-        };
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SilentCacheClient extends StandardInteractionClient {
+    /**
+     * Returns unexpired tokens from the cache, if available
+     * @param silentRequest
+     */
+    async acquireToken(silentRequest) {
+        const acquireTokenMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SilentCacheClientAcquireToken, silentRequest.correlationId);
+        // Telemetry manager only used to increment cacheHits here
+        const serverTelemetryManager = this.initializeServerTelemetryManager(ApiId.acquireTokenSilent_silentFlow);
+        const silentAuthClient = await this.createSilentFlowClient(serverTelemetryManager, silentRequest.authority, silentRequest.azureCloudOptions);
+        this.logger.verbose("Silent auth client created");
+        try {
+            const cachedToken = await silentAuthClient.acquireCachedToken(silentRequest);
+            acquireTokenMeasurement.endMeasurement({
+                success: true,
+                fromCache: true,
+            });
+            return cachedToken;
+        }
+        catch (error) {
+            if (error instanceof BrowserAuthError &&
+                error.errorCode ===
+                    BrowserAuthErrorMessage.signingKeyNotFoundInStorage.code) {
+                this.logger.verbose("Signing keypair for bound access token not found. Refreshing bound access token and generating a new crypto keypair.");
+            }
+            acquireTokenMeasurement.endMeasurement({
+                errorCode: (error instanceof AuthError && error.errorCode) ||
+                    undefined,
+                subErrorCode: (error instanceof AuthError && error.subError) || undefined,
+                success: false,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Currently Unsupported
+     */
+    logout() {
+        // Synchronous so we must reject
+        return Promise.reject(BrowserAuthError.createSilentLogoutUnsupportedError());
+    }
+    /**
+     * Creates an Silent Flow Client with the given authority, or the default authority.
+     * @param serverTelemetryManager
+     * @param authorityUrl
+     */
+    async createSilentFlowClient(serverTelemetryManager, authorityUrl, azureCloudOptions) {
+        // Create auth module.
+        this.performanceClient.setPreQueueTime(PerformanceEvents.StandardInteractionClientGetClientConfiguration, this.correlationId);
+        const clientConfig = await this.getClientConfiguration(serverTelemetryManager, authorityUrl, azureCloudOptions);
+        return new SilentFlowClient(clientConfig, this.performanceClient);
+    }
+    async initializeSilentRequest(request, account) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.InitializeSilentRequest, this.correlationId);
+        this.performanceClient.setPreQueueTime(PerformanceEvents.InitializeBaseRequest, this.correlationId);
+        return {
+            ...request,
+            ...(await this.initializeBaseRequest(request)),
+            account: account,
+            forceRefresh: request.forceRefresh || false,
+        };
+    }
 }
 
 export { SilentCacheClient };

package/dist/interaction_client/SilentIframeClient.d.ts

@@ -1,32 +1,32 @@
-import { AuthenticationResult, ICrypto, Logger, AuthorizationCodeClient, IPerformanceClient } from "@azure/msal-common";
-import { StandardInteractionClient } from "./StandardInteractionClient";
-import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
-import { BrowserConfiguration } from "../config/Configuration";
-import { BrowserCacheManager } from "../cache/BrowserCacheManager";
-import { EventHandler } from "../event/EventHandler";
-import { INavigationClient } from "../navigation/INavigationClient";
-import { ApiId } from "../utils/BrowserConstants";
-import { SsoSilentRequest } from "../request/SsoSilentRequest";
-import { NativeMessageHandler } from "../broker/nativeBroker/NativeMessageHandler";
-export declare class SilentIframeClient extends StandardInteractionClient {
-    protected apiId: ApiId;
-    protected nativeStorage: BrowserCacheManager;
-    constructor(config: BrowserConfiguration, storageImpl: BrowserCacheManager, browserCrypto: ICrypto, logger: Logger, eventHandler: EventHandler, navigationClient: INavigationClient, apiId: ApiId, performanceClient: IPerformanceClient, nativeStorageImpl: BrowserCacheManager, nativeMessageHandler?: NativeMessageHandler, correlationId?: string);
-    /**
-     * Acquires a token silently by opening a hidden iframe to the /authorize endpoint with prompt=none or prompt=no_session
-     * @param request
-     */
-    acquireToken(request: SsoSilentRequest): Promise<AuthenticationResult>;
-    /**
-     * Currently Unsupported
-     */
-    logout(): Promise<void>;
-    /**
-     * Helper which acquires an authorization code silently using a hidden iframe from given url
-     * using the scopes requested as part of the id, and exchanges the code for a set of OAuth tokens.
-     * @param navigateUrl
-     * @param userRequestScopes
-     */
-    protected silentTokenHelper(authClient: AuthorizationCodeClient, silentRequest: AuthorizationUrlRequest): Promise<AuthenticationResult>;
-}
+import { AuthenticationResult, ICrypto, Logger, AuthorizationCodeClient, IPerformanceClient } from "@azure/msal-common";
+import { StandardInteractionClient } from "./StandardInteractionClient";
+import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest";
+import { BrowserConfiguration } from "../config/Configuration";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager";
+import { EventHandler } from "../event/EventHandler";
+import { INavigationClient } from "../navigation/INavigationClient";
+import { ApiId } from "../utils/BrowserConstants";
+import { SsoSilentRequest } from "../request/SsoSilentRequest";
+import { NativeMessageHandler } from "../broker/nativeBroker/NativeMessageHandler";
+export declare class SilentIframeClient extends StandardInteractionClient {
+    protected apiId: ApiId;
+    protected nativeStorage: BrowserCacheManager;
+    constructor(config: BrowserConfiguration, storageImpl: BrowserCacheManager, browserCrypto: ICrypto, logger: Logger, eventHandler: EventHandler, navigationClient: INavigationClient, apiId: ApiId, performanceClient: IPerformanceClient, nativeStorageImpl: BrowserCacheManager, nativeMessageHandler?: NativeMessageHandler, correlationId?: string);
+    /**
+     * Acquires a token silently by opening a hidden iframe to the /authorize endpoint with prompt=none or prompt=no_session
+     * @param request
+     */
+    acquireToken(request: SsoSilentRequest): Promise<AuthenticationResult>;
+    /**
+     * Currently Unsupported
+     */
+    logout(): Promise<void>;
+    /**
+     * Helper which acquires an authorization code silently using a hidden iframe from given url
+     * using the scopes requested as part of the id, and exchanges the code for a set of OAuth tokens.
+     * @param navigateUrl
+     * @param userRequestScopes
+     */
+    protected silentTokenHelper(authClient: AuthorizationCodeClient, silentRequest: AuthorizationUrlRequest): Promise<AuthenticationResult>;
+}
 //# sourceMappingURL=SilentIframeClient.d.ts.map