@azure/msal-angular 2.5.4 → 2.5.6

package/esm2015/msal.interceptor.js

@@ -1,230 +1,230 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-import { Location, DOCUMENT } from "@angular/common";
-import { EMPTY, of } from "rxjs";
-import { switchMap, catchError, take, filter } from "rxjs/operators";
-import { MsalService } from "./msal.service";
-import { BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, UrlString } from "@azure/msal-browser";
-import { Injectable, Inject } from "@angular/core";
-import { MSAL_INTERCEPTOR_CONFIG } from "./constants";
-import { MsalBroadcastService } from "./msal.broadcast.service";
-export class MsalInterceptor {
-    constructor(msalInterceptorConfig, authService, location, msalBroadcastService, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    document) {
-        this.msalInterceptorConfig = msalInterceptorConfig;
-        this.authService = authService;
-        this.location = location;
-        this.msalBroadcastService = msalBroadcastService;
-        this._document = document;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    intercept(req, next) {
-        if (this.msalInterceptorConfig.interactionType !== InteractionType.Popup && this.msalInterceptorConfig.interactionType !== InteractionType.Redirect) {
-            throw new BrowserConfigurationAuthError("invalid_interaction_type", "Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration");
-        }
-        this.authService.getLogger().verbose("MSAL Interceptor activated");
-        const scopes = this.getScopesForEndpoint(req.url, req.method);
-        // If no scopes for endpoint, does not acquire token
-        if (!scopes || scopes.length === 0) {
-            this.authService.getLogger().verbose("Interceptor - no scopes for endpoint");
-            return next.handle(req);
-        }
-        // Sets account as active account or first account
-        let account;
-        if (!!this.authService.instance.getActiveAccount()) {
-            this.authService.getLogger().verbose("Interceptor - active account selected");
-            account = this.authService.instance.getActiveAccount();
-        }
-        else {
-            this.authService.getLogger().verbose("Interceptor - no active account, fallback to first account");
-            account = this.authService.instance.getAllAccounts()[0];
-        }
-        const authRequest = typeof this.msalInterceptorConfig.authRequest === "function"
-            ? this.msalInterceptorConfig.authRequest(this.authService, req, { account: account })
-            : Object.assign(Object.assign({}, this.msalInterceptorConfig.authRequest), { account });
-        this.authService.getLogger().info(`Interceptor - ${scopes.length} scopes found for endpoint`);
-        this.authService.getLogger().infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);
-        return this.acquireToken(authRequest, scopes, account)
-            .pipe(switchMap((result) => {
-            this.authService.getLogger().verbose("Interceptor - setting authorization headers");
-            const headers = req.headers
-                .set("Authorization", `Bearer ${result.accessToken}`);
-            const requestClone = req.clone({ headers });
-            return next.handle(requestClone);
-        }));
-    }
-    /**
-     * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token
-     * @param authRequest Request
-     * @param scopes Array of scopes for the request
-     * @param account Account
-     * @returns Authentication result
-     */
-    acquireToken(authRequest, scopes, account) {
-        // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken
-        return this.authService.acquireTokenSilent(Object.assign(Object.assign({}, authRequest), { scopes, account }))
-            .pipe(catchError(() => {
-            this.authService.getLogger().error("Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.");
-            return this.msalBroadcastService.inProgress$
-                .pipe(take(1), switchMap((status) => {
-                if (status === InteractionStatus.None) {
-                    return this.acquireTokenInteractively(authRequest, scopes);
-                }
-                return this.msalBroadcastService.inProgress$
-                    .pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireToken(authRequest, scopes, account)));
-            }));
-        }), switchMap((result) => {
-            if (!result.accessToken) {
-                this.authService.getLogger().error("Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.");
-                return this.msalBroadcastService.inProgress$
-                    .pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireTokenInteractively(authRequest, scopes)));
-            }
-            return of(result);
-        }));
-    }
-    /**
-     * Invoke interaction for the given set of scopes
-     * @param authRequest Request
-     * @param scopes Array of scopes for the request
-     * @returns Result from the interactive request
-     */
-    acquireTokenInteractively(authRequest, scopes) {
-        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {
-            this.authService.getLogger().verbose("Interceptor - error acquiring token silently, acquiring by popup");
-            return this.authService.acquireTokenPopup(Object.assign(Object.assign({}, authRequest), { scopes }));
-        }
-        this.authService.getLogger().verbose("Interceptor - error acquiring token silently, acquiring by redirect");
-        const redirectStartPage = window.location.href;
-        this.authService.acquireTokenRedirect(Object.assign(Object.assign({}, authRequest), { scopes, redirectStartPage }));
-        return EMPTY;
-    }
-    /**
-     * Looks up the scopes for the given endpoint from the protectedResourceMap
-     * @param endpoint Url of the request
-     * @param httpMethod Http method of the request
-     * @returns Array of scopes, or null if not found
-     *
-     */
-    getScopesForEndpoint(endpoint, httpMethod) {
-        this.authService.getLogger().verbose("Interceptor - getting scopes for endpoint");
-        // Ensures endpoints and protected resources compared are normalized
-        const normalizedEndpoint = this.location.normalize(endpoint);
-        const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());
-        const matchingProtectedResources = this.matchResourcesToEndpoint(protectedResourcesArray, normalizedEndpoint);
-        // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls
-        if (matchingProtectedResources.absoluteResources.length > 0) {
-            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.absoluteResources, httpMethod);
-        }
-        else if (matchingProtectedResources.relativeResources.length > 0) {
-            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.relativeResources, httpMethod);
-        }
-        return null;
-    }
-    /**
-     * Finds resource endpoints that match request endpoint
-     * @param protectedResourcesEndpoints
-     * @param endpoint
-     * @returns
-     */
-    matchResourcesToEndpoint(protectedResourcesEndpoints, endpoint) {
-        const matchingResources = { absoluteResources: [], relativeResources: [] };
-        protectedResourcesEndpoints.forEach(key => {
-            // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards
-            const normalizedKey = this.location.normalize(key);
-            if (StringUtils.matchPattern(normalizedKey, endpoint)) {
-                matchingResources.absoluteResources.push(key);
-            }
-            // Get url components for relative urls
-            const absoluteKey = this.getAbsoluteUrl(key);
-            const keyComponents = new UrlString(absoluteKey).getUrlComponents();
-            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);
-            const endpointComponents = new UrlString(absoluteEndpoint).getUrlComponents();
-            // Normalized key should include query strings if applicable
-            const relativeNormalizedKey = keyComponents.QueryString ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}` : this.location.normalize(keyComponents.AbsolutePath);
-            // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty
-            if (keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort && StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) && relativeNormalizedKey !== "" && relativeNormalizedKey !== "/*") {
-                matchingResources.relativeResources.push(key);
-            }
-        });
-        return matchingResources;
-    }
-    /**
-     * Transforms relative urls to absolute urls
-     * @param url
-     * @returns
-     */
-    getAbsoluteUrl(url) {
-        const link = this._document.createElement("a");
-        link.href = url;
-        return link.href;
-    }
-    /**
-     * Finds scopes from first matching endpoint with HTTP method that matches request
-     * @param protectedResourceMap Protected resource map
-     * @param endpointArray Array of resources that match request endpoint
-     * @param httpMethod Http method of the request
-     * @returns
-     */
-    matchScopesToEndpoint(protectedResourceMap, endpointArray, httpMethod) {
-        const allMatchedScopes = [];
-        // Check each matched endpoint for matching HttpMethod and scopes
-        endpointArray.forEach(matchedEndpoint => {
-            const scopesForEndpoint = [];
-            const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);
-            // Return if resource is unprotected
-            if (methodAndScopesArray === null) {
-                allMatchedScopes.push(null);
-                return;
-            }
-            methodAndScopesArray.forEach(entry => {
-                // Entry is either array of scopes or ProtectedResourceScopes object
-                if (typeof entry === "string") {
-                    scopesForEndpoint.push(entry);
-                }
-                else {
-                    // Ensure methods being compared are normalized
-                    const normalizedRequestMethod = httpMethod.toLowerCase();
-                    const normalizedResourceMethod = entry.httpMethod.toLowerCase();
-                    // Method in protectedResourceMap matches request http method
-                    if (normalizedResourceMethod === normalizedRequestMethod) {
-                        // Validate if scopes comes null to unprotect the resource in a certain http method
-                        if (entry.scopes === null) {
-                            allMatchedScopes.push(null);
-                        }
-                        else {
-                            entry.scopes.forEach((scope) => {
-                                scopesForEndpoint.push(scope);
-                            });
-                        }
-                    }
-                }
-            });
-            // Only add to all scopes if scopes for endpoint and method is found
-            if (scopesForEndpoint.length > 0) {
-                allMatchedScopes.push(scopesForEndpoint);
-            }
-        });
-        if (allMatchedScopes.length > 0) {
-            if (allMatchedScopes.length > 1) {
-                this.authService.getLogger().warning("Interceptor - More than 1 matching scopes for endpoint found.");
-            }
-            // Returns scopes for first matching endpoint
-            return allMatchedScopes[0];
-        }
-        return null;
-    }
-}
-MsalInterceptor.decorators = [
-    { type: Injectable }
-];
-MsalInterceptor.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [MSAL_INTERCEPTOR_CONFIG,] }] },
-    { type: MsalService },
-    { type: Location },
-    { type: MsalBroadcastService },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.interceptor.js","sourceRoot":"","sources":["../../src/msal.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n    HttpRequest,\n    HttpHandler,\n    HttpEvent,\n    HttpInterceptor\n} from \"@angular/common/http\";\nimport { Location, DOCUMENT } from \"@angular/common\";\nimport { Observable, EMPTY, of } from \"rxjs\";\nimport { switchMap, catchError, take, filter } from \"rxjs/operators\";\nimport { MsalService } from \"./msal.service\";\nimport { AccountInfo, AuthenticationResult, BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, UrlString } from \"@azure/msal-browser\";\nimport { Injectable, Inject } from \"@angular/core\";\nimport { MSAL_INTERCEPTOR_CONFIG } from \"./constants\";\nimport { MsalInterceptorAuthRequest, MsalInterceptorConfiguration, ProtectedResourceScopes, MatchingResources } from \"./msal.interceptor.config\";\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\n\n@Injectable()\nexport class MsalInterceptor implements HttpInterceptor {\n    private _document?: Document;\n\n    constructor(\n        @Inject(MSAL_INTERCEPTOR_CONFIG) private msalInterceptorConfig: MsalInterceptorConfiguration,\n        private authService: MsalService,\n        private location: Location,\n        private msalBroadcastService: MsalBroadcastService,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n        @Inject(DOCUMENT) document?: any\n    ) {\n        this._document = document as Document;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        if (this.msalInterceptorConfig.interactionType !== InteractionType.Popup && this.msalInterceptorConfig.interactionType !== InteractionType.Redirect) {\n            throw new BrowserConfigurationAuthError(\"invalid_interaction_type\", \"Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration\");\n        }\n\n        this.authService.getLogger().verbose(\"MSAL Interceptor activated\");\n        const scopes = this.getScopesForEndpoint(req.url, req.method);\n\n        // If no scopes for endpoint, does not acquire token\n        if (!scopes || scopes.length === 0) {\n            this.authService.getLogger().verbose(\"Interceptor - no scopes for endpoint\");\n            return next.handle(req);\n        }\n\n        // Sets account as active account or first account\n        let account: AccountInfo;\n        if (!!this.authService.instance.getActiveAccount()) {\n            this.authService.getLogger().verbose(\"Interceptor - active account selected\");\n            account = this.authService.instance.getActiveAccount();\n        } else {\n            this.authService.getLogger().verbose(\"Interceptor - no active account, fallback to first account\");\n            account = this.authService.instance.getAllAccounts()[0];\n        }\n\n        const authRequest = typeof this.msalInterceptorConfig.authRequest === \"function\"\n            ? this.msalInterceptorConfig.authRequest(this.authService, req, { account: account })\n            : { ...this.msalInterceptorConfig.authRequest, account };\n\n        this.authService.getLogger().info(`Interceptor - ${scopes.length} scopes found for endpoint`);\n        this.authService.getLogger().infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);\n\n        return this.acquireToken(authRequest, scopes, account)\n            .pipe(\n                switchMap((result: AuthenticationResult) => {\n                    this.authService.getLogger().verbose(\"Interceptor - setting authorization headers\");\n                    const headers = req.headers\n                        .set(\"Authorization\", `Bearer ${result.accessToken}`);\n\n                    const requestClone = req.clone({headers});\n                    return next.handle(requestClone);\n                })\n            );\n    }\n\n    /**\n     * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token\n     * @param authRequest Request\n     * @param scopes Array of scopes for the request\n     * @param account Account\n     * @returns Authentication result\n     */\n    private acquireToken(authRequest: MsalInterceptorAuthRequest, scopes: string[], account: AccountInfo): Observable<AuthenticationResult> {\n        // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\n        return this.authService.acquireTokenSilent({...authRequest, scopes, account })\n            .pipe(\n                catchError(() => {\n                    this.authService.getLogger().error(\"Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.\");\n                    return this.msalBroadcastService.inProgress$\n                        .pipe(\n                            take(1),\n                            switchMap((status: InteractionStatus) => {\n                                if (status === InteractionStatus.None) {\n                                    return this.acquireTokenInteractively(authRequest, scopes);\n                                }\n\n                                return this.msalBroadcastService.inProgress$\n                                    .pipe(\n                                        filter((status: InteractionStatus) => status === InteractionStatus.None),\n                                        take(1),\n                                        switchMap(() => this.acquireToken(authRequest, scopes, account))\n                                    );\n                            })\n                        );\n                }),\n                switchMap((result: AuthenticationResult)  => {\n                    if (!result.accessToken) {\n                        this.authService.getLogger().error(\"Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.\");\n                        return this.msalBroadcastService.inProgress$\n                            .pipe(\n                                filter((status: InteractionStatus) => status === InteractionStatus.None),\n                                take(1),\n                                switchMap(() => this.acquireTokenInteractively(authRequest, scopes))\n                            );\n                    }\n                    return of(result);\n                })\n            );\n    }\n\n    /**\n     * Invoke interaction for the given set of scopes\n     * @param authRequest Request\n     * @param scopes Array of scopes for the request\n     * @returns Result from the interactive request\n     */\n    private acquireTokenInteractively(authRequest: MsalInterceptorAuthRequest, scopes: string[]): Observable<AuthenticationResult> {\n        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\n            this.authService.getLogger().verbose(\"Interceptor - error acquiring token silently, acquiring by popup\");\n            return this.authService.acquireTokenPopup({ ...authRequest, scopes });\n        }\n        this.authService.getLogger().verbose(\"Interceptor - error acquiring token silently, acquiring by redirect\");\n        const redirectStartPage = window.location.href;\n        this.authService.acquireTokenRedirect({...authRequest, scopes, redirectStartPage });\n        return EMPTY;\n    }\n\n    /**\n     * Looks up the scopes for the given endpoint from the protectedResourceMap\n     * @param endpoint Url of the request\n     * @param httpMethod Http method of the request\n     * @returns Array of scopes, or null if not found\n     *\n     */\n    private getScopesForEndpoint(endpoint: string, httpMethod: string): Array<string>|null {\n        this.authService.getLogger().verbose(\"Interceptor - getting scopes for endpoint\");\n\n        // Ensures endpoints and protected resources compared are normalized\n        const normalizedEndpoint = this.location.normalize(endpoint);\n\n        const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());\n\n        const matchingProtectedResources = this.matchResourcesToEndpoint(protectedResourcesArray, normalizedEndpoint);\n\n        // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls\n        if (matchingProtectedResources.absoluteResources.length > 0) {\n            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.absoluteResources, httpMethod);\n        } else if (matchingProtectedResources.relativeResources.length > 0){\n            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.relativeResources, httpMethod);\n        }\n\n        return null;\n    }\n\n    /**\n     * Finds resource endpoints that match request endpoint\n     * @param protectedResourcesEndpoints\n     * @param endpoint\n     * @returns\n     */\n    private matchResourcesToEndpoint(protectedResourcesEndpoints: string[], endpoint: string): MatchingResources {\n        const matchingResources: MatchingResources = {absoluteResources: [], relativeResources: []};\n\n        protectedResourcesEndpoints.forEach(key => {\n            // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards\n            const normalizedKey = this.location.normalize(key);\n            if (StringUtils.matchPattern(normalizedKey, endpoint)){\n                matchingResources.absoluteResources.push(key);\n            }\n\n            // Get url components for relative urls\n            const absoluteKey = this.getAbsoluteUrl(key);\n            const keyComponents = new UrlString(absoluteKey).getUrlComponents();\n            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);\n            const endpointComponents = new UrlString(absoluteEndpoint).getUrlComponents();\n\n            // Normalized key should include query strings if applicable\n            const relativeNormalizedKey = keyComponents.QueryString ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}` : this.location.normalize(keyComponents.AbsolutePath);\n\n            // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty\n            if (keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort && StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) && relativeNormalizedKey !== \"\" && relativeNormalizedKey !== \"/*\"){\n                matchingResources.relativeResources.push(key);\n            }\n        });\n\n        return matchingResources;\n    }\n\n    /**\n     * Transforms relative urls to absolute urls\n     * @param url\n     * @returns\n     */\n    private getAbsoluteUrl(url: string): string {\n        const link = this._document.createElement(\"a\");\n        link.href = url;\n        return link.href;\n    }\n\n    /**\n     * Finds scopes from first matching endpoint with HTTP method that matches request\n     * @param protectedResourceMap Protected resource map\n     * @param endpointArray Array of resources that match request endpoint\n     * @param httpMethod Http method of the request\n     * @returns\n     */\n    private matchScopesToEndpoint(protectedResourceMap: Map<string, Array<string|ProtectedResourceScopes> | null>, endpointArray: string[], httpMethod: string): Array<string>|null {\n        const allMatchedScopes = [];\n\n        // Check each matched endpoint for matching HttpMethod and scopes\n        endpointArray.forEach(matchedEndpoint => {\n            const scopesForEndpoint = [];\n            const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);\n\n            // Return if resource is unprotected\n            if (methodAndScopesArray === null) {\n                allMatchedScopes.push(null);\n                return;\n            }\n\n            methodAndScopesArray.forEach(entry => {\n                // Entry is either array of scopes or ProtectedResourceScopes object\n                if (typeof entry === \"string\") {\n                    scopesForEndpoint.push(entry);\n                } else {\n                    // Ensure methods being compared are normalized\n                    const normalizedRequestMethod = httpMethod.toLowerCase();\n                    const normalizedResourceMethod = entry.httpMethod.toLowerCase();\n                    // Method in protectedResourceMap matches request http method\n                    if (normalizedResourceMethod === normalizedRequestMethod) {\n                        // Validate if scopes comes null to unprotect the resource in a certain http method\n                        if (entry.scopes === null) {\n                            allMatchedScopes.push(null);\n                        } else {\n                            entry.scopes.forEach((scope) => {\n                                scopesForEndpoint.push(scope);\n                            });\n                        }\n                    }\n                }\n            });\n\n            // Only add to all scopes if scopes for endpoint and method is found\n            if (scopesForEndpoint.length > 0) {\n                allMatchedScopes.push(scopesForEndpoint);\n            }\n        });\n\n        if (allMatchedScopes.length > 0) {\n            if (allMatchedScopes.length > 1) {\n                this.authService.getLogger().warning(\"Interceptor - More than 1 matching scopes for endpoint found.\");\n            }\n            // Returns scopes for first matching endpoint\n            return allMatchedScopes[0];\n        }\n\n        return null;\n    }\n\n}\n"]}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Location, DOCUMENT } from "@angular/common";
+import { EMPTY, of } from "rxjs";
+import { switchMap, catchError, take, filter } from "rxjs/operators";
+import { MsalService } from "./msal.service";
+import { BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, UrlString } from "@azure/msal-browser";
+import { Injectable, Inject } from "@angular/core";
+import { MSAL_INTERCEPTOR_CONFIG } from "./constants";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+export class MsalInterceptor {
+    constructor(msalInterceptorConfig, authService, location, msalBroadcastService, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    document) {
+        this.msalInterceptorConfig = msalInterceptorConfig;
+        this.authService = authService;
+        this.location = location;
+        this.msalBroadcastService = msalBroadcastService;
+        this._document = document;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    intercept(req, next) {
+        if (this.msalInterceptorConfig.interactionType !== InteractionType.Popup && this.msalInterceptorConfig.interactionType !== InteractionType.Redirect) {
+            throw new BrowserConfigurationAuthError("invalid_interaction_type", "Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration");
+        }
+        this.authService.getLogger().verbose("MSAL Interceptor activated");
+        const scopes = this.getScopesForEndpoint(req.url, req.method);
+        // If no scopes for endpoint, does not acquire token
+        if (!scopes || scopes.length === 0) {
+            this.authService.getLogger().verbose("Interceptor - no scopes for endpoint");
+            return next.handle(req);
+        }
+        // Sets account as active account or first account
+        let account;
+        if (!!this.authService.instance.getActiveAccount()) {
+            this.authService.getLogger().verbose("Interceptor - active account selected");
+            account = this.authService.instance.getActiveAccount();
+        }
+        else {
+            this.authService.getLogger().verbose("Interceptor - no active account, fallback to first account");
+            account = this.authService.instance.getAllAccounts()[0];
+        }
+        const authRequest = typeof this.msalInterceptorConfig.authRequest === "function"
+            ? this.msalInterceptorConfig.authRequest(this.authService, req, { account: account })
+            : Object.assign(Object.assign({}, this.msalInterceptorConfig.authRequest), { account });
+        this.authService.getLogger().info(`Interceptor - ${scopes.length} scopes found for endpoint`);
+        this.authService.getLogger().infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);
+        return this.acquireToken(authRequest, scopes, account)
+            .pipe(switchMap((result) => {
+            this.authService.getLogger().verbose("Interceptor - setting authorization headers");
+            const headers = req.headers
+                .set("Authorization", `Bearer ${result.accessToken}`);
+            const requestClone = req.clone({ headers });
+            return next.handle(requestClone);
+        }));
+    }
+    /**
+     * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token
+     * @param authRequest Request
+     * @param scopes Array of scopes for the request
+     * @param account Account
+     * @returns Authentication result
+     */
+    acquireToken(authRequest, scopes, account) {
+        // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken
+        return this.authService.acquireTokenSilent(Object.assign(Object.assign({}, authRequest), { scopes, account }))
+            .pipe(catchError(() => {
+            this.authService.getLogger().error("Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.");
+            return this.msalBroadcastService.inProgress$
+                .pipe(take(1), switchMap((status) => {
+                if (status === InteractionStatus.None) {
+                    return this.acquireTokenInteractively(authRequest, scopes);
+                }
+                return this.msalBroadcastService.inProgress$
+                    .pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireToken(authRequest, scopes, account)));
+            }));
+        }), switchMap((result) => {
+            if (!result.accessToken) {
+                this.authService.getLogger().error("Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.");
+                return this.msalBroadcastService.inProgress$
+                    .pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireTokenInteractively(authRequest, scopes)));
+            }
+            return of(result);
+        }));
+    }
+    /**
+     * Invoke interaction for the given set of scopes
+     * @param authRequest Request
+     * @param scopes Array of scopes for the request
+     * @returns Result from the interactive request
+     */
+    acquireTokenInteractively(authRequest, scopes) {
+        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {
+            this.authService.getLogger().verbose("Interceptor - error acquiring token silently, acquiring by popup");
+            return this.authService.acquireTokenPopup(Object.assign(Object.assign({}, authRequest), { scopes }));
+        }
+        this.authService.getLogger().verbose("Interceptor - error acquiring token silently, acquiring by redirect");
+        const redirectStartPage = window.location.href;
+        this.authService.acquireTokenRedirect(Object.assign(Object.assign({}, authRequest), { scopes, redirectStartPage }));
+        return EMPTY;
+    }
+    /**
+     * Looks up the scopes for the given endpoint from the protectedResourceMap
+     * @param endpoint Url of the request
+     * @param httpMethod Http method of the request
+     * @returns Array of scopes, or null if not found
+     *
+     */
+    getScopesForEndpoint(endpoint, httpMethod) {
+        this.authService.getLogger().verbose("Interceptor - getting scopes for endpoint");
+        // Ensures endpoints and protected resources compared are normalized
+        const normalizedEndpoint = this.location.normalize(endpoint);
+        const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());
+        const matchingProtectedResources = this.matchResourcesToEndpoint(protectedResourcesArray, normalizedEndpoint);
+        // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls
+        if (matchingProtectedResources.absoluteResources.length > 0) {
+            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.absoluteResources, httpMethod);
+        }
+        else if (matchingProtectedResources.relativeResources.length > 0) {
+            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.relativeResources, httpMethod);
+        }
+        return null;
+    }
+    /**
+     * Finds resource endpoints that match request endpoint
+     * @param protectedResourcesEndpoints
+     * @param endpoint
+     * @returns
+     */
+    matchResourcesToEndpoint(protectedResourcesEndpoints, endpoint) {
+        const matchingResources = { absoluteResources: [], relativeResources: [] };
+        protectedResourcesEndpoints.forEach(key => {
+            // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards
+            const normalizedKey = this.location.normalize(key);
+            if (StringUtils.matchPattern(normalizedKey, endpoint)) {
+                matchingResources.absoluteResources.push(key);
+            }
+            // Get url components for relative urls
+            const absoluteKey = this.getAbsoluteUrl(key);
+            const keyComponents = new UrlString(absoluteKey).getUrlComponents();
+            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);
+            const endpointComponents = new UrlString(absoluteEndpoint).getUrlComponents();
+            // Normalized key should include query strings if applicable
+            const relativeNormalizedKey = keyComponents.QueryString ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}` : this.location.normalize(keyComponents.AbsolutePath);
+            // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty
+            if (keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort && StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) && relativeNormalizedKey !== "" && relativeNormalizedKey !== "/*") {
+                matchingResources.relativeResources.push(key);
+            }
+        });
+        return matchingResources;
+    }
+    /**
+     * Transforms relative urls to absolute urls
+     * @param url
+     * @returns
+     */
+    getAbsoluteUrl(url) {
+        const link = this._document.createElement("a");
+        link.href = url;
+        return link.href;
+    }
+    /**
+     * Finds scopes from first matching endpoint with HTTP method that matches request
+     * @param protectedResourceMap Protected resource map
+     * @param endpointArray Array of resources that match request endpoint
+     * @param httpMethod Http method of the request
+     * @returns
+     */
+    matchScopesToEndpoint(protectedResourceMap, endpointArray, httpMethod) {
+        const allMatchedScopes = [];
+        // Check each matched endpoint for matching HttpMethod and scopes
+        endpointArray.forEach(matchedEndpoint => {
+            const scopesForEndpoint = [];
+            const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);
+            // Return if resource is unprotected
+            if (methodAndScopesArray === null) {
+                allMatchedScopes.push(null);
+                return;
+            }
+            methodAndScopesArray.forEach(entry => {
+                // Entry is either array of scopes or ProtectedResourceScopes object
+                if (typeof entry === "string") {
+                    scopesForEndpoint.push(entry);
+                }
+                else {
+                    // Ensure methods being compared are normalized
+                    const normalizedRequestMethod = httpMethod.toLowerCase();
+                    const normalizedResourceMethod = entry.httpMethod.toLowerCase();
+                    // Method in protectedResourceMap matches request http method
+                    if (normalizedResourceMethod === normalizedRequestMethod) {
+                        // Validate if scopes comes null to unprotect the resource in a certain http method
+                        if (entry.scopes === null) {
+                            allMatchedScopes.push(null);
+                        }
+                        else {
+                            entry.scopes.forEach((scope) => {
+                                scopesForEndpoint.push(scope);
+                            });
+                        }
+                    }
+                }
+            });
+            // Only add to all scopes if scopes for endpoint and method is found
+            if (scopesForEndpoint.length > 0) {
+                allMatchedScopes.push(scopesForEndpoint);
+            }
+        });
+        if (allMatchedScopes.length > 0) {
+            if (allMatchedScopes.length > 1) {
+                this.authService.getLogger().warning("Interceptor - More than 1 matching scopes for endpoint found.");
+            }
+            // Returns scopes for first matching endpoint
+            return allMatchedScopes[0];
+        }
+        return null;
+    }
+}
+MsalInterceptor.decorators = [
+    { type: Injectable }
+];
+MsalInterceptor.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MSAL_INTERCEPTOR_CONFIG,] }] },
+    { type: MsalService },
+    { type: Location },
+    { type: MsalBroadcastService },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.interceptor.js","sourceRoot":"","sources":["../../src/msal.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport {\r\n    HttpRequest,\r\n    HttpHandler,\r\n    HttpEvent,\r\n    HttpInterceptor\r\n} from \"@angular/common/http\";\r\nimport { Location, DOCUMENT } from \"@angular/common\";\r\nimport { Observable, EMPTY, of } from \"rxjs\";\r\nimport { switchMap, catchError, take, filter } from \"rxjs/operators\";\r\nimport { MsalService } from \"./msal.service\";\r\nimport { AccountInfo, AuthenticationResult, BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, UrlString } from \"@azure/msal-browser\";\r\nimport { Injectable, Inject } from \"@angular/core\";\r\nimport { MSAL_INTERCEPTOR_CONFIG } from \"./constants\";\r\nimport { MsalInterceptorAuthRequest, MsalInterceptorConfiguration, ProtectedResourceScopes, MatchingResources } from \"./msal.interceptor.config\";\r\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\r\n\r\n@Injectable()\r\nexport class MsalInterceptor implements HttpInterceptor {\r\n    private _document?: Document;\r\n\r\n    constructor(\r\n        @Inject(MSAL_INTERCEPTOR_CONFIG) private msalInterceptorConfig: MsalInterceptorConfiguration,\r\n        private authService: MsalService,\r\n        private location: Location,\r\n        private msalBroadcastService: MsalBroadcastService,\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n        @Inject(DOCUMENT) document?: any\r\n    ) {\r\n        this._document = document as Document;\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n        if (this.msalInterceptorConfig.interactionType !== InteractionType.Popup && this.msalInterceptorConfig.interactionType !== InteractionType.Redirect) {\r\n            throw new BrowserConfigurationAuthError(\"invalid_interaction_type\", \"Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration\");\r\n        }\r\n\r\n        this.authService.getLogger().verbose(\"MSAL Interceptor activated\");\r\n        const scopes = this.getScopesForEndpoint(req.url, req.method);\r\n\r\n        // If no scopes for endpoint, does not acquire token\r\n        if (!scopes || scopes.length === 0) {\r\n            this.authService.getLogger().verbose(\"Interceptor - no scopes for endpoint\");\r\n            return next.handle(req);\r\n        }\r\n\r\n        // Sets account as active account or first account\r\n        let account: AccountInfo;\r\n        if (!!this.authService.instance.getActiveAccount()) {\r\n            this.authService.getLogger().verbose(\"Interceptor - active account selected\");\r\n            account = this.authService.instance.getActiveAccount();\r\n        } else {\r\n            this.authService.getLogger().verbose(\"Interceptor - no active account, fallback to first account\");\r\n            account = this.authService.instance.getAllAccounts()[0];\r\n        }\r\n\r\n        const authRequest = typeof this.msalInterceptorConfig.authRequest === \"function\"\r\n            ? this.msalInterceptorConfig.authRequest(this.authService, req, { account: account })\r\n            : { ...this.msalInterceptorConfig.authRequest, account };\r\n\r\n        this.authService.getLogger().info(`Interceptor - ${scopes.length} scopes found for endpoint`);\r\n        this.authService.getLogger().infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);\r\n\r\n        return this.acquireToken(authRequest, scopes, account)\r\n            .pipe(\r\n                switchMap((result: AuthenticationResult) => {\r\n                    this.authService.getLogger().verbose(\"Interceptor - setting authorization headers\");\r\n                    const headers = req.headers\r\n                        .set(\"Authorization\", `Bearer ${result.accessToken}`);\r\n\r\n                    const requestClone = req.clone({headers});\r\n                    return next.handle(requestClone);\r\n                })\r\n            );\r\n    }\r\n\r\n    /**\r\n     * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token\r\n     * @param authRequest Request\r\n     * @param scopes Array of scopes for the request\r\n     * @param account Account\r\n     * @returns Authentication result\r\n     */\r\n    private acquireToken(authRequest: MsalInterceptorAuthRequest, scopes: string[], account: AccountInfo): Observable<AuthenticationResult> {\r\n        // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\r\n        return this.authService.acquireTokenSilent({...authRequest, scopes, account })\r\n            .pipe(\r\n                catchError(() => {\r\n                    this.authService.getLogger().error(\"Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.\");\r\n                    return this.msalBroadcastService.inProgress$\r\n                        .pipe(\r\n                            take(1),\r\n                            switchMap((status: InteractionStatus) => {\r\n                                if (status === InteractionStatus.None) {\r\n                                    return this.acquireTokenInteractively(authRequest, scopes);\r\n                                }\r\n\r\n                                return this.msalBroadcastService.inProgress$\r\n                                    .pipe(\r\n                                        filter((status: InteractionStatus) => status === InteractionStatus.None),\r\n                                        take(1),\r\n                                        switchMap(() => this.acquireToken(authRequest, scopes, account))\r\n                                    );\r\n                            })\r\n                        );\r\n                }),\r\n                switchMap((result: AuthenticationResult)  => {\r\n                    if (!result.accessToken) {\r\n                        this.authService.getLogger().error(\"Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.\");\r\n                        return this.msalBroadcastService.inProgress$\r\n                            .pipe(\r\n                                filter((status: InteractionStatus) => status === InteractionStatus.None),\r\n                                take(1),\r\n                                switchMap(() => this.acquireTokenInteractively(authRequest, scopes))\r\n                            );\r\n                    }\r\n                    return of(result);\r\n                })\r\n            );\r\n    }\r\n\r\n    /**\r\n     * Invoke interaction for the given set of scopes\r\n     * @param authRequest Request\r\n     * @param scopes Array of scopes for the request\r\n     * @returns Result from the interactive request\r\n     */\r\n    private acquireTokenInteractively(authRequest: MsalInterceptorAuthRequest, scopes: string[]): Observable<AuthenticationResult> {\r\n        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\r\n            this.authService.getLogger().verbose(\"Interceptor - error acquiring token silently, acquiring by popup\");\r\n            return this.authService.acquireTokenPopup({ ...authRequest, scopes });\r\n        }\r\n        this.authService.getLogger().verbose(\"Interceptor - error acquiring token silently, acquiring by redirect\");\r\n        const redirectStartPage = window.location.href;\r\n        this.authService.acquireTokenRedirect({...authRequest, scopes, redirectStartPage });\r\n        return EMPTY;\r\n    }\r\n\r\n    /**\r\n     * Looks up the scopes for the given endpoint from the protectedResourceMap\r\n     * @param endpoint Url of the request\r\n     * @param httpMethod Http method of the request\r\n     * @returns Array of scopes, or null if not found\r\n     *\r\n     */\r\n    private getScopesForEndpoint(endpoint: string, httpMethod: string): Array<string>|null {\r\n        this.authService.getLogger().verbose(\"Interceptor - getting scopes for endpoint\");\r\n\r\n        // Ensures endpoints and protected resources compared are normalized\r\n        const normalizedEndpoint = this.location.normalize(endpoint);\r\n\r\n        const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());\r\n\r\n        const matchingProtectedResources = this.matchResourcesToEndpoint(protectedResourcesArray, normalizedEndpoint);\r\n\r\n        // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls\r\n        if (matchingProtectedResources.absoluteResources.length > 0) {\r\n            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.absoluteResources, httpMethod);\r\n        } else if (matchingProtectedResources.relativeResources.length > 0){\r\n            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.relativeResources, httpMethod);\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Finds resource endpoints that match request endpoint\r\n     * @param protectedResourcesEndpoints\r\n     * @param endpoint\r\n     * @returns\r\n     */\r\n    private matchResourcesToEndpoint(protectedResourcesEndpoints: string[], endpoint: string): MatchingResources {\r\n        const matchingResources: MatchingResources = {absoluteResources: [], relativeResources: []};\r\n\r\n        protectedResourcesEndpoints.forEach(key => {\r\n            // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards\r\n            const normalizedKey = this.location.normalize(key);\r\n            if (StringUtils.matchPattern(normalizedKey, endpoint)){\r\n                matchingResources.absoluteResources.push(key);\r\n            }\r\n\r\n            // Get url components for relative urls\r\n            const absoluteKey = this.getAbsoluteUrl(key);\r\n            const keyComponents = new UrlString(absoluteKey).getUrlComponents();\r\n            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);\r\n            const endpointComponents = new UrlString(absoluteEndpoint).getUrlComponents();\r\n\r\n            // Normalized key should include query strings if applicable\r\n            const relativeNormalizedKey = keyComponents.QueryString ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}` : this.location.normalize(keyComponents.AbsolutePath);\r\n\r\n            // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty\r\n            if (keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort && StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) && relativeNormalizedKey !== \"\" && relativeNormalizedKey !== \"/*\"){\r\n                matchingResources.relativeResources.push(key);\r\n            }\r\n        });\r\n\r\n        return matchingResources;\r\n    }\r\n\r\n    /**\r\n     * Transforms relative urls to absolute urls\r\n     * @param url\r\n     * @returns\r\n     */\r\n    private getAbsoluteUrl(url: string): string {\r\n        const link = this._document.createElement(\"a\");\r\n        link.href = url;\r\n        return link.href;\r\n    }\r\n\r\n    /**\r\n     * Finds scopes from first matching endpoint with HTTP method that matches request\r\n     * @param protectedResourceMap Protected resource map\r\n     * @param endpointArray Array of resources that match request endpoint\r\n     * @param httpMethod Http method of the request\r\n     * @returns\r\n     */\r\n    private matchScopesToEndpoint(protectedResourceMap: Map<string, Array<string|ProtectedResourceScopes> | null>, endpointArray: string[], httpMethod: string): Array<string>|null {\r\n        const allMatchedScopes = [];\r\n\r\n        // Check each matched endpoint for matching HttpMethod and scopes\r\n        endpointArray.forEach(matchedEndpoint => {\r\n            const scopesForEndpoint = [];\r\n            const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);\r\n\r\n            // Return if resource is unprotected\r\n            if (methodAndScopesArray === null) {\r\n                allMatchedScopes.push(null);\r\n                return;\r\n            }\r\n\r\n            methodAndScopesArray.forEach(entry => {\r\n                // Entry is either array of scopes or ProtectedResourceScopes object\r\n                if (typeof entry === \"string\") {\r\n                    scopesForEndpoint.push(entry);\r\n                } else {\r\n                    // Ensure methods being compared are normalized\r\n                    const normalizedRequestMethod = httpMethod.toLowerCase();\r\n                    const normalizedResourceMethod = entry.httpMethod.toLowerCase();\r\n                    // Method in protectedResourceMap matches request http method\r\n                    if (normalizedResourceMethod === normalizedRequestMethod) {\r\n                        // Validate if scopes comes null to unprotect the resource in a certain http method\r\n                        if (entry.scopes === null) {\r\n                            allMatchedScopes.push(null);\r\n                        } else {\r\n                            entry.scopes.forEach((scope) => {\r\n                                scopesForEndpoint.push(scope);\r\n                            });\r\n                        }\r\n                    }\r\n                }\r\n            });\r\n\r\n            // Only add to all scopes if scopes for endpoint and method is found\r\n            if (scopesForEndpoint.length > 0) {\r\n                allMatchedScopes.push(scopesForEndpoint);\r\n            }\r\n        });\r\n\r\n        if (allMatchedScopes.length > 0) {\r\n            if (allMatchedScopes.length > 1) {\r\n                this.authService.getLogger().warning(\"Interceptor - More than 1 matching scopes for endpoint found.\");\r\n            }\r\n            // Returns scopes for first matching endpoint\r\n            return allMatchedScopes[0];\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n}\r\n"]}