@azure/msal-angular 0.0.0-alpha1

package/esm2015/msal.guard.js

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Router } from "@angular/router";
+import { MsalService } from "./msal.service";
+import { Injectable, Inject, VERSION } from "@angular/core";
+import { Location } from "@angular/common";
+import { InteractionType, BrowserConfigurationAuthError, BrowserUtils, UrlString } from "@azure/msal-browser";
+import { MSAL_GUARD_CONFIG } from "./constants";
+import { concatMap, catchError, map } from "rxjs/operators";
+import { of } from "rxjs";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+export class MsalGuard {
+    constructor(msalGuardConfig, msalBroadcastService, authService, location, router) {
+        this.msalGuardConfig = msalGuardConfig;
+        this.msalBroadcastService = msalBroadcastService;
+        this.authService = authService;
+        this.location = location;
+        this.router = router;
+        // Subscribing so events in MsalGuard will set inProgress$ observable
+        this.msalBroadcastService.inProgress$.subscribe();
+    }
+    /**
+     * Parses url string to UrlTree
+     * @param url
+     */
+    parseUrl(url) {
+        return this.router.parseUrl(url);
+    }
+    /**
+     * Builds the absolute url for the destination page
+     * @param path Relative path of requested page
+     * @returns Full destination url
+     */
+    getDestinationUrl(path) {
+        this.authService.getLogger().verbose("Guard - getting destination url");
+        // Absolute base url for the application (default to origin if base element not present)
+        const baseElements = document.getElementsByTagName("base");
+        const baseUrl = this.location.normalize(baseElements.length ? baseElements[0].href : window.location.origin);
+        // Path of page (including hash, if using hash routing)
+        const pathUrl = this.location.prepareExternalUrl(path);
+        // Hash location strategy
+        if (pathUrl.startsWith("#")) {
+            this.authService.getLogger().verbose("Guard - destination by hash routing");
+            return `${baseUrl}/${pathUrl}`;
+        }
+        /*
+         * If using path location strategy, pathUrl will include the relative portion of the base path (e.g. /base/page).
+         * Since baseUrl also includes /base, can just concatentate baseUrl + path
+         */
+        return `${baseUrl}${path}`;
+    }
+    /**
+     * Interactively prompt the user to login
+     * @param url Path of the requested page
+     */
+    loginInteractively(state) {
+        const authRequest = typeof this.msalGuardConfig.authRequest === "function"
+            ? this.msalGuardConfig.authRequest(this.authService, state)
+            : Object.assign({}, this.msalGuardConfig.authRequest);
+        if (this.msalGuardConfig.interactionType === InteractionType.Popup) {
+            this.authService.getLogger().verbose("Guard - logging in by popup");
+            return this.authService.loginPopup(authRequest)
+                .pipe(map((response) => {
+                this.authService.getLogger().verbose("Guard - login by popup successful, can activate, setting active account");
+                this.authService.instance.setActiveAccount(response.account);
+                return true;
+            }));
+        }
+        this.authService.getLogger().verbose("Guard - logging in by redirect");
+        const redirectStartPage = this.getDestinationUrl(state.url);
+        return this.authService.loginRedirect(Object.assign({ redirectStartPage }, authRequest))
+            .pipe(map(() => false));
+    }
+    /**
+     * Helper which checks for the correct interaction type, prevents page with Guard to be set as reidrect, and calls handleRedirectObservable
+     * @param state
+     */
+    activateHelper(state) {
+        if (this.msalGuardConfig.interactionType !== InteractionType.Popup && this.msalGuardConfig.interactionType !== InteractionType.Redirect) {
+            throw new BrowserConfigurationAuthError("invalid_interaction_type", "Invalid interaction type provided to MSAL Guard. InteractionType.Popup or InteractionType.Redirect must be provided in the MsalGuardConfiguration");
+        }
+        this.authService.getLogger().verbose("MSAL Guard activated");
+        /*
+         * If a page with MSAL Guard is set as the redirect for acquireTokenSilent,
+         * short-circuit to prevent redirecting or popups.
+         */
+        if (typeof window !== "undefined") {
+            if (UrlString.hashContainsKnownProperties(window.location.hash) && BrowserUtils.isInIframe() && !this.authService.instance.getConfiguration().system.allowRedirectInIframe) {
+                this.authService.getLogger().warning("Guard - redirectUri set to page with MSAL Guard. It is recommended to not set redirectUri to a page that requires authentication.");
+                return of(false);
+            }
+        }
+        else {
+            this.authService.getLogger().info("Guard - window is undefined, MSAL does not support server-side token acquisition");
+            return of(true);
+        }
+        /**
+         * If a loginFailedRoute is set in the config, set this as the loginFailedRoute
+         */
+        if (this.msalGuardConfig.loginFailedRoute) {
+            this.loginFailedRoute = this.parseUrl(this.msalGuardConfig.loginFailedRoute);
+        }
+        // Capture current path before it gets changed by handleRedirectObservable
+        const currentPath = this.location.path(true);
+        return this.authService.handleRedirectObservable()
+            .pipe(concatMap(() => {
+            if (!this.authService.instance.getAllAccounts().length) {
+                if (state) {
+                    this.authService.getLogger().verbose("Guard - no accounts retrieved, log in required to activate");
+                    return this.loginInteractively(state);
+                }
+                this.authService.getLogger().verbose("Guard - no accounts retrieved, no state, cannot load");
+                return of(false);
+            }
+            this.authService.getLogger().verbose("Guard - at least 1 account exists, can activate or load");
+            // Prevent navigating the app to /#code= or /code=
+            if (state) {
+                /*
+                 * Path routing:
+                 * state.url: /#code=...
+                 * state.root.fragment: code=...
+                 */
+                /*
+                 * Hash routing:
+                 * state.url: /code
+                 * state.root.fragment: null
+                 */
+                const urlContainsCode = this.includesCode(state.url);
+                const fragmentContainsCode = !!state.root && !!state.root.fragment && this.includesCode(`#${state.root.fragment}`);
+                const hashRouting = this.location.prepareExternalUrl(state.url).indexOf("#") === 0;
+                // Ensure code parameter is in fragment (and not in query parameter), or that hash hash routing is used
+                if (urlContainsCode && (fragmentContainsCode || hashRouting)) {
+                    this.authService.getLogger().info("Guard - Hash contains known code response, stopping navigation.");
+                    // Path routing (navigate to current path without hash)
+                    if (currentPath.indexOf("#") > -1) {
+                        return of(this.parseUrl(this.location.path()));
+                    }
+                    // Hash routing (navigate to root path)
+                    return of(this.parseUrl(""));
+                }
+            }
+            return of(true);
+        }), catchError((error) => {
+            this.authService.getLogger().error("Guard - error while logging in, unable to activate");
+            this.authService.getLogger().errorPii(`Guard - error: ${error.message}`);
+            /**
+             * If a loginFailedRoute is set, checks to see if Angular 10+ is used and state is passed in before returning route
+             * Apps using Angular 9 will receive of(false) in canLoad interface, as it does not support UrlTree return types
+             */
+            if (this.loginFailedRoute && parseInt(VERSION.major, 10) > 9 && state) {
+                this.authService.getLogger().verbose("Guard - loginFailedRoute set, redirecting");
+                return of(this.loginFailedRoute);
+            }
+            return of(false);
+        }));
+    }
+    includesCode(path) {
+        return (path.lastIndexOf("/code") > -1 &&
+            path.lastIndexOf("/code") === path.length - "/code".length) || // path.endsWith("/code")
+            path.indexOf("#code=") > -1 ||
+            path.indexOf("&code=") > -1;
+    }
+    canActivate(route, state) {
+        this.authService.getLogger().verbose("Guard - canActivate");
+        return this.activateHelper(state);
+    }
+    canActivateChild(route, state) {
+        this.authService.getLogger().verbose("Guard - canActivateChild");
+        return this.activateHelper(state);
+    }
+    canLoad() {
+        this.authService.getLogger().verbose("Guard - canLoad");
+        // @ts-ignore
+        return this.activateHelper();
+    }
+}
+MsalGuard.decorators = [
+    { type: Injectable }
+];
+MsalGuard.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MSAL_GUARD_CONFIG,] }] },
+    { type: MsalBroadcastService },
+    { type: MsalService },
+    { type: Location },
+    { type: Router }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.guard.js","sourceRoot":"","sources":["../../src/msal.guard.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAgG,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACvI,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,6BAA6B,EAAE,YAAY,EAAE,SAAS,EAAuD,MAAM,qBAAqB,CAAC;AAEnK,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGhE,MAAM,OAAO,SAAS;IAGlB,YACuC,eAAuC,EAClE,oBAA0C,EAC1C,WAAwB,EACxB,QAAkB,EAClB,MAAc;QAJa,oBAAe,GAAf,eAAe,CAAwB;QAClE,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,gBAAW,GAAX,WAAW,CAAa;QACxB,aAAQ,GAAR,QAAQ,CAAU;QAClB,WAAM,GAAN,MAAM,CAAQ;QAEtB,qEAAqE;QACrE,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,GAAW;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,IAAY;QAC1B,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,iCAAiC,CAAC,CAAC;QACxE,wFAAwF;QACxF,MAAM,YAAY,GAAG,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE7G,uDAAuD;QACvD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAEvD,yBAAyB;QACzB,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YACzB,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;YAC5E,OAAO,GAAG,OAAO,IAAI,OAAO,EAAE,CAAC;SAClC;QAED;;;WAGG;QACH,OAAO,GAAG,OAAO,GAAG,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACK,kBAAkB,CAAC,KAA0B;QACjD,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,eAAe,CAAC,WAAW,KAAK,UAAU;YACtE,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC;YAC3D,CAAC,mBAAM,IAAI,CAAC,eAAe,CAAC,WAAW,CAAE,CAAC;QAC9C,IAAI,IAAI,CAAC,eAAe,CAAC,eAAe,KAAK,eAAe,CAAC,KAAK,EAAE;YAChE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC;YACpE,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,WAA2B,CAAC;iBAC1D,IAAI,CACD,GAAG,CAAC,CAAC,QAA8B,EAAE,EAAE;gBACnC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,yEAAyE,CAAC,CAAC;gBAChH,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBAC7D,OAAO,IAAI,CAAC;YAChB,CAAC,CAAC,CACL,CAAC;SACT;QAED,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QACvE,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC5D,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,gBAClC,iBAAiB,IACd,WAAW,CACE,CAAC;aAChB,IAAI,CACD,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CACnB,CAAC;IACV,CAAC;IAED;;;OAGG;IACK,cAAc,CAAC,KAA2B;QAC9C,IAAI,IAAI,CAAC,eAAe,CAAC,eAAe,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,eAAe,CAAC,eAAe,KAAK,eAAe,CAAC,QAAQ,EAAE;YACrI,MAAM,IAAI,6BAA6B,CAAC,0BAA0B,EAAE,mJAAmJ,CAAC,CAAC;SAC5N;QACD,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAE7D;;;WAGG;QACH,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;YAC/B,IAAI,SAAS,CAAC,2BAA2B,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,MAAM,CAAC,qBAAqB,EAAE;gBACxK,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,mIAAmI,CAAC,CAAC;gBAC1K,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;aACpB;SACJ;aAAM;YACH,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,kFAAkF,CAAC,CAAC;YACtH,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;SACnB;QAED;;WAEG;QACH,IAAI,IAAI,CAAC,eAAe,CAAC,gBAAgB,EAAE;YACvC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;SAChF;QAED,0EAA0E;QAC1E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE7C,OAAO,IAAI,CAAC,WAAW,CAAC,wBAAwB,EAAE;aAC7C,IAAI,CACD,SAAS,CAAC,GAAG,EAAE;YACX,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE;gBACpD,IAAI,KAAK,EAAE;oBACP,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,4DAA4D,CAAC,CAAC;oBACnG,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;iBACzC;gBACD,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,sDAAsD,CAAC,CAAC;gBAC7F,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;aACpB;YAED,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,yDAAyD,CAAC,CAAC;YAEhG,kDAAkD;YAClD,IAAI,KAAK,EAAE;gBACP;;;;mBAIG;gBAEH;;;;mBAIG;gBACH,MAAM,eAAe,GAAY,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9D,MAAM,oBAAoB,GAAY,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC5H,MAAM,WAAW,GAAY,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAE5F,uGAAuG;gBACvG,IAAI,eAAe,IAAI,CAAC,oBAAoB,IAAI,WAAW,CAAC,EAAE;oBAC1D,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;oBAErG,uDAAuD;oBACvD,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE;wBAC/B,OAAO,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;qBAClD;oBAED,uCAAuC;oBACvC,OAAO,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;iBAChC;aACJ;YAED,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAEpB,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,KAAY,EAAE,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACzF,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,kBAAkB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACzE;;;eAGG;YACH,IAAI,IAAI,CAAC,gBAAgB,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,EAAE;gBACnE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAC;gBAClF,OAAO,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;aACpC;YACD,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CACL,CAAC;IACV,CAAC;IAED,YAAY,CAAC,IAAY;QACrB,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAClC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,yBAAyB;YACxF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,CAAC;IAED,WAAW,CAAC,KAA6B,EAAE,KAA0B;QACjE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QAC5D,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,gBAAgB,CAAC,KAA6B,EAAE,KAA0B;QACtE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,OAAO;QACH,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QACxD,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;IACjC,CAAC;;;YAxMJ,UAAU;;;4CAKF,MAAM,SAAC,iBAAiB;YAPxB,oBAAoB;YARpB,WAAW;YAEX,QAAQ;YAHsF,MAAM","sourcesContent":["/*\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, CanActivateChild, CanLoad, UrlTree, Router } from \"@angular/router\";\nimport { MsalService } from \"./msal.service\";\nimport { Injectable, Inject, VERSION } from \"@angular/core\";\nimport { Location } from \"@angular/common\";\nimport { InteractionType, BrowserConfigurationAuthError, BrowserUtils, UrlString, PopupRequest, RedirectRequest, AuthenticationResult } from \"@azure/msal-browser\";\nimport { MsalGuardConfiguration } from \"./msal.guard.config\";\nimport { MSAL_GUARD_CONFIG } from \"./constants\";\nimport { concatMap, catchError, map } from \"rxjs/operators\";\nimport { Observable, of } from \"rxjs\";\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\n\n@Injectable()\nexport class MsalGuard implements CanActivate, CanActivateChild, CanLoad {\n    private loginFailedRoute?: UrlTree;\n\n    constructor(\n        @Inject(MSAL_GUARD_CONFIG) private msalGuardConfig: MsalGuardConfiguration,\n        private msalBroadcastService: MsalBroadcastService,\n        private authService: MsalService,\n        private location: Location,\n        private router: Router\n    ) { \n        // Subscribing so events in MsalGuard will set inProgress$ observable\n        this.msalBroadcastService.inProgress$.subscribe();\n    }\n\n    /**\n     * Parses url string to UrlTree\n     * @param url \n     */\n    parseUrl(url: string): UrlTree {\n        return this.router.parseUrl(url);\n    }\n\n    /**\n     * Builds the absolute url for the destination page\n     * @param path Relative path of requested page\n     * @returns Full destination url\n     */\n    getDestinationUrl(path: string): string {\n        this.authService.getLogger().verbose(\"Guard - getting destination url\");\n        // Absolute base url for the application (default to origin if base element not present)\n        const baseElements = document.getElementsByTagName(\"base\");\n        const baseUrl = this.location.normalize(baseElements.length ? baseElements[0].href : window.location.origin);\n\n        // Path of page (including hash, if using hash routing)\n        const pathUrl = this.location.prepareExternalUrl(path);\n\n        // Hash location strategy\n        if (pathUrl.startsWith(\"#\")) {\n            this.authService.getLogger().verbose(\"Guard - destination by hash routing\");\n            return `${baseUrl}/${pathUrl}`;\n        }\n\n        /*\n         * If using path location strategy, pathUrl will include the relative portion of the base path (e.g. /base/page).\n         * Since baseUrl also includes /base, can just concatentate baseUrl + path\n         */\n        return `${baseUrl}${path}`;\n    }\n\n    /**\n     * Interactively prompt the user to login\n     * @param url Path of the requested page\n     */\n    private loginInteractively(state: RouterStateSnapshot): Observable<boolean> {\n        const authRequest = typeof this.msalGuardConfig.authRequest === \"function\"\n            ? this.msalGuardConfig.authRequest(this.authService, state)\n            : { ...this.msalGuardConfig.authRequest };\n        if (this.msalGuardConfig.interactionType === InteractionType.Popup) {\n            this.authService.getLogger().verbose(\"Guard - logging in by popup\");\n            return this.authService.loginPopup(authRequest as PopupRequest)\n                .pipe(\n                    map((response: AuthenticationResult) => {\n                        this.authService.getLogger().verbose(\"Guard - login by popup successful, can activate, setting active account\");\n                        this.authService.instance.setActiveAccount(response.account);\n                        return true;\n                    })\n                );\n        }\n\n        this.authService.getLogger().verbose(\"Guard - logging in by redirect\");\n        const redirectStartPage = this.getDestinationUrl(state.url);\n        return this.authService.loginRedirect({\n            redirectStartPage,\n            ...authRequest\n        } as RedirectRequest)\n            .pipe(\n                map(() => false)\n            );\n    }\n\n    /**\n     * Helper which checks for the correct interaction type, prevents page with Guard to be set as reidrect, and calls handleRedirectObservable\n     * @param state \n     */\n    private activateHelper(state?: RouterStateSnapshot): Observable<boolean|UrlTree> {\n        if (this.msalGuardConfig.interactionType !== InteractionType.Popup && this.msalGuardConfig.interactionType !== InteractionType.Redirect) {\n            throw new BrowserConfigurationAuthError(\"invalid_interaction_type\", \"Invalid interaction type provided to MSAL Guard. InteractionType.Popup or InteractionType.Redirect must be provided in the MsalGuardConfiguration\");\n        }\n        this.authService.getLogger().verbose(\"MSAL Guard activated\");\n\n        /*\n         * If a page with MSAL Guard is set as the redirect for acquireTokenSilent,\n         * short-circuit to prevent redirecting or popups.\n         */\n        if (typeof window !== \"undefined\") {\n            if (UrlString.hashContainsKnownProperties(window.location.hash) && BrowserUtils.isInIframe() && !this.authService.instance.getConfiguration().system.allowRedirectInIframe) {\n                this.authService.getLogger().warning(\"Guard - redirectUri set to page with MSAL Guard. It is recommended to not set redirectUri to a page that requires authentication.\");\n                return of(false);\n            }\n        } else {\n            this.authService.getLogger().info(\"Guard - window is undefined, MSAL does not support server-side token acquisition\");\n            return of(true);\n        }\n\n        /**\n         * If a loginFailedRoute is set in the config, set this as the loginFailedRoute\n         */\n        if (this.msalGuardConfig.loginFailedRoute) {\n            this.loginFailedRoute = this.parseUrl(this.msalGuardConfig.loginFailedRoute);\n        }\n\n        // Capture current path before it gets changed by handleRedirectObservable\n        const currentPath = this.location.path(true);\n\n        return this.authService.handleRedirectObservable()\n            .pipe(\n                concatMap(() => {\n                    if (!this.authService.instance.getAllAccounts().length) {\n                        if (state) {\n                            this.authService.getLogger().verbose(\"Guard - no accounts retrieved, log in required to activate\");\n                            return this.loginInteractively(state);\n                        } \n                        this.authService.getLogger().verbose(\"Guard - no accounts retrieved, no state, cannot load\");\n                        return of(false);\n                    }\n\n                    this.authService.getLogger().verbose(\"Guard - at least 1 account exists, can activate or load\");\n\n                    // Prevent navigating the app to /#code= or /code=\n                    if (state) {\n                        /*\n                         * Path routing:\n                         * state.url: /#code=...\n                         * state.root.fragment: code=...\n                         */\n\n                        /*\n                         * Hash routing:\n                         * state.url: /code\n                         * state.root.fragment: null\n                         */\n                        const urlContainsCode: boolean = this.includesCode(state.url);\n                        const fragmentContainsCode: boolean = !!state.root && !!state.root.fragment && this.includesCode(`#${state.root.fragment}`);\n                        const hashRouting: boolean = this.location.prepareExternalUrl(state.url).indexOf(\"#\") === 0;\n\n                        // Ensure code parameter is in fragment (and not in query parameter), or that hash hash routing is used\n                        if (urlContainsCode && (fragmentContainsCode || hashRouting)) {\n                            this.authService.getLogger().info(\"Guard - Hash contains known code response, stopping navigation.\");\n                            \n                            // Path routing (navigate to current path without hash)\n                            if (currentPath.indexOf(\"#\") > -1) {\n                                return of(this.parseUrl(this.location.path()));\n                            }\n                            \n                            // Hash routing (navigate to root path)\n                            return of(this.parseUrl(\"\"));\n                        }\n                    }\n\n                    return of(true);\n\n                }),\n                catchError((error: Error) => {\n                    this.authService.getLogger().error(\"Guard - error while logging in, unable to activate\");\n                    this.authService.getLogger().errorPii(`Guard - error: ${error.message}`);\n                    /**\n                     * If a loginFailedRoute is set, checks to see if Angular 10+ is used and state is passed in before returning route\n                     * Apps using Angular 9 will receive of(false) in canLoad interface, as it does not support UrlTree return types\n                     */\n                    if (this.loginFailedRoute && parseInt(VERSION.major, 10) > 9 && state) {\n                        this.authService.getLogger().verbose(\"Guard - loginFailedRoute set, redirecting\");\n                        return of(this.loginFailedRoute);\n                    }\n                    return of(false);\n                })\n            );\n    }\n\n    includesCode(path: string): boolean {\n        return (path.lastIndexOf(\"/code\") > -1 &&\n            path.lastIndexOf(\"/code\") === path.length - \"/code\".length) || // path.endsWith(\"/code\")\n            path.indexOf(\"#code=\") > -1 || \n            path.indexOf(\"&code=\") > -1;\n    }\n\n    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean|UrlTree> {\n        this.authService.getLogger().verbose(\"Guard - canActivate\");\n        return this.activateHelper(state);\n    }\n\n    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean|UrlTree> {\n        this.authService.getLogger().verbose(\"Guard - canActivateChild\");\n        return this.activateHelper(state);\n    }\n\n    canLoad(): Observable<boolean> {\n        this.authService.getLogger().verbose(\"Guard - canLoad\");\n        // @ts-ignore\n        return this.activateHelper();\n    }\n}\n"]}

package/esm2015/msal.interceptor.config.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5pbnRlcmNlcHRvci5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNhbC5pbnRlcmNlcHRvci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgTWljcm9zb2Z0IENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICogTGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IEh0dHBSZXF1ZXN0IH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vbi9odHRwXCI7XG5pbXBvcnQgeyBQb3B1cFJlcXVlc3QsIFJlZGlyZWN0UmVxdWVzdCwgSW50ZXJhY3Rpb25UeXBlLCBTaWxlbnRSZXF1ZXN0IH0gZnJvbSBcIkBhenVyZS9tc2FsLWJyb3dzZXJcIjtcbmltcG9ydCB7IE1zYWxTZXJ2aWNlIH0gZnJvbSBcIi4vbXNhbC5zZXJ2aWNlXCI7XG5cbmV4cG9ydCBkZWNsYXJlIHR5cGUgTXNhbEludGVyY2VwdG9yQXV0aFJlcXVlc3QgPSBPbWl0PFBvcHVwUmVxdWVzdCwgXCJzY29wZXNcIj4gfCBPbWl0PFJlZGlyZWN0UmVxdWVzdCwgXCJzY29wZXNcIj4gfCBPbWl0PFNpbGVudFJlcXVlc3QsIFwic2NvcGVzXCI+IDtcblxuZXhwb3J0IHR5cGUgTXNhbEludGVyY2VwdG9yQ29uZmlndXJhdGlvbiA9IHtcbiAgICBpbnRlcmFjdGlvblR5cGU6IEludGVyYWN0aW9uVHlwZS5Qb3B1cCB8IEludGVyYWN0aW9uVHlwZS5SZWRpcmVjdDtcbiAgICBwcm90ZWN0ZWRSZXNvdXJjZU1hcDogTWFwPHN0cmluZywgQXJyYXk8c3RyaW5nfFByb3RlY3RlZFJlc291cmNlU2NvcGVzPiB8IG51bGw+O1xuICAgIGF1dGhSZXF1ZXN0PzogTXNhbEludGVyY2VwdG9yQXV0aFJlcXVlc3QgfCAoKG1zYWxTZXJ2aWNlOiBNc2FsU2VydmljZSwgcmVxOiBIdHRwUmVxdWVzdDx1bmtub3duPiwgb3JpZ2luYWxBdXRoUmVxdWVzdDogTXNhbEludGVyY2VwdG9yQXV0aFJlcXVlc3QpID0+IE1zYWxJbnRlcmNlcHRvckF1dGhSZXF1ZXN0KTtcbn07XG5cbmV4cG9ydCB0eXBlIFByb3RlY3RlZFJlc291cmNlU2NvcGVzID0ge1xuICAgIGh0dHBNZXRob2Q6IHN0cmluZyxcbiAgICBzY29wZXM6IEFycmF5PHN0cmluZz5cbn07XG5cbmV4cG9ydCB0eXBlIE1hdGNoaW5nUmVzb3VyY2VzID0ge1xuICAgIGFic29sdXRlUmVzb3VyY2VzOiBBcnJheTxzdHJpbmc+LFxuICAgIHJlbGF0aXZlUmVzb3VyY2VzOiBBcnJheTxzdHJpbmc+XG59O1xuIl19

package/esm2015/msal.interceptor.js

@@ -0,0 +1,208 @@
+/*
+ * 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 } from "rxjs/operators";
+import { MsalService } from "./msal.service";
+import { BrowserConfigurationAuthError, InteractionType, StringUtils, UrlString } from "@azure/msal-browser";
+import { Injectable, Inject } from "@angular/core";
+import { MSAL_INTERCEPTOR_CONFIG } from "./constants";
+export class MsalInterceptor {
+    constructor(msalInterceptorConfig, authService, location, 
+    // 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._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}`);
+        // 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.acquireTokenInteractively(authRequest, scopes);
+        }), 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.acquireTokenInteractively(authRequest, scopes);
+            }
+            return of(result);
+        }), 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);
+        }));
+    }
+    /**
+     * 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: 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 } from \"rxjs/operators\";\nimport { MsalService } from \"./msal.service\";\nimport { AccountInfo, AuthenticationResult, BrowserConfigurationAuthError, 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\";\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        // 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        // 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.acquireTokenInteractively(authRequest, scopes);\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.acquireTokenInteractively(authRequest, scopes);\n                    }\n                    return of(result);\n                }),\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     * 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"]}

package/esm2015/msal.module.js

@@ -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 { MsalGuard } from "./msal.guard";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+import { MsalService } from "./msal.service";
+import { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG } from "./constants";
+import { MsalRedirectComponent } from "./msal.redirect.component";
+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.decorators = [
+    { type: NgModule, args: [{
+                declarations: [MsalRedirectComponent],
+                imports: [
+                    CommonModule
+                ],
+                providers: [
+                    MsalGuard,
+                    MsalBroadcastService
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/msal.navigation.client.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { __awaiter } from "tslib";
+import { NavigationClient, UrlString } from "@azure/msal-browser";
+import { Router } from "@angular/router";
+import { Location } from "@angular/common";
+import { MsalService } from "./msal.service";
+import { Injectable } from "@angular/core";
+/**
+ * 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/v2-docs/performance.md
+ */
+export class MsalCustomNavigationClient extends NavigationClient {
+    constructor(authService, router, location) {
+        super();
+        this.authService = authService;
+        this.router = router;
+        this.location = location;
+    }
+    navigateInternal(url, options) {
+        const _super = Object.create(null, {
+            navigateInternal: { get: () => super.navigateInternal }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            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.call(this, 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);
+                this.router.navigateByUrl(newUrl, { replaceUrl: options.noHistory });
+            }
+            return Promise.resolve(options.noHistory);
+        });
+    }
+}
+MsalCustomNavigationClient.decorators = [
+    { type: Injectable }
+];
+MsalCustomNavigationClient.ctorParameters = () => [
+    { type: MsalService },
+    { type: Router },
+    { type: Location }
+];
+//# sourceMappingURL=data:application/json;base64,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