@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/broker/nativeBroker/NativeRequest.d.ts

@@ -1,44 +1,44 @@
-import { NativeExtensionMethod } from "../../utils/BrowserConstants";
-import { StringDict } from "@azure/msal-common";
-/**
- * Token request which native broker will use to acquire tokens
- */
-export type NativeTokenRequest = {
-    accountId: string;
-    clientId: string;
-    authority: string;
-    redirectUri: string;
-    scope: string;
-    correlationId: string;
-    windowTitleSubstring: string;
-    prompt?: string;
-    nonce?: string;
-    claims?: string;
-    state?: string;
-    reqCnf?: string;
-    keyId?: string;
-    tokenType?: string;
-    shrClaims?: string;
-    shrNonce?: string;
-    resourceRequestMethod?: string;
-    resourceRequestUri?: string;
-    extendedExpiryToken?: boolean;
-    extraParameters?: StringDict;
-};
-/**
- * Request which will be forwarded to native broker by the browser extension
- */
-export type NativeExtensionRequestBody = {
-    method: NativeExtensionMethod;
-    request?: NativeTokenRequest;
-};
-/**
- * Browser extension request
- */
-export type NativeExtensionRequest = {
-    channel: string;
-    responseId: string;
-    extensionId?: string;
-    body: NativeExtensionRequestBody;
-};
+import { NativeExtensionMethod } from "../../utils/BrowserConstants";
+import { StringDict } from "@azure/msal-common";
+/**
+ * Token request which native broker will use to acquire tokens
+ */
+export type NativeTokenRequest = {
+    accountId: string;
+    clientId: string;
+    authority: string;
+    redirectUri: string;
+    scope: string;
+    correlationId: string;
+    windowTitleSubstring: string;
+    prompt?: string;
+    nonce?: string;
+    claims?: string;
+    state?: string;
+    reqCnf?: string;
+    keyId?: string;
+    tokenType?: string;
+    shrClaims?: string;
+    shrNonce?: string;
+    resourceRequestMethod?: string;
+    resourceRequestUri?: string;
+    extendedExpiryToken?: boolean;
+    extraParameters?: StringDict;
+};
+/**
+ * Request which will be forwarded to native broker by the browser extension
+ */
+export type NativeExtensionRequestBody = {
+    method: NativeExtensionMethod;
+    request?: NativeTokenRequest;
+};
+/**
+ * Browser extension request
+ */
+export type NativeExtensionRequest = {
+    channel: string;
+    responseId: string;
+    extensionId?: string;
+    body: NativeExtensionRequestBody;
+};
 //# sourceMappingURL=NativeRequest.d.ts.map

package/dist/broker/nativeBroker/NativeResponse.d.ts

@@ -1,49 +1,49 @@
-/**
- * Account properties returned by Native Platform e.g. WAM
- */
-export type NativeAccountInfo = {
-    id: string;
-    properties: object;
-    userName: string;
-};
-/**
- * Token response returned by Native Platform e.g. WAM
- */
-export type NativeResponse = {
-    access_token: string;
-    account: NativeAccountInfo;
-    client_info: string;
-    expires_in: number;
-    id_token: string;
-    properties: NativeResponseProperties;
-    scope: string;
-    state: string;
-    shr?: string;
-    extendedLifetimeToken?: boolean;
-};
-/**
- * Properties returned under "properties" of the NativeResponse
- */
-export type NativeResponseProperties = {
-    MATS?: string;
-};
-/**
- * The native token broker can optionally include additional information about operations it performs. If that data is returned, MSAL.js will include the following properties in the telemetry it collects.
- */
-export type MATS = {
-    is_cached?: number;
-    broker_version?: string;
-    account_join_on_start?: string;
-    account_join_on_end?: string;
-    device_join?: string;
-    prompt_behavior?: string;
-    api_error_code?: number;
-    ui_visible?: boolean;
-    silent_code?: number;
-    silent_bi_sub_code?: number;
-    silent_message?: string;
-    silent_status?: number;
-    http_status?: number;
-    http_event_count?: number;
-};
+/**
+ * Account properties returned by Native Platform e.g. WAM
+ */
+export type NativeAccountInfo = {
+    id: string;
+    properties: object;
+    userName: string;
+};
+/**
+ * Token response returned by Native Platform e.g. WAM
+ */
+export type NativeResponse = {
+    access_token: string;
+    account: NativeAccountInfo;
+    client_info: string;
+    expires_in: number;
+    id_token: string;
+    properties: NativeResponseProperties;
+    scope: string;
+    state: string;
+    shr?: string;
+    extendedLifetimeToken?: boolean;
+};
+/**
+ * Properties returned under "properties" of the NativeResponse
+ */
+export type NativeResponseProperties = {
+    MATS?: string;
+};
+/**
+ * The native token broker can optionally include additional information about operations it performs. If that data is returned, MSAL.js will include the following properties in the telemetry it collects.
+ */
+export type MATS = {
+    is_cached?: number;
+    broker_version?: string;
+    account_join_on_start?: string;
+    account_join_on_end?: string;
+    device_join?: string;
+    prompt_behavior?: string;
+    api_error_code?: number;
+    ui_visible?: boolean;
+    silent_code?: number;
+    silent_bi_sub_code?: number;
+    silent_message?: string;
+    silent_status?: number;
+    http_status?: number;
+    http_event_count?: number;
+};
 //# sourceMappingURL=NativeResponse.d.ts.map

package/dist/cache/AsyncMemoryStorage.d.ts

@@ -1,52 +1,52 @@
-import { Logger } from "@azure/msal-common";
-import { IAsyncStorage } from "./IAsyncMemoryStorage";
-/**
- * This class allows MSAL to store artifacts asynchronously using the DatabaseStorage IndexedDB wrapper,
- * backed up with the more volatile MemoryStorage object for cases in which IndexedDB may be unavailable.
- */
-export declare class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
-    private inMemoryCache;
-    private indexedDBCache;
-    private logger;
-    private storeName;
-    constructor(logger: Logger, storeName: string);
-    private handleDatabaseAccessError;
-    /**
-     * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
-     * storage object if item isn't found in-memory.
-     * @param key
-     */
-    getItem(key: string): Promise<T | null>;
-    /**
-     * Sets the item in the in-memory cache and then tries to set it in the asynchronous
-     * storage object with the given key.
-     * @param key
-     * @param value
-     */
-    setItem(key: string, value: T): Promise<void>;
-    /**
-     * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
-     * @param key
-     */
-    removeItem(key: string): Promise<void>;
-    /**
-     * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
-     * asynchronous storage object.
-     */
-    getKeys(): Promise<string[]>;
-    /**
-     * Returns true or false if the given key is present in the cache.
-     * @param key
-     */
-    containsKey(key: string): Promise<boolean>;
-    /**
-     * Clears in-memory Map
-     */
-    clearInMemory(): void;
-    /**
-     * Tries to delete the IndexedDB database
-     * @returns
-     */
-    clearPersistent(): Promise<boolean>;
-}
+import { Logger } from "@azure/msal-common";
+import { IAsyncStorage } from "./IAsyncMemoryStorage";
+/**
+ * This class allows MSAL to store artifacts asynchronously using the DatabaseStorage IndexedDB wrapper,
+ * backed up with the more volatile MemoryStorage object for cases in which IndexedDB may be unavailable.
+ */
+export declare class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
+    private inMemoryCache;
+    private indexedDBCache;
+    private logger;
+    private storeName;
+    constructor(logger: Logger, storeName: string);
+    private handleDatabaseAccessError;
+    /**
+     * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
+     * storage object if item isn't found in-memory.
+     * @param key
+     */
+    getItem(key: string): Promise<T | null>;
+    /**
+     * Sets the item in the in-memory cache and then tries to set it in the asynchronous
+     * storage object with the given key.
+     * @param key
+     * @param value
+     */
+    setItem(key: string, value: T): Promise<void>;
+    /**
+     * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
+     * @param key
+     */
+    removeItem(key: string): Promise<void>;
+    /**
+     * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
+     * asynchronous storage object.
+     */
+    getKeys(): Promise<string[]>;
+    /**
+     * Returns true or false if the given key is present in the cache.
+     * @param key
+     */
+    containsKey(key: string): Promise<boolean>;
+    /**
+     * Clears in-memory Map
+     */
+    clearInMemory(): void;
+    /**
+     * Tries to delete the IndexedDB database
+     * @returns
+     */
+    clearPersistent(): Promise<boolean>;
+}
 //# sourceMappingURL=AsyncMemoryStorage.d.ts.map

package/dist/cache/AsyncMemoryStorage.js

@@ -1,140 +1,140 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { BrowserAuthError, BrowserAuthErrorMessage } from '../error/BrowserAuthError.js';
 import { DatabaseStorage } from './DatabaseStorage.js';
 import { MemoryStorage } from './MemoryStorage.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * This class allows MSAL to store artifacts asynchronously using the DatabaseStorage IndexedDB wrapper,
- * backed up with the more volatile MemoryStorage object for cases in which IndexedDB may be unavailable.
- */
-class AsyncMemoryStorage {
-    constructor(logger, storeName) {
-        this.inMemoryCache = new MemoryStorage();
-        this.indexedDBCache = new DatabaseStorage();
-        this.logger = logger;
-        this.storeName = storeName;
-    }
-    handleDatabaseAccessError(error) {
-        if (error instanceof BrowserAuthError &&
-            error.errorCode === BrowserAuthErrorMessage.databaseUnavailable.code) {
-            this.logger.error("Could not access persistent storage. This may be caused by browser privacy features which block persistent storage in third-party contexts.");
-        }
-        else {
-            throw error;
-        }
-    }
-    /**
-     * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
-     * storage object if item isn't found in-memory.
-     * @param key
-     */
-    async getItem(key) {
-        const item = this.inMemoryCache.getItem(key);
-        if (!item) {
-            try {
-                this.logger.verbose("Queried item not found in in-memory cache, now querying persistent storage.");
-                return await this.indexedDBCache.getItem(key);
-            }
-            catch (e) {
-                this.handleDatabaseAccessError(e);
-            }
-        }
-        return item;
-    }
-    /**
-     * Sets the item in the in-memory cache and then tries to set it in the asynchronous
-     * storage object with the given key.
-     * @param key
-     * @param value
-     */
-    async setItem(key, value) {
-        this.inMemoryCache.setItem(key, value);
-        try {
-            await this.indexedDBCache.setItem(key, value);
-        }
-        catch (e) {
-            this.handleDatabaseAccessError(e);
-        }
-    }
-    /**
-     * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
-     * @param key
-     */
-    async removeItem(key) {
-        this.inMemoryCache.removeItem(key);
-        try {
-            await this.indexedDBCache.removeItem(key);
-        }
-        catch (e) {
-            this.handleDatabaseAccessError(e);
-        }
-    }
-    /**
-     * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
-     * asynchronous storage object.
-     */
-    async getKeys() {
-        const cacheKeys = this.inMemoryCache.getKeys();
-        if (cacheKeys.length === 0) {
-            try {
-                this.logger.verbose("In-memory cache is empty, now querying persistent storage.");
-                return await this.indexedDBCache.getKeys();
-            }
-            catch (e) {
-                this.handleDatabaseAccessError(e);
-            }
-        }
-        return cacheKeys;
-    }
-    /**
-     * Returns true or false if the given key is present in the cache.
-     * @param key
-     */
-    async containsKey(key) {
-        const containsKey = this.inMemoryCache.containsKey(key);
-        if (!containsKey) {
-            try {
-                this.logger.verbose("Key not found in in-memory cache, now querying persistent storage.");
-                return await this.indexedDBCache.containsKey(key);
-            }
-            catch (e) {
-                this.handleDatabaseAccessError(e);
-            }
-        }
-        return containsKey;
-    }
-    /**
-     * Clears in-memory Map
-     */
-    clearInMemory() {
-        // InMemory cache is a Map instance, clear is straightforward
-        this.logger.verbose(`Deleting in-memory keystore ${this.storeName}`);
-        this.inMemoryCache.clear();
-        this.logger.verbose(`In-memory keystore ${this.storeName} deleted`);
-    }
-    /**
-     * Tries to delete the IndexedDB database
-     * @returns
-     */
-    async clearPersistent() {
-        try {
-            this.logger.verbose("Deleting persistent keystore");
-            const dbDeleted = await this.indexedDBCache.deleteDatabase();
-            if (dbDeleted) {
-                this.logger.verbose("Persistent keystore deleted");
-            }
-            return dbDeleted;
-        }
-        catch (e) {
-            this.handleDatabaseAccessError(e);
-            return false;
-        }
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This class allows MSAL to store artifacts asynchronously using the DatabaseStorage IndexedDB wrapper,
+ * backed up with the more volatile MemoryStorage object for cases in which IndexedDB may be unavailable.
+ */
+class AsyncMemoryStorage {
+    constructor(logger, storeName) {
+        this.inMemoryCache = new MemoryStorage();
+        this.indexedDBCache = new DatabaseStorage();
+        this.logger = logger;
+        this.storeName = storeName;
+    }
+    handleDatabaseAccessError(error) {
+        if (error instanceof BrowserAuthError &&
+            error.errorCode === BrowserAuthErrorMessage.databaseUnavailable.code) {
+            this.logger.error("Could not access persistent storage. This may be caused by browser privacy features which block persistent storage in third-party contexts.");
+        }
+        else {
+            throw error;
+        }
+    }
+    /**
+     * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
+     * storage object if item isn't found in-memory.
+     * @param key
+     */
+    async getItem(key) {
+        const item = this.inMemoryCache.getItem(key);
+        if (!item) {
+            try {
+                this.logger.verbose("Queried item not found in in-memory cache, now querying persistent storage.");
+                return await this.indexedDBCache.getItem(key);
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e);
+            }
+        }
+        return item;
+    }
+    /**
+     * Sets the item in the in-memory cache and then tries to set it in the asynchronous
+     * storage object with the given key.
+     * @param key
+     * @param value
+     */
+    async setItem(key, value) {
+        this.inMemoryCache.setItem(key, value);
+        try {
+            await this.indexedDBCache.setItem(key, value);
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e);
+        }
+    }
+    /**
+     * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
+     * @param key
+     */
+    async removeItem(key) {
+        this.inMemoryCache.removeItem(key);
+        try {
+            await this.indexedDBCache.removeItem(key);
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e);
+        }
+    }
+    /**
+     * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
+     * asynchronous storage object.
+     */
+    async getKeys() {
+        const cacheKeys = this.inMemoryCache.getKeys();
+        if (cacheKeys.length === 0) {
+            try {
+                this.logger.verbose("In-memory cache is empty, now querying persistent storage.");
+                return await this.indexedDBCache.getKeys();
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e);
+            }
+        }
+        return cacheKeys;
+    }
+    /**
+     * Returns true or false if the given key is present in the cache.
+     * @param key
+     */
+    async containsKey(key) {
+        const containsKey = this.inMemoryCache.containsKey(key);
+        if (!containsKey) {
+            try {
+                this.logger.verbose("Key not found in in-memory cache, now querying persistent storage.");
+                return await this.indexedDBCache.containsKey(key);
+            }
+            catch (e) {
+                this.handleDatabaseAccessError(e);
+            }
+        }
+        return containsKey;
+    }
+    /**
+     * Clears in-memory Map
+     */
+    clearInMemory() {
+        // InMemory cache is a Map instance, clear is straightforward
+        this.logger.verbose(`Deleting in-memory keystore ${this.storeName}`);
+        this.inMemoryCache.clear();
+        this.logger.verbose(`In-memory keystore ${this.storeName} deleted`);
+    }
+    /**
+     * Tries to delete the IndexedDB database
+     * @returns
+     */
+    async clearPersistent() {
+        try {
+            this.logger.verbose("Deleting persistent keystore");
+            const dbDeleted = await this.indexedDBCache.deleteDatabase();
+            if (dbDeleted) {
+                this.logger.verbose("Persistent keystore deleted");
+            }
+            return dbDeleted;
+        }
+        catch (e) {
+            this.handleDatabaseAccessError(e);
+            return false;
+        }
+    }
 }
 
 export { AsyncMemoryStorage };