@azure/msal-angular 4.0.13 → 4.0.14

package/esm2020/msal.interceptor.mjs

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable, Inject } from "@angular/core";
+import { DOCUMENT } from "@angular/common";
+import { BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, } from "@azure/msal-browser";
+import { EMPTY, of } from "rxjs";
+import { switchMap, catchError, take, filter } from "rxjs/operators";
+import { MSAL_INTERCEPTOR_CONFIG } from "./constants";
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+import * as i2 from "@angular/common";
+import * as i3 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;
+    }
+    intercept(req, // eslint-disable-line @typescript-eslint/no-explicit-any
+    next
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        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,
+            })
+            : { ...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({ ...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({ ...authRequest, scopes });
+        }
+        this.authService
+            .getLogger()
+            .verbose("Interceptor - error acquiring token silently, acquiring by redirect");
+        const redirectStartPage = window.location.href;
+        this.authService.acquireTokenRedirect({
+            ...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);
+        if (matchingProtectedResources.length > 0) {
+            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources, httpMethod);
+        }
+        return null;
+    }
+    /**
+     * Finds resource endpoints that match request endpoint
+     * @param protectedResourcesEndpoints
+     * @param endpoint
+     * @returns
+     */
+    matchResourcesToEndpoint(protectedResourcesEndpoints, endpoint) {
+        const matchingResources = [];
+        protectedResourcesEndpoints.forEach((key) => {
+            const normalizedKey = this.location.normalize(key);
+            // Get url components
+            const absoluteKey = this.getAbsoluteUrl(normalizedKey);
+            const keyComponents = new URL(absoluteKey);
+            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);
+            const endpointComponents = new URL(absoluteEndpoint);
+            if (this.checkUrlComponents(keyComponents, endpointComponents)) {
+                matchingResources.push(key);
+            }
+        });
+        return matchingResources;
+    }
+    /**
+     * Compares URL segments between key and endpoint
+     * @param key
+     * @param endpoint
+     * @returns
+     */
+    checkUrlComponents(keyComponents, endpointComponents) {
+        // URL properties from https://developer.mozilla.org/en-US/docs/Web/API/URL
+        const urlProperties = ["protocol", "host", "pathname", "search", "hash"];
+        for (const property of urlProperties) {
+            if (keyComponents[property]) {
+                const decodedInput = decodeURIComponent(keyComponents[property]);
+                if (!StringUtils.matchPattern(decodedInput, endpointComponents[property])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * 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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalInterceptor, deps: [{ token: MSAL_INTERCEPTOR_CONFIG }, { token: i1.MsalService }, { token: i2.Location }, { token: i3.MsalBroadcastService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_INTERCEPTOR_CONFIG]
+                }] }, { type: i1.MsalService }, { type: i2.Location }, { type: i3.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 { Injectable, Inject } from \"@angular/core\";\nimport { Location, DOCUMENT } from \"@angular/common\";\nimport {\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n  HttpInterceptor,\n} from \"@angular/common/http\"; // eslint-disable-line import/no-unresolved\nimport {\n  AccountInfo,\n  AuthenticationResult,\n  BrowserConfigurationAuthError,\n  InteractionStatus,\n  InteractionType,\n  StringUtils,\n} from \"@azure/msal-browser\";\nimport { Observable, EMPTY, of } from \"rxjs\";\nimport { switchMap, catchError, take, filter } from \"rxjs/operators\";\nimport { MsalService } from \"./msal.service\";\nimport {\n  MsalInterceptorAuthRequest,\n  MsalInterceptorConfiguration,\n  ProtectedResourceScopes,\n} from \"./msal.interceptor.config\";\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\nimport { MSAL_INTERCEPTOR_CONFIG } from \"./constants\";\n\n@Injectable()\nexport class MsalInterceptor implements HttpInterceptor {\n  private _document?: Document;\n\n  constructor(\n    @Inject(MSAL_INTERCEPTOR_CONFIG)\n    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  intercept(\n    req: HttpRequest<any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n    next: HttpHandler\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): Observable<HttpEvent<any>> {\n    if (\n      this.msalInterceptorConfig.interactionType !== InteractionType.Popup &&\n      this.msalInterceptorConfig.interactionType !== InteractionType.Redirect\n    ) {\n      throw new BrowserConfigurationAuthError(\n        \"invalid_interaction_type\",\n        \"Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration\"\n      );\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\n        .getLogger()\n        .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\n        .getLogger()\n        .verbose(\"Interceptor - active account selected\");\n      account = this.authService.instance.getActiveAccount();\n    } else {\n      this.authService\n        .getLogger()\n        .verbose(\"Interceptor - no active account, fallback to first account\");\n      account = this.authService.instance.getAllAccounts()[0];\n    }\n\n    const authRequest =\n      typeof this.msalInterceptorConfig.authRequest === \"function\"\n        ? this.msalInterceptorConfig.authRequest(this.authService, req, {\n            account: account,\n          })\n        : { ...this.msalInterceptorConfig.authRequest, account };\n\n    this.authService\n      .getLogger()\n      .info(`Interceptor - ${scopes.length} scopes found for endpoint`);\n    this.authService\n      .getLogger()\n      .infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);\n\n    return this.acquireToken(authRequest, scopes, account).pipe(\n      switchMap((result: AuthenticationResult) => {\n        this.authService\n          .getLogger()\n          .verbose(\"Interceptor - setting authorization headers\");\n        const headers = req.headers.set(\n          \"Authorization\",\n          `Bearer ${result.accessToken}`\n        );\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(\n    authRequest: MsalInterceptorAuthRequest,\n    scopes: string[],\n    account: AccountInfo\n  ): Observable<AuthenticationResult> {\n    // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\n    return this.authService\n      .acquireTokenSilent({ ...authRequest, scopes, account })\n      .pipe(\n        catchError(() => {\n          this.authService\n            .getLogger()\n            .error(\n              \"Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.\"\n            );\n          return this.msalBroadcastService.inProgress$.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$.pipe(\n                filter(\n                  (status: InteractionStatus) =>\n                    status === InteractionStatus.None\n                ),\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\n              .getLogger()\n              .error(\n                \"Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.\"\n              );\n            return this.msalBroadcastService.inProgress$.pipe(\n              filter(\n                (status: InteractionStatus) => status === InteractionStatus.None\n              ),\n              take(1),\n              switchMap(() =>\n                this.acquireTokenInteractively(authRequest, scopes)\n              )\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(\n    authRequest: MsalInterceptorAuthRequest,\n    scopes: string[]\n  ): Observable<AuthenticationResult> {\n    if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\n      this.authService\n        .getLogger()\n        .verbose(\n          \"Interceptor - error acquiring token silently, acquiring by popup\"\n        );\n      return this.authService.acquireTokenPopup({ ...authRequest, scopes });\n    }\n    this.authService\n      .getLogger()\n      .verbose(\n        \"Interceptor - error acquiring token silently, acquiring by redirect\"\n      );\n    const redirectStartPage = window.location.href;\n    this.authService.acquireTokenRedirect({\n      ...authRequest,\n      scopes,\n      redirectStartPage,\n    });\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(\n    endpoint: string,\n    httpMethod: string\n  ): Array<string> | null {\n    this.authService\n      .getLogger()\n      .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(\n      this.msalInterceptorConfig.protectedResourceMap.keys()\n    );\n\n    const matchingProtectedResources = this.matchResourcesToEndpoint(\n      protectedResourcesArray,\n      normalizedEndpoint\n    );\n\n    if (matchingProtectedResources.length > 0) {\n      return this.matchScopesToEndpoint(\n        this.msalInterceptorConfig.protectedResourceMap,\n        matchingProtectedResources,\n        httpMethod\n      );\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(\n    protectedResourcesEndpoints: string[],\n    endpoint: string\n  ): Array<string> {\n    const matchingResources: Array<string> = [];\n\n    protectedResourcesEndpoints.forEach((key) => {\n      const normalizedKey = this.location.normalize(key);\n\n      // Get url components\n      const absoluteKey = this.getAbsoluteUrl(normalizedKey);\n      const keyComponents = new URL(absoluteKey);\n      const absoluteEndpoint = this.getAbsoluteUrl(endpoint);\n      const endpointComponents = new URL(absoluteEndpoint);\n\n      if (this.checkUrlComponents(keyComponents, endpointComponents)) {\n        matchingResources.push(key);\n      }\n    });\n\n    return matchingResources;\n  }\n\n  /**\n   * Compares URL segments between key and endpoint\n   * @param key\n   * @param endpoint\n   * @returns\n   */\n  private checkUrlComponents(\n    keyComponents: URL,\n    endpointComponents: URL\n  ): boolean {\n    // URL properties from https://developer.mozilla.org/en-US/docs/Web/API/URL\n    const urlProperties = [\"protocol\", \"host\", \"pathname\", \"search\", \"hash\"];\n\n    for (const property of urlProperties) {\n      if (keyComponents[property]) {\n        const decodedInput = decodeURIComponent(keyComponents[property]);\n        if (\n          !StringUtils.matchPattern(decodedInput, endpointComponents[property])\n        ) {\n          return false;\n        }\n      }\n    }\n\n    return true;\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(\n    protectedResourceMap: Map<\n      string,\n      Array<string | ProtectedResourceScopes> | null\n    >,\n    endpointArray: string[],\n    httpMethod: string\n  ): 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\n          .getLogger()\n          .warning(\n            \"Interceptor - More than 1 matching scopes for endpoint found.\"\n          );\n      }\n      // Returns scopes for first matching endpoint\n      return allMatchedScopes[0];\n    }\n\n    return null;\n  }\n}\n"]}

package/esm2020/msal.module.mjs

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+import { MsalGuard } from "./msal.guard";
+import { MsalRedirectComponent } from "./msal.redirect.component";
+import { MsalService } from "./msal.service";
+import { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG, } from "./constants";
+import * as i0 from "@angular/core";
+export class MsalModule {
+    static forRoot(msalInstance, guardConfig, interceptorConfig) {
+        return {
+            ngModule: MsalModule,
+            providers: [
+                {
+                    provide: MSAL_INSTANCE,
+                    useValue: msalInstance,
+                },
+                {
+                    provide: MSAL_GUARD_CONFIG,
+                    useValue: guardConfig,
+                },
+                {
+                    provide: MSAL_INTERCEPTOR_CONFIG,
+                    useValue: interceptorConfig,
+                },
+                MsalService,
+            ],
+        };
+    }
+}
+MsalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MsalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: MsalModule, declarations: [MsalRedirectComponent], imports: [CommonModule] });
+MsalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalModule, providers: [MsalGuard, MsalBroadcastService], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MsalRedirectComponent],
+                    imports: [CommonModule],
+                    providers: [MsalGuard, MsalBroadcastService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/msal.navigation.client.mjs

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable } from "@angular/core";
+import { NavigationClient, UrlString, } from "@azure/msal-browser";
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+/**
+ * Custom navigation used for Angular client-side navigation.
+ * See performance doc for details:
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/tree/dev/lib/msal-angular/docs/performance.md
+ */
+export class MsalCustomNavigationClient extends NavigationClient {
+    constructor(authService, router, location) {
+        super();
+        this.authService = authService;
+        this.router = router;
+        this.location = location;
+    }
+    async navigateInternal(url, options) {
+        this.authService.getLogger().trace("MsalCustomNavigationClient called");
+        this.authService
+            .getLogger()
+            .verbose("MsalCustomNavigationClient - navigating");
+        this.authService
+            .getLogger()
+            .verbosePii(`MsalCustomNavigationClient - navigating to url: ${url}`);
+        // Prevent hash clearing from causing an issue with Client-side navigation after redirect is handled
+        if (options.noHistory) {
+            return super.navigateInternal(url, options);
+        }
+        else {
+            // Normalizing newUrl if no query string
+            const urlComponents = new UrlString(url).getUrlComponents();
+            const newUrl = urlComponents.QueryString
+                ? `${urlComponents.AbsolutePath}?${urlComponents.QueryString}`
+                : this.location.normalize(urlComponents.AbsolutePath);
+            await this.router.navigateByUrl(newUrl, {
+                replaceUrl: options.noHistory,
+            });
+        }
+        return Promise.resolve(options.noHistory);
+    }
+}
+MsalCustomNavigationClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalCustomNavigationClient, deps: [{ token: i1.MsalService }, { token: i2.Router }, { token: i3.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalCustomNavigationClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalCustomNavigationClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalCustomNavigationClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MsalService }, { type: i2.Router }, { type: i3.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/msal.redirect.component.mjs

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This is a dedicated redirect component to be added to Angular apps to
+ * handle redirects when using @azure/msal-angular.
+ * Import this component to use redirects in your app.
+ */
+import { Component } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+export class MsalRedirectComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.getLogger().verbose("MsalRedirectComponent activated");
+        this.authService.handleRedirectObservable().subscribe();
+    }
+}
+MsalRedirectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalRedirectComponent, deps: [{ token: i1.MsalService }], target: i0.ɵɵFactoryTarget.Component });
+MsalRedirectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: MsalRedirectComponent, selector: "app-redirect", ngImport: i0, template: "", isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalRedirectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "app-redirect",
+                    template: "",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MsalService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5yZWRpcmVjdC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNhbC5yZWRpcmVjdC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUg7Ozs7R0FJRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7OztBQU9sRCxNQUFNLE9BQU8scUJBQXFCO0lBQ2hDLFlBQW9CLFdBQXdCO1FBQXhCLGdCQUFXLEdBQVgsV0FBVyxDQUFhO0lBQUcsQ0FBQztJQUVoRCxRQUFRO1FBQ04sSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxPQUFPLENBQUMsaUNBQWlDLENBQUMsQ0FBQztRQUN4RSxJQUFJLENBQUMsV0FBVyxDQUFDLHdCQUF3QixFQUFFLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDMUQsQ0FBQzs7bUhBTlUscUJBQXFCO3VHQUFyQixxQkFBcUIsb0RBRnRCLEVBQUU7NEZBRUQscUJBQXFCO2tCQUpqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxjQUFjO29CQUN4QixRQUFRLEVBQUUsRUFBRTtpQkFDYiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIE1pY3Jvc29mdCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS5cbiAqL1xuXG4vKipcbiAqIFRoaXMgaXMgYSBkZWRpY2F0ZWQgcmVkaXJlY3QgY29tcG9uZW50IHRvIGJlIGFkZGVkIHRvIEFuZ3VsYXIgYXBwcyB0b1xuICogaGFuZGxlIHJlZGlyZWN0cyB3aGVuIHVzaW5nIEBhenVyZS9tc2FsLWFuZ3VsYXIuXG4gKiBJbXBvcnQgdGhpcyBjb21wb25lbnQgdG8gdXNlIHJlZGlyZWN0cyBpbiB5b3VyIGFwcC5cbiAqL1xuXG5pbXBvcnQgeyBDb21wb25lbnQsIE9uSW5pdCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBNc2FsU2VydmljZSB9IGZyb20gXCIuL21zYWwuc2VydmljZVwiO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6IFwiYXBwLXJlZGlyZWN0XCIsXG4gIHRlbXBsYXRlOiBcIlwiLFxufSlcbmV4cG9ydCBjbGFzcyBNc2FsUmVkaXJlY3RDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGF1dGhTZXJ2aWNlOiBNc2FsU2VydmljZSkge31cblxuICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB0aGlzLmF1dGhTZXJ2aWNlLmdldExvZ2dlcigpLnZlcmJvc2UoXCJNc2FsUmVkaXJlY3RDb21wb25lbnQgYWN0aXZhdGVkXCIpO1xuICAgIHRoaXMuYXV0aFNlcnZpY2UuaGFuZGxlUmVkaXJlY3RPYnNlcnZhYmxlKCkuc3Vic2NyaWJlKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/msal.service.mjs

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Inject, Injectable } from "@angular/core";
+import { WrapperSKU, } from "@azure/msal-browser";
+import { from } from "rxjs";
+import { name, version } from "./packageMetadata";
+import { MSAL_INSTANCE } from "./constants";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class MsalService {
+    constructor(instance, location, injector) {
+        this.instance = instance;
+        this.location = location;
+        this.injector = injector;
+        const hash = this.location.path(true).split("#").pop();
+        if (hash) {
+            this.redirectHash = `#${hash}`;
+        }
+        this.instance.initializeWrapperLibrary(WrapperSKU.Angular, version);
+    }
+    initialize() {
+        return from(this.instance.initialize());
+    }
+    acquireTokenPopup(request) {
+        return from(this.instance.acquireTokenPopup(request));
+    }
+    acquireTokenRedirect(request) {
+        return from(this.instance.acquireTokenRedirect(request));
+    }
+    acquireTokenSilent(silentRequest) {
+        return from(this.instance.acquireTokenSilent(silentRequest));
+    }
+    handleRedirectObservable(hash) {
+        return from(this.instance
+            .initialize()
+            .then(() => this.instance.handleRedirectPromise(hash || this.redirectHash))
+            .finally(() => {
+            // update inProgress state to none
+            this.injector.get(MsalBroadcastService).resetInProgressEvent();
+        }));
+    }
+    loginPopup(request) {
+        return from(this.instance.loginPopup(request));
+    }
+    loginRedirect(request) {
+        return from(this.instance.loginRedirect(request));
+    }
+    // @deprecated: Use logoutRedirect or logoutPopup
+    logout(logoutRequest) {
+        return from(this.instance.logout(logoutRequest));
+    }
+    logoutRedirect(logoutRequest) {
+        return from(this.instance.logoutRedirect(logoutRequest));
+    }
+    logoutPopup(logoutRequest) {
+        return from(this.instance.logoutPopup(logoutRequest));
+    }
+    ssoSilent(request) {
+        return from(this.instance.ssoSilent(request));
+    }
+    /**
+     * Gets logger for msal-angular.
+     * If no logger set, returns logger instance created with same options as msal-browser
+     */
+    getLogger() {
+        if (!this.logger) {
+            this.logger = this.instance.getLogger().clone(name, version);
+        }
+        return this.logger;
+    }
+    // Create a logger instance for msal-angular with the same options as msal-browser
+    setLogger(logger) {
+        this.logger = logger.clone(name, version);
+        this.instance.setLogger(logger);
+    }
+}
+MsalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalService, deps: [{ token: MSAL_INSTANCE }, { token: i1.Location }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_INSTANCE]
+                }] }, { type: i1.Location }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.service.js","sourceRoot":"","sources":["../../src/msal.service.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 { Inject, Injectable, Injector } from \"@angular/core\";\nimport { Location } from \"@angular/common\";\nimport {\n  IPublicClientApplication,\n  EndSessionRequest,\n  EndSessionPopupRequest,\n  AuthenticationResult,\n  RedirectRequest,\n  SilentRequest,\n  PopupRequest,\n  SsoSilentRequest,\n  Logger,\n  WrapperSKU,\n} from \"@azure/msal-browser\";\nimport { Observable, from } from \"rxjs\";\nimport { IMsalService } from \"./IMsalService\";\nimport { name, version } from \"./packageMetadata\";\nimport { MSAL_INSTANCE } from \"./constants\";\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\n\n@Injectable()\nexport class MsalService implements IMsalService {\n  private redirectHash: string;\n  private logger: Logger;\n\n  constructor(\n    @Inject(MSAL_INSTANCE) public instance: IPublicClientApplication,\n    private location: Location,\n    private injector: Injector\n  ) {\n    const hash = this.location.path(true).split(\"#\").pop();\n    if (hash) {\n      this.redirectHash = `#${hash}`;\n    }\n    this.instance.initializeWrapperLibrary(WrapperSKU.Angular, version);\n  }\n\n  initialize(): Observable<void> {\n    return from(this.instance.initialize());\n  }\n  acquireTokenPopup(request: PopupRequest): Observable<AuthenticationResult> {\n    return from(this.instance.acquireTokenPopup(request));\n  }\n  acquireTokenRedirect(request: RedirectRequest): Observable<void> {\n    return from(this.instance.acquireTokenRedirect(request));\n  }\n  acquireTokenSilent(\n    silentRequest: SilentRequest\n  ): Observable<AuthenticationResult> {\n    return from(this.instance.acquireTokenSilent(silentRequest));\n  }\n  handleRedirectObservable(hash?: string): Observable<AuthenticationResult> {\n    return from(\n      this.instance\n        .initialize()\n        .then(() =>\n          this.instance.handleRedirectPromise(hash || this.redirectHash)\n        )\n        .finally(() => {\n          // update inProgress state to none\n          this.injector.get(MsalBroadcastService).resetInProgressEvent();\n        })\n    );\n  }\n  loginPopup(request?: PopupRequest): Observable<AuthenticationResult> {\n    return from(this.instance.loginPopup(request));\n  }\n  loginRedirect(request?: RedirectRequest): Observable<void> {\n    return from(this.instance.loginRedirect(request));\n  }\n  // @deprecated: Use logoutRedirect or logoutPopup\n  logout(logoutRequest?: EndSessionRequest): Observable<void> {\n    return from(this.instance.logout(logoutRequest));\n  }\n  logoutRedirect(logoutRequest?: EndSessionRequest): Observable<void> {\n    return from(this.instance.logoutRedirect(logoutRequest));\n  }\n  logoutPopup(logoutRequest?: EndSessionPopupRequest): Observable<void> {\n    return from(this.instance.logoutPopup(logoutRequest));\n  }\n  ssoSilent(request: SsoSilentRequest): Observable<AuthenticationResult> {\n    return from(this.instance.ssoSilent(request));\n  }\n  /**\n   * Gets logger for msal-angular.\n   * If no logger set, returns logger instance created with same options as msal-browser\n   */\n  getLogger(): Logger {\n    if (!this.logger) {\n      this.logger = this.instance.getLogger().clone(name, version);\n    }\n    return this.logger;\n  }\n  // Create a logger instance for msal-angular with the same options as msal-browser\n  setLogger(logger: Logger): void {\n    this.logger = logger.clone(name, version);\n    this.instance.setLogger(logger);\n  }\n}\n"]}

package/esm2020/packageMetadata.mjs

@@ -0,0 +1,4 @@
+/* eslint-disable header/header */
+export const name = "@azure/msal-angular";
+export const version = "4.0.14";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZU1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BhY2thZ2VNZXRhZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQ0FBa0M7QUFDbEMsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLHFCQUFxQixDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBoZWFkZXIvaGVhZGVyICovXG5leHBvcnQgY29uc3QgbmFtZSA9IFwiQGF6dXJlL21zYWwtYW5ndWxhclwiO1xuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSBcIjQuMC4xNFwiO1xuIl19

package/esm2020/public-api.mjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * @packageDocumentation
+ * @module @azure/msal-angular
+ */
+export { MsalService } from "./msal.service";
+export { MsalGuard } from "./msal.guard";
+export { MsalInterceptor } from "./msal.interceptor";
+export { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG, MSAL_BROADCAST_CONFIG, } from "./constants";
+export { MsalBroadcastService } from "./msal.broadcast.service";
+export { MsalModule } from "./msal.module";
+export { MsalRedirectComponent } from "./msal.redirect.component";
+export { MsalCustomNavigationClient } from "./msal.navigation.client";
+export { version } from "./packageMetadata";
+//# sourceMappingURL=data:application/json;base64,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