@azure/msal-angular 4.0.13 → 4.0.14

package/IMsalService.d.ts

@@ -0,0 +1,17 @@
+import { EndSessionRequest, AuthenticationResult, PopupRequest, RedirectRequest, SilentRequest, Logger, SsoSilentRequest } from "@azure/msal-browser";
+import { Observable } from "rxjs";
+export interface IMsalService {
+    initialize(): Observable<void>;
+    acquireTokenPopup(request: PopupRequest): Observable<AuthenticationResult>;
+    acquireTokenRedirect(request: RedirectRequest): Observable<void>;
+    acquireTokenSilent(silentRequest: SilentRequest): Observable<AuthenticationResult>;
+    handleRedirectObservable(): Observable<AuthenticationResult | null>;
+    loginPopup(request?: PopupRequest): Observable<AuthenticationResult>;
+    loginRedirect(request?: RedirectRequest): Observable<void>;
+    logout(logoutRequest?: EndSessionRequest): Observable<void>;
+    logoutRedirect(logoutRequest?: EndSessionRequest): Observable<void>;
+    logoutPopup(logoutRequest?: EndSessionRequest): Observable<void>;
+    ssoSilent(request: SsoSilentRequest): Observable<AuthenticationResult>;
+    getLogger(): Logger;
+    setLogger(logger: Logger): void;
+}

package/README.md

@@ -46,7 +46,7 @@ At a minimum, `@azure/msal-angular` will follow the [support schedule of the mai
 
 | MSAL Angular version | MSAL support status | Supported Angular versions |
 | -------------------- | ------------------- | -------------------------- |
-| MSAL Angular v4      | Active development  | 15, 16, 17, 18, 19         |
+| MSAL Angular v4      | Active development  | 15, 16, 17, 18, 19, 20     |
 | MSAL Angular v3      | In maintenance      | 15, 16, 17, 18             |
 | MSAL Angular v2      | In maintenance      | 9, 10, 11, 12, 13, 14      |
 | MSAL Angular v1      | In maintenance      | 6, 7, 8, 9                 |

package/constants.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from "@angular/core";
+export declare const MSAL_INSTANCE: InjectionToken<string>;
+export declare const MSAL_GUARD_CONFIG: InjectionToken<string>;
+export declare const MSAL_INTERCEPTOR_CONFIG: InjectionToken<string>;
+export declare const MSAL_BROADCAST_CONFIG: InjectionToken<string>;

package/esm2020/IMsalService.mjs

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSU1zYWxTZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL0lNc2FsU2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHtcbiAgRW5kU2Vzc2lvblJlcXVlc3QsXG4gIEF1dGhlbnRpY2F0aW9uUmVzdWx0LFxuICBQb3B1cFJlcXVlc3QsXG4gIFJlZGlyZWN0UmVxdWVzdCxcbiAgU2lsZW50UmVxdWVzdCxcbiAgTG9nZ2VyLFxuICBTc29TaWxlbnRSZXF1ZXN0LFxufSBmcm9tIFwiQGF6dXJlL21zYWwtYnJvd3NlclwiO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSU1zYWxTZXJ2aWNlIHtcbiAgaW5pdGlhbGl6ZSgpOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICBhY3F1aXJlVG9rZW5Qb3B1cChyZXF1ZXN0OiBQb3B1cFJlcXVlc3QpOiBPYnNlcnZhYmxlPEF1dGhlbnRpY2F0aW9uUmVzdWx0PjtcbiAgYWNxdWlyZVRva2VuUmVkaXJlY3QocmVxdWVzdDogUmVkaXJlY3RSZXF1ZXN0KTogT2JzZXJ2YWJsZTx2b2lkPjtcbiAgYWNxdWlyZVRva2VuU2lsZW50KFxuICAgIHNpbGVudFJlcXVlc3Q6IFNpbGVudFJlcXVlc3RcbiAgKTogT2JzZXJ2YWJsZTxBdXRoZW50aWNhdGlvblJlc3VsdD47XG4gIGhhbmRsZVJlZGlyZWN0T2JzZXJ2YWJsZSgpOiBPYnNlcnZhYmxlPEF1dGhlbnRpY2F0aW9uUmVzdWx0IHwgbnVsbD47XG4gIGxvZ2luUG9wdXAocmVxdWVzdD86IFBvcHVwUmVxdWVzdCk6IE9ic2VydmFibGU8QXV0aGVudGljYXRpb25SZXN1bHQ+O1xuICBsb2dpblJlZGlyZWN0KHJlcXVlc3Q/OiBSZWRpcmVjdFJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICAvLyBAZGVwcmVjYXRlZDogVXNlIGxvZ291dFJlZGlyZWN0IG9yIGxvZ291dFBvcHVwXG4gIGxvZ291dChsb2dvdXRSZXF1ZXN0PzogRW5kU2Vzc2lvblJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICBsb2dvdXRSZWRpcmVjdChsb2dvdXRSZXF1ZXN0PzogRW5kU2Vzc2lvblJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICBsb2dvdXRQb3B1cChsb2dvdXRSZXF1ZXN0PzogRW5kU2Vzc2lvblJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICBzc29TaWxlbnQocmVxdWVzdDogU3NvU2lsZW50UmVxdWVzdCk6IE9ic2VydmFibGU8QXV0aGVudGljYXRpb25SZXN1bHQ+O1xuICBnZXRMb2dnZXIoKTogTG9nZ2VyO1xuICBzZXRMb2dnZXIobG9nZ2VyOiBMb2dnZXIpOiB2b2lkO1xufVxuIl19

package/esm2020/azure-msal-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp1cmUtbXNhbC1hbmd1bGFyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2F6dXJlLW1zYWwtYW5ndWxhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/constants.mjs

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { InjectionToken } from "@angular/core";
+export const MSAL_INSTANCE = new InjectionToken("MSAL_INSTANCE");
+export const MSAL_GUARD_CONFIG = new InjectionToken("MSAL_GUARD_CONFIG");
+export const MSAL_INTERCEPTOR_CONFIG = new InjectionToken("MSAL_INTERCEPTOR_CONFIG");
+export const MSAL_BROADCAST_CONFIG = new InjectionToken("MSAL_BROADCAST_CONFIG");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxJQUFJLGNBQWMsQ0FBUyxlQUFlLENBQUMsQ0FBQztBQUV6RSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGNBQWMsQ0FDakQsbUJBQW1CLENBQ3BCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxJQUFJLGNBQWMsQ0FDdkQseUJBQXlCLENBQzFCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLGNBQWMsQ0FDckQsdUJBQXVCLENBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5leHBvcnQgY29uc3QgTVNBTF9JTlNUQU5DRSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmc+KFwiTVNBTF9JTlNUQU5DRVwiKTtcblxuZXhwb3J0IGNvbnN0IE1TQUxfR1VBUkRfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oXG4gIFwiTVNBTF9HVUFSRF9DT05GSUdcIlxuKTtcblxuZXhwb3J0IGNvbnN0IE1TQUxfSU5URVJDRVBUT1JfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oXG4gIFwiTVNBTF9JTlRFUkNFUFRPUl9DT05GSUdcIlxuKTtcblxuZXhwb3J0IGNvbnN0IE1TQUxfQlJPQURDQVNUX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmc+KFxuICBcIk1TQUxfQlJPQURDQVNUX0NPTkZJR1wiXG4pO1xuIl19

package/esm2020/msal.broadcast.config.mjs

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

package/esm2020/msal.broadcast.service.mjs

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Inject, Injectable, Optional } from "@angular/core";
+import { EventMessageUtils, InteractionStatus, } from "@azure/msal-browser";
+import { BehaviorSubject, ReplaySubject, Subject } from "rxjs";
+import { MSAL_BROADCAST_CONFIG, MSAL_INSTANCE } from "./constants";
+import { name, version } from "./packageMetadata";
+import * as i0 from "@angular/core";
+export class MsalBroadcastService {
+    constructor(msalInstance, msalBroadcastConfig) {
+        this.msalInstance = msalInstance;
+        this.msalBroadcastConfig = msalBroadcastConfig;
+        // Make _msalSubject a ReplaySubject if configured to replay past events
+        if (this.msalBroadcastConfig &&
+            this.msalBroadcastConfig.eventsToReplay > 0) {
+            this.msalInstance
+                .getLogger()
+                .clone(name, version)
+                .verbose(`BroadcastService - eventsToReplay set on BroadcastConfig, replaying the last ${this.msalBroadcastConfig.eventsToReplay} events`);
+            this._msalSubject = new ReplaySubject(this.msalBroadcastConfig.eventsToReplay);
+        }
+        else {
+            // Defaults to _msalSubject being a Subject
+            this._msalSubject = new Subject();
+        }
+        this.msalSubject$ = this._msalSubject.asObservable();
+        // InProgress as BehaviorSubject so most recent inProgress state will be available upon subscription
+        this._inProgress = new BehaviorSubject(InteractionStatus.Startup);
+        this.inProgress$ = this._inProgress.asObservable();
+        this.msalInstance.addEventCallback((message) => {
+            this._msalSubject.next(message);
+            const status = EventMessageUtils.getInteractionStatusFromEvent(message, this._inProgress.value);
+            if (status !== null) {
+                this.msalInstance
+                    .getLogger()
+                    .clone(name, version)
+                    .verbose(`BroadcastService - ${message.eventType} results in setting inProgress from ${this._inProgress.value} to ${status}`);
+                this._inProgress.next(status);
+            }
+        });
+    }
+    /**
+     * Resets inProgress state to None
+     */
+    resetInProgressEvent() {
+        if (this._inProgress.value === InteractionStatus.Startup) {
+            this._inProgress.next(InteractionStatus.None);
+        }
+    }
+}
+MsalBroadcastService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalBroadcastService, deps: [{ token: MSAL_INSTANCE }, { token: MSAL_BROADCAST_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalBroadcastService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalBroadcastService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalBroadcastService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_INSTANCE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MSAL_BROADCAST_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/msal.guard.config.mjs

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

package/esm2020/msal.guard.mjs

@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable, Inject } from "@angular/core";
+import { InteractionType, BrowserConfigurationAuthError, BrowserUtils, UrlString, } from "@azure/msal-browser";
+import { of } from "rxjs";
+import { concatMap, catchError, map } from "rxjs/operators";
+import { MSAL_GUARD_CONFIG } from "./constants";
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.broadcast.service";
+import * as i2 from "./msal.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/router";
+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)
+            : { ...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({
+            redirectStartPage,
+            ...authRequest,
+        })
+            .pipe(map(() => false));
+    }
+    /**
+     * Helper which checks for the correct interaction type, prevents page with Guard to be set as redirect, 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.initialize().pipe(concatMap(() => {
+            return this.authService.handleRedirectObservable();
+        }), 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 state is passed before returning route
+             */
+            if (this.loginFailedRoute && 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);
+    }
+    canMatch() {
+        this.authService.getLogger().verbose("Guard - canLoad");
+        return this.activateHelper();
+    }
+}
+MsalGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalGuard, deps: [{ token: MSAL_GUARD_CONFIG }, { token: i1.MsalBroadcastService }, { token: i2.MsalService }, { token: i3.Location }, { token: i4.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MsalGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_GUARD_CONFIG]
+                }] }, { type: i1.MsalBroadcastService }, { type: i2.MsalService }, { type: i3.Location }, { type: i4.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.guard.js","sourceRoot":"","sources":["../../src/msal.guard.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 } from \"@angular/common\";\nimport {\n  ActivatedRouteSnapshot,\n  RouterStateSnapshot,\n  UrlTree,\n  Router,\n} from \"@angular/router\";\nimport {\n  InteractionType,\n  BrowserConfigurationAuthError,\n  BrowserUtils,\n  UrlString,\n  PopupRequest,\n  RedirectRequest,\n  AuthenticationResult,\n} from \"@azure/msal-browser\";\nimport { Observable, of } from \"rxjs\";\nimport { concatMap, catchError, map } from \"rxjs/operators\";\nimport { MsalService } from \"./msal.service\";\nimport { MsalGuardConfiguration } from \"./msal.guard.config\";\nimport { MsalBroadcastService } from \"./msal.broadcast.service\";\nimport { MSAL_GUARD_CONFIG } from \"./constants\";\n\n@Injectable()\nexport class MsalGuard {\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(\n      baseElements.length ? baseElements[0].href : window.location.origin\n    );\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\n        .getLogger()\n        .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 =\n      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).pipe(\n        map((response: AuthenticationResult) => {\n          this.authService\n            .getLogger()\n            .verbose(\n              \"Guard - login by popup successful, can activate, setting active account\"\n            );\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\n      .loginRedirect({\n        redirectStartPage,\n        ...authRequest,\n      } as RedirectRequest)\n      .pipe(map(() => false));\n  }\n\n  /**\n   * Helper which checks for the correct interaction type, prevents page with Guard to be set as redirect, and calls handleRedirectObservable\n   * @param state\n   */\n  private activateHelper(\n    state?: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    if (\n      this.msalGuardConfig.interactionType !== InteractionType.Popup &&\n      this.msalGuardConfig.interactionType !== InteractionType.Redirect\n    ) {\n      throw new BrowserConfigurationAuthError(\n        \"invalid_interaction_type\",\n        \"Invalid interaction type provided to MSAL Guard. InteractionType.Popup or InteractionType.Redirect must be provided in the MsalGuardConfiguration\"\n      );\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 (\n        UrlString.hashContainsKnownProperties(window.location.hash) &&\n        BrowserUtils.isInIframe() &&\n        !this.authService.instance.getConfiguration().system\n          .allowRedirectInIframe\n      ) {\n        this.authService\n          .getLogger()\n          .warning(\n            \"Guard - redirectUri set to page with MSAL Guard. It is recommended to not set redirectUri to a page that requires authentication.\"\n          );\n        return of(false);\n      }\n    } else {\n      this.authService\n        .getLogger()\n        .info(\n          \"Guard - window is undefined, MSAL does not support server-side token acquisition\"\n        );\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(\n        this.msalGuardConfig.loginFailedRoute\n      );\n    }\n\n    // Capture current path before it gets changed by handleRedirectObservable\n    const currentPath = this.location.path(true);\n\n    return this.authService.initialize().pipe(\n      concatMap(() => {\n        return this.authService.handleRedirectObservable();\n      }),\n      concatMap(() => {\n        if (!this.authService.instance.getAllAccounts().length) {\n          if (state) {\n            this.authService\n              .getLogger()\n              .verbose(\n                \"Guard - no accounts retrieved, log in required to activate\"\n              );\n            return this.loginInteractively(state);\n          }\n          this.authService\n            .getLogger()\n            .verbose(\"Guard - no accounts retrieved, no state, cannot load\");\n          return of(false);\n        }\n\n        this.authService\n          .getLogger()\n          .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 =\n            !!state.root &&\n            !!state.root.fragment &&\n            this.includesCode(`#${state.root.fragment}`);\n          const hashRouting: boolean =\n            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\n              .getLogger()\n              .info(\n                \"Guard - Hash contains known code response, stopping navigation.\"\n              );\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      catchError((error: Error) => {\n        this.authService\n          .getLogger()\n          .error(\"Guard - error while logging in, unable to activate\");\n        this.authService\n          .getLogger()\n          .errorPii(`Guard - error: ${error.message}`);\n        /**\n         * If a loginFailedRoute is set, checks to see if state is passed before returning route\n         */\n        if (this.loginFailedRoute && state) {\n          this.authService\n            .getLogger()\n            .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 (\n      (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\n  canActivate(\n    route: ActivatedRouteSnapshot,\n    state: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose(\"Guard - canActivate\");\n    return this.activateHelper(state);\n  }\n\n  canActivateChild(\n    route: ActivatedRouteSnapshot,\n    state: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose(\"Guard - canActivateChild\");\n    return this.activateHelper(state);\n  }\n\n  canMatch(): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose(\"Guard - canLoad\");\n    return this.activateHelper();\n  }\n}\n"]}

package/esm2020/msal.interceptor.config.mjs

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5pbnRlcmNlcHRvci5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNhbC5pbnRlcmNlcHRvci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgTWljcm9zb2Z0IENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICogTGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLlxuICovXG5cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBpbXBvcnQvbm8tdW5yZXNvbHZlZFxuaW1wb3J0IHsgSHR0cFJlcXVlc3QgfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uL2h0dHBcIjtcbmltcG9ydCB7XG4gIFBvcHVwUmVxdWVzdCxcbiAgUmVkaXJlY3RSZXF1ZXN0LFxuICBJbnRlcmFjdGlvblR5cGUsXG4gIFNpbGVudFJlcXVlc3QsXG59IGZyb20gXCJAYXp1cmUvbXNhbC1icm93c2VyXCI7XG5pbXBvcnQgeyBNc2FsU2VydmljZSB9IGZyb20gXCIuL21zYWwuc2VydmljZVwiO1xuXG5leHBvcnQgZGVjbGFyZSB0eXBlIE1zYWxJbnRlcmNlcHRvckF1dGhSZXF1ZXN0ID1cbiAgfCBPbWl0PFBvcHVwUmVxdWVzdCwgXCJzY29wZXNcIj5cbiAgfCBPbWl0PFJlZGlyZWN0UmVxdWVzdCwgXCJzY29wZXNcIj5cbiAgfCBPbWl0PFNpbGVudFJlcXVlc3QsIFwic2NvcGVzXCI+O1xuXG5leHBvcnQgdHlwZSBNc2FsSW50ZXJjZXB0b3JDb25maWd1cmF0aW9uID0ge1xuICBpbnRlcmFjdGlvblR5cGU6IEludGVyYWN0aW9uVHlwZS5Qb3B1cCB8IEludGVyYWN0aW9uVHlwZS5SZWRpcmVjdDtcbiAgcHJvdGVjdGVkUmVzb3VyY2VNYXA6IE1hcDxcbiAgICBzdHJpbmcsXG4gICAgQXJyYXk8c3RyaW5nIHwgUHJvdGVjdGVkUmVzb3VyY2VTY29wZXM+IHwgbnVsbFxuICA+O1xuICBhdXRoUmVxdWVzdD86XG4gICAgfCBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdFxuICAgIHwgKChcbiAgICAgICAgbXNhbFNlcnZpY2U6IE1zYWxTZXJ2aWNlLFxuICAgICAgICByZXE6IEh0dHBSZXF1ZXN0PHVua25vd24+LFxuICAgICAgICBvcmlnaW5hbEF1dGhSZXF1ZXN0OiBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdFxuICAgICAgKSA9PiBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdCk7XG59O1xuXG5leHBvcnQgdHlwZSBQcm90ZWN0ZWRSZXNvdXJjZVNjb3BlcyA9IHtcbiAgaHR0cE1ldGhvZDogc3RyaW5nO1xuICBzY29wZXM6IEFycmF5PHN0cmluZz4gfCBudWxsO1xufTtcbiJdfQ==