@azure/msal-browser 3.2.0 → 3.3.0

package/dist/interaction_handler/SilentHandler.mjs

@@ -1,172 +1,137 @@
-/*! @azure/msal-browser v3.2.0 2023-10-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
-import { PerformanceEvents, invokeAsync, Constants, UrlString } from '@azure/msal-common';
-import { InteractionHandler } from './InteractionHandler.mjs';
+import { PerformanceEvents, invokeAsync, invoke } from '@azure/msal-common';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { DEFAULT_IFRAME_TIMEOUT_MS } from '../config/Configuration.mjs';
-import { emptyNavigateUri, monitorWindowTimeout, hashDoesNotContainKnownProperties, hashEmptyError } from '../error/BrowserAuthErrorCodes.mjs';
+import { emptyNavigateUri, monitorWindowTimeout } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-class SilentHandler extends InteractionHandler {
-    constructor(authCodeModule, storageImpl, authCodeRequest, logger, systemOptions, performanceClient) {
-        super(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient);
-        this.navigateFrameWait = systemOptions.navigateFrameWait;
-        this.pollIntervalMilliseconds = systemOptions.pollIntervalMilliseconds;
-    }
-    /**
-     * Creates a hidden iframe to given URL using user-requested scopes as an id.
-     * @param urlNavigate
-     * @param userRequestScopes
-     */
-    async initiateAuthRequest(requestUrl) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerInitiateAuthRequest, this.authCodeRequest.correlationId);
-        if (!requestUrl) {
-            // Throw error if request URL is empty.
-            this.logger.info("Navigate url is empty");
-            throw createBrowserAuthError(emptyNavigateUri);
-        }
-        if (this.navigateFrameWait) {
-            return await invokeAsync(this.loadFrame.bind(this), PerformanceEvents.SilentHandlerLoadFrame, this.logger, this.performanceClient, this.authCodeRequest.correlationId)(requestUrl);
-        }
-        return this.loadFrameSync(requestUrl);
+/**
+ * Creates a hidden iframe to given URL using user-requested scopes as an id.
+ * @param urlNavigate
+ * @param userRequestScopes
+ */
+async function initiateAuthRequest(requestUrl, performanceClient, logger, correlationId, navigateFrameWait) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerInitiateAuthRequest, correlationId);
+    if (!requestUrl) {
+        // Throw error if request URL is empty.
+        logger.info("Navigate url is empty");
+        throw createBrowserAuthError(emptyNavigateUri);
     }
-    /**
-     * Monitors an iframe content window until it loads a url with a known hash, or hits a specified timeout.
-     * @param iframe
-     * @param timeout
-     */
-    monitorIframeForHash(iframe, timeout) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerMonitorIframeForHash, this.authCodeRequest.correlationId);
-        return new Promise((resolve, reject) => {
-            if (timeout < DEFAULT_IFRAME_TIMEOUT_MS) {
-                this.logger.warning(`system.loadFrameTimeout or system.iframeHashTimeout set to lower (${timeout}ms) than the default (${DEFAULT_IFRAME_TIMEOUT_MS}ms). This may result in timeouts.`);
-            }
-            /*
-             * Polling for iframes can be purely timing based,
-             * since we don't need to account for interaction.
-             */
-            const nowMark = window.performance.now();
-            const timeoutMark = nowMark + timeout;
-            const intervalId = setInterval(() => {
-                if (window.performance.now() > timeoutMark) {
-                    this.removeHiddenIframe(iframe);
-                    clearInterval(intervalId);
-                    reject(createBrowserAuthError(monitorWindowTimeout));
-                    return;
-                }
-                let href = Constants.EMPTY_STRING;
-                const contentWindow = iframe.contentWindow;
-                try {
-                    /*
-                     * Will throw if cross origin,
-                     * which should be caught and ignored
-                     * since we need the interval to keep running while on STS UI.
-                     */
-                    href = contentWindow
-                        ? contentWindow.location.href
-                        : Constants.EMPTY_STRING;
-                }
-                catch (e) { }
-                if (!href || href === "about:blank") {
-                    return;
-                }
-                const contentHash = contentWindow
-                    ? contentWindow.location.hash
-                    : Constants.EMPTY_STRING;
-                if (contentHash) {
-                    if (UrlString.hashContainsKnownProperties(contentHash)) {
-                        // Success case
-                        this.removeHiddenIframe(iframe);
-                        clearInterval(intervalId);
-                        resolve(contentHash);
-                        return;
-                    }
-                    else {
-                        // Hash is present but incorrect
-                        this.logger.error("SilentHandler:monitorIFrameForHash - a hash is present in the iframe but it does not contain known properties. It's likely that the hash has been replaced by code running on the redirectUri page.");
-                        this.logger.errorPii(`SilentHandler:monitorIFrameForHash - the url detected in the iframe is: ${href}`);
-                        this.removeHiddenIframe(iframe);
-                        clearInterval(intervalId);
-                        reject(createBrowserAuthError(hashDoesNotContainKnownProperties));
-                        return;
-                    }
-                }
-                else {
-                    // No hash is present
-                    this.logger.error("SilentHandler:monitorIFrameForHash - the request has returned to the redirectUri but a hash is not present in the iframe. It's likely that the hash has been removed or the page has been redirected by code running on the redirectUri page.");
-                    this.logger.errorPii(`SilentHandler:monitorIFrameForHash - the url detected in the iframe is: ${href}`);
-                    this.removeHiddenIframe(iframe);
-                    clearInterval(intervalId);
-                    reject(createBrowserAuthError(hashEmptyError));
-                    return;
-                }
-            }, this.pollIntervalMilliseconds);
-        });
+    if (navigateFrameWait) {
+        return await invokeAsync(loadFrame, PerformanceEvents.SilentHandlerLoadFrame, logger, performanceClient, correlationId)(requestUrl, navigateFrameWait, performanceClient, correlationId);
     }
-    /**
-     * @hidden
-     * Loads iframe with authorization endpoint URL
-     * @ignore
-     */
-    loadFrame(urlNavigate) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerLoadFrame, this.authCodeRequest.correlationId);
+    return invoke(loadFrameSync, PerformanceEvents.SilentHandlerLoadFrameSync, logger, performanceClient, correlationId)(requestUrl);
+}
+/**
+ * Monitors an iframe content window until it loads a url with a known hash, or hits a specified timeout.
+ * @param iframe
+ * @param timeout
+ */
+async function monitorIframeForHash(iframe, timeout, pollIntervalMilliseconds, performanceClient, logger, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerMonitorIframeForHash, correlationId);
+    return new Promise((resolve, reject) => {
+        if (timeout < DEFAULT_IFRAME_TIMEOUT_MS) {
+            logger.warning(`system.loadFrameTimeout or system.iframeHashTimeout set to lower (${timeout}ms) than the default (${DEFAULT_IFRAME_TIMEOUT_MS}ms). This may result in timeouts.`);
+        }
         /*
-         * This trick overcomes iframe navigation in IE
-         * IE does not load the page consistently in iframe
+         * Polling for iframes can be purely timing based,
+         * since we don't need to account for interaction.
          */
-        return new Promise((resolve, reject) => {
-            const frameHandle = this.createHiddenIframe();
-            setTimeout(() => {
-                if (!frameHandle) {
-                    reject("Unable to load iframe");
-                    return;
-                }
-                frameHandle.src = urlNavigate;
-                resolve(frameHandle);
-            }, this.navigateFrameWait);
-        });
-    }
-    /**
-     * @hidden
-     * Loads the iframe synchronously when the navigateTimeFrame is set to `0`
-     * @param urlNavigate
-     * @param frameName
-     * @param logger
-     */
-    loadFrameSync(urlNavigate) {
-        const frameHandle = this.createHiddenIframe();
-        frameHandle.src = urlNavigate;
-        return frameHandle;
-    }
-    /**
-     * @hidden
-     * Creates a new hidden iframe or gets an existing one for silent token renewal.
-     * @ignore
-     */
-    createHiddenIframe() {
-        const authFrame = document.createElement("iframe");
-        authFrame.style.visibility = "hidden";
-        authFrame.style.position = "absolute";
-        authFrame.style.width = authFrame.style.height = "0";
-        authFrame.style.border = "0";
-        authFrame.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms");
-        document.getElementsByTagName("body")[0].appendChild(authFrame);
-        return authFrame;
-    }
-    /**
-     * @hidden
-     * Removes a hidden iframe from the page.
-     * @ignore
+        const timeoutId = window.setTimeout(() => {
+            window.clearInterval(intervalId);
+            reject(createBrowserAuthError(monitorWindowTimeout));
+        }, timeout);
+        const intervalId = window.setInterval(() => {
+            let href = "";
+            const contentWindow = iframe.contentWindow;
+            try {
+                /*
+                 * Will throw if cross origin,
+                 * which should be caught and ignored
+                 * since we need the interval to keep running while on STS UI.
+                 */
+                href = contentWindow ? contentWindow.location.href : "";
+            }
+            catch (e) { }
+            if (!href || href === "about:blank") {
+                return;
+            }
+            const contentHash = contentWindow
+                ? contentWindow.location.hash
+                : "";
+            window.clearTimeout(timeoutId);
+            window.clearInterval(intervalId);
+            resolve(contentHash);
+        }, pollIntervalMilliseconds);
+    }).finally(() => {
+        invoke(removeHiddenIframe, PerformanceEvents.RemoveHiddenIframe, logger, performanceClient, correlationId)(iframe);
+    });
+}
+/**
+ * @hidden
+ * Loads iframe with authorization endpoint URL
+ * @ignore
+ * @deprecated
+ */
+function loadFrame(urlNavigate, navigateFrameWait, performanceClient, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.SilentHandlerLoadFrame, correlationId);
+    /*
+     * This trick overcomes iframe navigation in IE
+     * IE does not load the page consistently in iframe
      */
-    removeHiddenIframe(iframe) {
-        if (document.body === iframe.parentNode) {
-            document.body.removeChild(iframe);
-        }
+    return new Promise((resolve, reject) => {
+        const frameHandle = createHiddenIframe();
+        window.setTimeout(() => {
+            if (!frameHandle) {
+                reject("Unable to load iframe");
+                return;
+            }
+            frameHandle.src = urlNavigate;
+            resolve(frameHandle);
+        }, navigateFrameWait);
+    });
+}
+/**
+ * @hidden
+ * Loads the iframe synchronously when the navigateTimeFrame is set to `0`
+ * @param urlNavigate
+ * @param frameName
+ * @param logger
+ */
+function loadFrameSync(urlNavigate) {
+    const frameHandle = createHiddenIframe();
+    frameHandle.src = urlNavigate;
+    return frameHandle;
+}
+/**
+ * @hidden
+ * Creates a new hidden iframe or gets an existing one for silent token renewal.
+ * @ignore
+ */
+function createHiddenIframe() {
+    const authFrame = document.createElement("iframe");
+    authFrame.style.visibility = "hidden";
+    authFrame.style.position = "absolute";
+    authFrame.style.width = authFrame.style.height = "0";
+    authFrame.style.border = "0";
+    authFrame.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms");
+    document.getElementsByTagName("body")[0].appendChild(authFrame);
+    return authFrame;
+}
+/**
+ * @hidden
+ * Removes a hidden iframe from the page.
+ * @ignore
+ */
+function removeHiddenIframe(iframe) {
+    if (document.body === iframe.parentNode) {
+        document.body.removeChild(iframe);
     }
 }
 
-export { SilentHandler };
+export { initiateAuthRequest, monitorIframeForHash };
 //# sourceMappingURL=SilentHandler.mjs.map

package/dist/interaction_handler/SilentHandler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"SilentHandler.mjs","sources":["../../src/interaction_handler/SilentHandler.ts"],"sourcesContent":[null],"names":["BrowserAuthErrorCodes.emptyNavigateUri"],"mappings":";;;;;;;;AAKA;AAUA;AAKA;AACA;AAiCI,MAAA,aAAA,SAAA,kBAAA,CAAA;;;;AAIG,QAAA,IAAA,CAAA,wBAAA,GAAA,aAAA,CAAA,wBAAA,CAAA;KACsB;AA0BzB;;;;AAIG;AACH,IAAA,MAAA,mBACI,CAAA,UAAQ,EAAA;AAmGZ,QAAA,IAAA,CAAA,iBAAA,CAAA,mBAAA,CAAA,iBAAA,CAAA,gCAAA,EAAA,IAAA,CAAA,eAAA,CAAA,aAAA,CAAA,CAAA;;;;AAIG,YAAA,MAAA,sBAAA,CAAAA,gBAAA,CAAA,CAAA;AACH,SAAA;AA2BA,QAAA,IAAA,IAAA,CAAA,iBAAA,EAAA;;;;;;AAMG;AACH;AAQA;;;;AAIG,QAAA,OAAA,IAAA,OAAA,CAAA,CAAA,OAAA,EAAA,MAAA,KAAA;AACH,YAAQ,IAAkB,OAAA,GAAA,yBAAA,EAAA;AAgB1B,gBAAA,IAAA,CAAA,MAAA,CAAA,OAAA,CAAA,CAAA,kEAAA,EAAA,OAAA,CAAA,sBAAA,EAAA,yBAAA,CAAA,iCAAA,CAAA,CAAA,CAAA;;;;AAIG;AACH;AAKH,YAAA,MAAA,OAAA,GAAA,MAAA,CAAA,WAAA,CAAA,GAAA,EAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"SilentHandler.mjs","sources":["../../src/interaction_handler/SilentHandler.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAKA;AAaA;;;AAwCA;;;;AAIG;AACH,eAAA,mBAA0C,CAAA,UAChC,EAAmB,iBAAA,EAClB,MAAA,EAAE,aACe,EAAA,iBAAA,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/naa/AccountInfo.d.ts

@@ -0,0 +1,13 @@
+export type AccountInfo = {
+    homeAccountId: string;
+    environment: string;
+    tenantId: string;
+    username: string;
+    localAccountId: string;
+    name?: string;
+    idToken?: string;
+    platformBrokerId?: string;
+    idTokenClaims?: object;
+    client_info?: string;
+};
+//# sourceMappingURL=AccountInfo.d.ts.map

package/dist/naa/AccountInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountInfo.d.ts","sourceRoot":"","sources":["../../src/naa/AccountInfo.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dist/naa/AccountRequests.d.ts

@@ -0,0 +1,10 @@
+export type AccountByHomeIdRequest = {
+    homeAccountId: string;
+};
+export type AccountByLocalIdRequest = {
+    localAccountId: string;
+};
+export type AccountByUsernameRequest = {
+    username: string;
+};
+//# sourceMappingURL=AccountRequests.d.ts.map

package/dist/naa/AccountRequests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountRequests.d.ts","sourceRoot":"","sources":["../../src/naa/AccountRequests.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,sBAAsB,GAAG;IACjC,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAClC,cAAc,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACnC,QAAQ,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/naa/AuthBridge.d.ts

@@ -0,0 +1,6 @@
+export interface AuthBridge {
+    addEventListener: (eventName: string, callback: (response: string) => void) => void;
+    postMessage: (message: string) => void;
+    removeEventListener: (eventName: string, callback: (response: string) => void) => void;
+}
+//# sourceMappingURL=AuthBridge.d.ts.map

package/dist/naa/AuthBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthBridge.d.ts","sourceRoot":"","sources":["../../src/naa/AuthBridge.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,UAAU;IACvB,gBAAgB,EAAE,CACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,KACnC,IAAI,CAAC;IACV,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,mBAAmB,EAAE,CACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,KACnC,IAAI,CAAC;CACb"}

package/dist/naa/BridgeCapabilities.d.ts

@@ -0,0 +1,4 @@
+export interface BridgeCapabilities {
+    queryAccount: boolean;
+}
+//# sourceMappingURL=BridgeCapabilities.d.ts.map

package/dist/naa/BridgeCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeCapabilities.d.ts","sourceRoot":"","sources":["../../src/naa/BridgeCapabilities.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IAC/B,YAAY,EAAE,OAAO,CAAC;CACzB"}

package/dist/naa/BridgeError.d.ts

@@ -0,0 +1,10 @@
+import { BridgeStatusCode } from "./BridgeStatusCode";
+export type BridgeError = {
+    status: BridgeStatusCode;
+    code: string;
+    subError: string;
+    description: string;
+    properties: object;
+};
+export declare function isBridgeError(error: unknown): error is BridgeError;
+//# sourceMappingURL=BridgeError.d.ts.map

package/dist/naa/BridgeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeError.d.ts","sourceRoot":"","sources":["../../src/naa/BridgeError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,MAAM,WAAW,GAAG;IACtB,MAAM,EAAE,gBAAgB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE"}

package/dist/naa/BridgeError.mjs

@@ -0,0 +1,12 @@
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+function isBridgeError(error) {
+    return error.status !== undefined;
+}
+
+export { isBridgeError };
+//# sourceMappingURL=BridgeError.mjs.map

package/dist/naa/BridgeError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeError.mjs","sources":["../../src/naa/BridgeError.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;AAEA;;;AAGY,sBAAS,CAAA,KAAA,EAAA;IACjB,OAAW,KAAA,CAAE,MAAM,KAAC,SAAA,CAAA;;;;;"}

package/dist/naa/BridgeProxy.d.ts

@@ -0,0 +1,72 @@
+import { AccountInfo } from "./AccountInfo";
+import { AccountByHomeIdRequest, AccountByLocalIdRequest, AccountByUsernameRequest } from "./AccountRequests";
+import { AuthBridge } from "./AuthBridge";
+import { BridgeCapabilities } from "./BridgeCapabilities";
+import { IBridgeProxy } from "./IBridgeProxy";
+import { InitializeBridgeResponse } from "./InitializeBridgeResponse";
+import { TokenRequest } from "./TokenRequest";
+import { TokenResponse } from "./TokenResponse";
+declare global {
+    interface Window {
+        nestedAppAuthBridge: AuthBridge;
+    }
+}
+/**
+ * BridgeProxy
+ * Provides a proxy for accessing a bridge to a host app and/or
+ * platform broker
+ */
+export declare class BridgeProxy implements IBridgeProxy {
+    static bridgeRequests: any[];
+    static crypto: Crypto;
+    sdkName: string;
+    sdkVersion: string;
+    capabilities: BridgeCapabilities;
+    /**
+     * initializeNestedAppAuthBridge - Initializes the bridge to the host app
+     * @returns a promise that resolves to an InitializeBridgeResponse or rejects with an Error
+     * @remarks This method will be called by the create factory method
+     * @remarks If the bridge is not available, this method will throw an error
+     */
+    protected static initializeNestedAppAuthBridge(): Promise<InitializeBridgeResponse>;
+    static getRandomId(): string;
+    /**
+     * getTokenInteractive - Attempts to get a token interactively from the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a token response or rejects with a BridgeError
+     */
+    getTokenInteractive(request: TokenRequest): Promise<TokenResponse>;
+    /**
+     * getTokenSilent Attempts to get a token silently from the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a token response or rejects with a BridgeError
+     */
+    getTokenSilent(request: TokenRequest): Promise<TokenResponse>;
+    /**
+     * getAccountInfo - Gets account information from the bridge
+     *
+     * @param request A request for account information
+     */
+    getAccountInfo(request: AccountByHomeIdRequest | AccountByLocalIdRequest | AccountByUsernameRequest): Promise<AccountInfo>;
+    getActiveAccount(): Promise<AccountInfo>;
+    /**
+     * A method used to send a request to the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a response of provided type or rejects with a BridgeError
+     */
+    private sendRequest;
+    /**
+     * Private constructor for BridgeProxy
+     * @param sdkName The name of the SDK being used to make requests on behalf of the app
+     * @param sdkVersion The version of the SDK being used to make requests on behalf of the app
+     * @param capabilities The capabilities of the bridge / SDK / platform broker
+     */
+    private constructor();
+    /**
+     * Factory method for creating an implementation of IBridgeProxy
+     * @returns A promise that resolves to a BridgeProxy implementation
+     */
+    static create(): Promise<IBridgeProxy>;
+}
+export default BridgeProxy;
+//# sourceMappingURL=BridgeProxy.d.ts.map

package/dist/naa/BridgeProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeProxy.d.ts","sourceRoot":"","sources":["../../src/naa/BridgeProxy.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACH,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,mBAAmB,EAAE,UAAU,CAAC;KACnC;CACJ;AAED;;;;GAIG;AACH,qBAAa,WAAY,YAAW,YAAY;IAE5C,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAAM;IAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,kBAAkB,CAAC;IAEjC;;;;;OAKG;qBACoB,6BAA6B,IAAI,OAAO,CAAC,wBAAwB,CAAC;WAgE3E,WAAW,IAAI,MAAM;IAInC;;;;OAIG;IACI,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAIzE;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAIpE;;;;OAIG;IACI,cAAc,CACjB,OAAO,EACD,sBAAsB,GACtB,uBAAuB,GACvB,wBAAwB,GAC/B,OAAO,CAAC,WAAW,CAAC;IAkBhB,gBAAgB,IAAI,OAAO,CAAC,WAAW,CAAC;IAI/C;;;;OAIG;IACH,OAAO,CAAC,WAAW;IA8BnB;;;;;OAKG;IACH,OAAO;IAUP;;;OAGG;WACiB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;CAQtD;AAED,eAAe,WAAW,CAAC"}

package/dist/naa/BridgeProxy.mjs

@@ -0,0 +1,154 @@
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * BridgeProxy
+ * Provides a proxy for accessing a bridge to a host app and/or
+ * platform broker
+ */
+class BridgeProxy {
+    /**
+     * initializeNestedAppAuthBridge - Initializes the bridge to the host app
+     * @returns a promise that resolves to an InitializeBridgeResponse or rejects with an Error
+     * @remarks This method will be called by the create factory method
+     * @remarks If the bridge is not available, this method will throw an error
+     */
+    static async initializeNestedAppAuthBridge() {
+        if (window === undefined) {
+            throw new Error("window is undefined");
+        }
+        if (window.nestedAppAuthBridge === undefined) {
+            throw new Error("window.nestedAppAuthBridge is undefined");
+        }
+        if (window.crypto === undefined) {
+            throw new Error("window.crypto is undefined");
+        }
+        try {
+            BridgeProxy.crypto = window.crypto;
+            window.nestedAppAuthBridge.addEventListener("message", (response) => {
+                const responseEnvelope = JSON.parse(response);
+                const request = BridgeProxy.bridgeRequests.find((element) => element.requestId === responseEnvelope.requestId);
+                if (request !== undefined) {
+                    BridgeProxy.bridgeRequests.splice(BridgeProxy.bridgeRequests.indexOf(request), 1);
+                    if (responseEnvelope.success) {
+                        request.resolve(responseEnvelope.body);
+                    }
+                    else {
+                        request.reject(responseEnvelope.body);
+                    }
+                }
+            });
+            const promise = new Promise((resolve, reject) => {
+                const message = {
+                    messageType: "NestedAppAuthRequest",
+                    method: "GetInitContext",
+                    requestId: BridgeProxy.getRandomId(),
+                };
+                const request = {
+                    requestId: message.requestId,
+                    method: message.method,
+                    resolve: resolve,
+                    reject: reject,
+                };
+                BridgeProxy.bridgeRequests.push(request);
+                window.nestedAppAuthBridge.postMessage(JSON.stringify(message));
+            });
+            return promise;
+        }
+        catch (error) {
+            window.console.log(error);
+            throw error;
+        }
+    }
+    static getRandomId() {
+        return BridgeProxy.crypto.randomUUID();
+    }
+    /**
+     * getTokenInteractive - Attempts to get a token interactively from the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a token response or rejects with a BridgeError
+     */
+    getTokenInteractive(request) {
+        return this.sendRequest("GetTokenPopup", request);
+    }
+    /**
+     * getTokenSilent Attempts to get a token silently from the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a token response or rejects with a BridgeError
+     */
+    getTokenSilent(request) {
+        return this.sendRequest("GetToken", request);
+    }
+    /**
+     * getAccountInfo - Gets account information from the bridge
+     *
+     * @param request A request for account information
+     */
+    getAccountInfo(request) {
+        let method = "GetAccountByHomeId";
+        if (request.homeAccountId !== undefined) {
+            method = "GetAccountByHomeId";
+        }
+        if (request.localAccountId !== undefined) {
+            method = "GetAccountByLocalId";
+        }
+        if (request.username !== undefined) {
+            method = "GetAccountByUsername";
+        }
+        return this.sendRequest(method, request);
+    }
+    getActiveAccount() {
+        return this.sendRequest("GetActiveAccount", undefined);
+    }
+    /**
+     * A method used to send a request to the bridge
+     * @param request A token request
+     * @returns a promise that resolves to a response of provided type or rejects with a BridgeError
+     */
+    sendRequest(method, request) {
+        const message = {
+            messageType: "NestedAppAuthRequest",
+            method: method,
+            requestId: BridgeProxy.getRandomId(),
+            body: request,
+        };
+        const promise = new Promise((resolve, reject) => {
+            const request = {
+                requestId: message.requestId,
+                method: message.method,
+                resolve: resolve,
+                reject: reject,
+            };
+            BridgeProxy.bridgeRequests.push(request);
+            window.nestedAppAuthBridge.postMessage(JSON.stringify(message));
+        });
+        return promise;
+    }
+    /**
+     * Private constructor for BridgeProxy
+     * @param sdkName The name of the SDK being used to make requests on behalf of the app
+     * @param sdkVersion The version of the SDK being used to make requests on behalf of the app
+     * @param capabilities The capabilities of the bridge / SDK / platform broker
+     */
+    constructor(sdkName, sdkVersion, capabilities) {
+        this.sdkName = sdkName;
+        this.sdkVersion = sdkVersion;
+        this.capabilities = capabilities;
+    }
+    /**
+     * Factory method for creating an implementation of IBridgeProxy
+     * @returns A promise that resolves to a BridgeProxy implementation
+     */
+    static async create() {
+        const response = await BridgeProxy.initializeNestedAppAuthBridge();
+        return new BridgeProxy(response.sdkName, response.sdkVersion, response.capabilities);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+BridgeProxy.bridgeRequests = [];
+
+export { BridgeProxy, BridgeProxy as default };
+//# sourceMappingURL=BridgeProxy.mjs.map

package/dist/naa/BridgeProxy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeProxy.mjs","sources":["../../src/naa/BridgeProxy.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;AACA;AAKA;AACA;AAIA;AACA;AACA;AACA;AAEA;AACI,MAAA,WAAgB,CAAA;;AAEf;AACJ;AAED;;;;AAIG,QAAA,IAAA,MAAA,KAAA,SAAA,EAAA;AACH,YAAa,MAAA,IAAA,KAAA,CAAA,qBAAmC,CAAA,CAAA;AAE5C,SAAA;AACA,QAAA,IAAO,MAAQ,CAAA,mBAAO,KAAA,SAAA,EAAA;YACf,UAAS,KAAA,CAAA,yCAAA,CAAA,CAAA;SACN;QACE,IAAA,MAAE,qBAAmB,EAAA;AAEjC,YAAA,MAAA,IAAA,KAAA,CAAA,4BAAA,CAAA,CAAA;;;;;AAKG,gBAAA,MAAA,gBAAA,GAAA,IAAA,CAAA,KAAA,CAAA,QAAA,CAAA,CAAA;AACoB,gBAAA,MAAA,OAAA,GAAA,WAAA,CAAA,cAAiC,CAAA,IAAQ,CAAA,CAAA,OAAA,KAAA,OAAA,CAAA,SAAyB,KAAA,gBAAA,CAAA,SAAA,CAAA,CAAA;AAgE3E,gBAAA,IAAA,OAAqB,KAAA,SAAA,EAAA;AAInC,oBAAA,WAAA,CAAA,cAAA,CAAA,MAAA,CAAA,WAAA,CAAA,cAAA,CAAA,OAAA,CAAA,OAAA,CAAA,EAAA,CAAA,CAAA,CAAA;;;;AAIG,yBAAA;wBACwB,OAAO,CAAE,MAAA,CAAA,gBAAsB,CAAC;AAI3D,qBAAA;;;;AAIG,gBAAA,MAAA,OAAA,GAAA;+BAC4B,EAAA;AAI/B,oBAAA,MAAA,EAAA,gBAAA;;;;AAIG,oBAAA,SAAA,EAAA,OAAA,CAAA,SAAA;AACI,oBACH,MAAO,EACD,OAAA,CAAA,MAAA;AAqBH,oBAAgB,OAAI,EAAA,OAAQ;AAInC,oBAAA,MAAA,EAAA,MAAA;;;;AAIG,aAAA,CAAA,CAAA;AACH,YAAQ,OAAW,OAAA,CAAA;AA8BnB,SAAA;;;;;AAKG,KAAA;IACH,OAAO,WAAA,GAAA;AAUP,QAAA,OAAA,WAAA,CAAA,MAAA,CAAA,UAAA,EAAA,CAAA;;;AAGG;AACiB;AAQvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/naa/BridgeRequest.d.ts

@@ -0,0 +1,7 @@
+export type BridgeRequest<TResponse> = {
+    requestId: string;
+    method: string;
+    resolve: (value: TResponse | PromiseLike<TResponse>) => void;
+    reject: (reason?: any) => void;
+};
+//# sourceMappingURL=BridgeRequest.d.ts.map

package/dist/naa/BridgeRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeRequest.d.ts","sourceRoot":"","sources":["../../src/naa/BridgeRequest.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,aAAa,CAAC,SAAS,IAAI;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC;IAE7D,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAClC,CAAC"}