matrix-react-sdk
Version:
SDK for matrix.org using React
397 lines (365 loc) • 48 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.UpdateCheckStatus = exports.SSO_ID_SERVER_URL_KEY = exports.SSO_IDP_ID_KEY = exports.SSO_HOMESERVER_URL_KEY = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _matrix = require("matrix-js-sdk/src/matrix");
var _logger = require("matrix-js-sdk/src/logger");
var _dispatcher = _interopRequireDefault(require("./dispatcher/dispatcher"));
var _actions = require("./dispatcher/actions");
var _UpdateToast = require("./toasts/UpdateToast");
var _MatrixClientPeg = require("./MatrixClientPeg");
var _StorageAccess = require("./utils/StorageAccess");
var _SdkConfig = _interopRequireDefault(require("./SdkConfig"));
var _pickling = require("./utils/tokens/pickling");
/*
Copyright 2024 New Vector Ltd.
Copyright 2020 The Matrix.org Foundation C.I.C.
Copyright 2018 New Vector Ltd
Copyright 2016 Aviral Dasgupta
Copyright 2016 OpenMarket Ltd
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
const SSO_HOMESERVER_URL_KEY = exports.SSO_HOMESERVER_URL_KEY = "mx_sso_hs_url";
const SSO_ID_SERVER_URL_KEY = exports.SSO_ID_SERVER_URL_KEY = "mx_sso_is_url";
const SSO_IDP_ID_KEY = exports.SSO_IDP_ID_KEY = "mx_sso_idp_id";
let UpdateCheckStatus = exports.UpdateCheckStatus = /*#__PURE__*/function (UpdateCheckStatus) {
UpdateCheckStatus["Checking"] = "CHECKING";
UpdateCheckStatus["Error"] = "ERROR";
UpdateCheckStatus["NotAvailable"] = "NOTAVAILABLE";
UpdateCheckStatus["Downloading"] = "DOWNLOADING";
UpdateCheckStatus["Ready"] = "READY";
return UpdateCheckStatus;
}({});
const UPDATE_DEFER_KEY = "mx_defer_update";
/**
* Base class for classes that provide platform-specific functionality
* eg. Setting an application badge or displaying notifications
*
* Instances of this class are provided by the application.
*/
class BasePlatform {
constructor() {
(0, _defineProperty2.default)(this, "notificationCount", 0);
(0, _defineProperty2.default)(this, "errorDidOccur", false);
(0, _defineProperty2.default)(this, "onAction", payload => {
switch (payload.action) {
case "on_client_not_viable":
case _actions.Action.OnLoggedOut:
this.setNotificationCount(0);
break;
}
});
_dispatcher.default.register(this.onAction);
this.startUpdateCheck = this.startUpdateCheck.bind(this);
}
// Used primarily for Analytics
setNotificationCount(count) {
this.notificationCount = count;
}
setErrorStatus(errorDidOccur) {
this.errorDidOccur = errorDidOccur;
}
/**
* Whether we can call checkForUpdate on this platform build
*/
async canSelfUpdate() {
return false;
}
startUpdateCheck() {
(0, _UpdateToast.hideToast)();
localStorage.removeItem(UPDATE_DEFER_KEY);
_dispatcher.default.dispatch({
action: _actions.Action.CheckUpdates,
status: UpdateCheckStatus.Checking
});
}
/**
* Update the currently running app to the latest available version
* and replace this instance of the app with the new version.
*/
installUpdate() {}
/**
* Check if the version update has been deferred and that deferment is still in effect
* @param newVersion the version string to check
*/
shouldShowUpdate(newVersion) {
// If the user registered on this client in the last 24 hours then do not show them the update toast
if (_MatrixClientPeg.MatrixClientPeg.userRegisteredWithinLastHours(24)) return false;
try {
const [version, deferUntil] = JSON.parse(localStorage.getItem(UPDATE_DEFER_KEY));
return newVersion !== version || Date.now() > deferUntil;
} catch (e) {
return true;
}
}
/**
* Ignore the pending update and don't prompt about this version
* until the next morning (8am).
*/
deferUpdate(newVersion) {
const date = new Date(Date.now() + 24 * 60 * 60 * 1000);
date.setHours(8, 0, 0, 0); // set to next 8am
localStorage.setItem(UPDATE_DEFER_KEY, JSON.stringify([newVersion, date.getTime()]));
(0, _UpdateToast.hideToast)();
}
/**
* Return true if platform supports multi-language
* spell-checking, otherwise false.
*/
supportsSpellCheckSettings() {
return false;
}
/**
* Returns true if platform allows overriding native context menus
*/
allowOverridingNativeContextMenus() {
return false;
}
/**
* Returns true if the platform supports displaying
* notifications, otherwise false.
* @returns {boolean} whether the platform supports displaying notifications
*/
supportsNotifications() {
return false;
}
/**
* Returns true if the application currently has permission
* to display notifications. Otherwise false.
* @returns {boolean} whether the application has permission to display notifications
*/
maySendNotifications() {
return false;
}
/**
* Requests permission to send notifications. Returns
* a promise that is resolved when the user has responded
* to the request. The promise has a single string argument
* that is 'granted' if the user allowed the request or
* 'denied' otherwise.
*/
displayNotification(title, msg, avatarUrl, room, ev) {
const notifBody = {
body: msg,
silent: true // we play our own sounds
};
if (avatarUrl) notifBody["icon"] = avatarUrl;
const notification = new window.Notification(title, notifBody);
notification.onclick = () => {
const payload = {
action: _actions.Action.ViewRoom,
room_id: room.roomId,
metricsTrigger: "Notification"
};
if (ev?.getThread()) {
payload.event_id = ev.getId();
}
_dispatcher.default.dispatch(payload);
window.focus();
};
return notification;
}
loudNotification(ev, room) {}
clearNotification(notif) {
// Some browsers don't support this, e.g Safari on iOS
// https://developer.mozilla.org/en-US/docs/Web/API/Notification/close
if (notif.close) {
notif.close();
}
}
/**
* Returns true if the platform requires URL previews in tooltips, otherwise false.
* @returns {boolean} whether the platform requires URL previews in tooltips
*/
needsUrlTooltips() {
return false;
}
/**
* Returns a promise that resolves to a string representing the current version of the application.
*/
/**
* Restarts the application, without necessarily reloading
* any application code
*/
supportsSetting(settingName) {
return false;
}
async getSettingValue(settingName) {
return undefined;
}
setSettingValue(settingName, value) {
throw new Error("Unimplemented");
}
/**
* Get our platform specific EventIndexManager.
*
* @return {BaseEventIndexManager} The EventIndex manager for our platform,
* can be null if the platform doesn't support event indexing.
*/
getEventIndexingManager() {
return null;
}
setLanguage(preferredLangs) {}
setSpellCheckEnabled(enabled) {}
async getSpellCheckEnabled() {
return false;
}
setSpellCheckLanguages(preferredLangs) {}
getSpellCheckLanguages() {
return null;
}
async getDesktopCapturerSources(options) {
return [];
}
supportsDesktopCapturer() {
return false;
}
supportsJitsiScreensharing() {
return true;
}
overrideBrowserShortcuts() {
return false;
}
navigateForwardBack(back) {}
getAvailableSpellCheckLanguages() {
return null;
}
/**
* The URL to return to after a successful SSO authentication
* @param fragmentAfterLogin optional fragment for specific view to return to
*/
getSSOCallbackUrl(fragmentAfterLogin = "") {
const url = new URL(window.location.href);
url.hash = fragmentAfterLogin;
return url;
}
/**
* Begin Single Sign On flows.
* @param {MatrixClient} mxClient the matrix client using which we should start the flow
* @param {"sso"|"cas"} loginType the type of SSO it is, CAS/SSO.
* @param {string} fragmentAfterLogin the hash to pass to the app during sso callback.
* @param {SSOAction} action the SSO flow to indicate to the IdP, optional.
* @param {string} idpId The ID of the Identity Provider being targeted, optional.
*/
startSingleSignOn(mxClient, loginType, fragmentAfterLogin, idpId, action) {
// persist hs url and is url for when the user is returned to the app with the login token
localStorage.setItem(SSO_HOMESERVER_URL_KEY, mxClient.getHomeserverUrl());
if (mxClient.getIdentityServerUrl()) {
localStorage.setItem(SSO_ID_SERVER_URL_KEY, mxClient.getIdentityServerUrl());
}
if (idpId) {
localStorage.setItem(SSO_IDP_ID_KEY, idpId);
}
const callbackUrl = this.getSSOCallbackUrl(fragmentAfterLogin);
window.location.href = mxClient.getSsoLoginUrl(callbackUrl.toString(), loginType, idpId, action); // redirect to SSO
}
/**
* Get a previously stored pickle key. The pickle key is used for
* encrypting libolm objects and react-sdk-crypto data.
* @param {string} userId the user ID for the user that the pickle key is for.
* @param {string} deviceId the device ID that the pickle key is for.
* @returns {string|null} the previously stored pickle key, or null if no
* pickle key has been stored.
*/
async getPickleKey(userId, deviceId) {
let data;
try {
data = await (0, _StorageAccess.idbLoad)("pickleKey", [userId, deviceId]);
} catch (e) {
_logger.logger.error("idbLoad for pickleKey failed", e);
}
return (await (0, _pickling.buildAndEncodePickleKey)(data, userId, deviceId)) ?? null;
}
/**
* Create and store a pickle key for encrypting libolm objects.
* @param {string} userId the user ID for the user that the pickle key is for.
* @param {string} deviceId the device ID that the pickle key is for.
* @returns {string|null} the pickle key, or null if the platform does not
* support storing pickle keys.
*/
async createPickleKey(userId, deviceId) {
const randomArray = new Uint8Array(32);
crypto.getRandomValues(randomArray);
const data = await (0, _pickling.encryptPickleKey)(randomArray, userId, deviceId);
if (data === undefined) {
// no crypto support
return null;
}
try {
await (0, _StorageAccess.idbSave)("pickleKey", [userId, deviceId], data);
} catch (e) {
return null;
}
return (0, _matrix.encodeUnpaddedBase64)(randomArray);
}
/**
* Delete a previously stored pickle key from storage.
* @param {string} userId the user ID for the user that the pickle key is for.
* @param {string} deviceId the device ID that the pickle key is for.
*/
async destroyPickleKey(userId, deviceId) {
try {
await (0, _StorageAccess.idbDelete)("pickleKey", [userId, deviceId]);
} catch (e) {
_logger.logger.error("idbDelete failed in destroyPickleKey", e);
}
}
/**
* Clear app storage, called when logging out to perform data clean up.
*/
async clearStorage() {
window.sessionStorage.clear();
window.localStorage.clear();
}
/**
* Base URL to use when generating external links for this client, for platforms e.g. Desktop this will be a different instance
*/
get baseUrl() {
return window.location.origin + window.location.pathname;
}
/**
* Fallback Client URI to use for OIDC client registration for if one is not specified in config.json
*/
get defaultOidcClientUri() {
return window.location.origin;
}
/**
* Metadata to use for dynamic OIDC client registrations
*/
async getOidcClientMetadata() {
const config = _SdkConfig.default.get();
return {
clientName: config.brand,
clientUri: config.oidc_metadata?.client_uri ?? this.defaultOidcClientUri,
redirectUris: [this.getOidcCallbackUrl().href],
logoUri: config.oidc_metadata?.logo_uri ?? new URL("vector-icons/1024.png", this.baseUrl).href,
applicationType: "web",
contacts: config.oidc_metadata?.contacts,
tosUri: config.oidc_metadata?.tos_uri ?? config.terms_and_conditions_links?.[0]?.url,
policyUri: config.oidc_metadata?.policy_uri ?? config.privacy_policy_url
};
}
/**
* Suffix to append to the `state` parameter of OIDC /auth calls. Will be round-tripped to the callback URI.
* Currently only required for ElectronPlatform for passing element-desktop-ssoid.
*/
getOidcClientState() {
return "";
}
/**
* The URL to return to after a successful OIDC authentication
*/
getOidcCallbackUrl() {
const url = new URL(window.location.href);
// The redirect URL has to exactly match that registered at the OIDC server, so
// ensure that the fragment part of the URL is empty.
url.hash = "";
return url;
}
}
exports.default = BasePlatform;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_matrix","require","_logger","_dispatcher","_interopRequireDefault","_actions","_UpdateToast","_MatrixClientPeg","_StorageAccess","_SdkConfig","_pickling","SSO_HOMESERVER_URL_KEY","exports","SSO_ID_SERVER_URL_KEY","SSO_IDP_ID_KEY","UpdateCheckStatus","UPDATE_DEFER_KEY","BasePlatform","constructor","_defineProperty2","default","payload","action","Action","OnLoggedOut","setNotificationCount","dis","register","onAction","startUpdateCheck","bind","count","notificationCount","setErrorStatus","errorDidOccur","canSelfUpdate","hideUpdateToast","localStorage","removeItem","dispatch","CheckUpdates","status","Checking","installUpdate","shouldShowUpdate","newVersion","MatrixClientPeg","userRegisteredWithinLastHours","version","deferUntil","JSON","parse","getItem","Date","now","e","deferUpdate","date","setHours","setItem","stringify","getTime","supportsSpellCheckSettings","allowOverridingNativeContextMenus","supportsNotifications","maySendNotifications","displayNotification","title","msg","avatarUrl","room","ev","notifBody","body","silent","notification","window","Notification","onclick","ViewRoom","room_id","roomId","metricsTrigger","getThread","event_id","getId","focus","loudNotification","clearNotification","notif","close","needsUrlTooltips","supportsSetting","settingName","getSettingValue","undefined","setSettingValue","value","Error","getEventIndexingManager","setLanguage","preferredLangs","setSpellCheckEnabled","enabled","getSpellCheckEnabled","setSpellCheckLanguages","getSpellCheckLanguages","getDesktopCapturerSources","options","supportsDesktopCapturer","supportsJitsiScreensharing","overrideBrowserShortcuts","navigateForwardBack","back","getAvailableSpellCheckLanguages","getSSOCallbackUrl","fragmentAfterLogin","url","URL","location","href","hash","startSingleSignOn","mxClient","loginType","idpId","getHomeserverUrl","getIdentityServerUrl","callbackUrl","getSsoLoginUrl","toString","getPickleKey","userId","deviceId","data","idbLoad","logger","error","buildAndEncodePickleKey","createPickleKey","randomArray","Uint8Array","crypto","getRandomValues","encryptPickleKey","idbSave","encodeUnpaddedBase64","destroyPickleKey","idbDelete","clearStorage","sessionStorage","clear","baseUrl","origin","pathname","defaultOidcClientUri","getOidcClientMetadata","config","SdkConfig","get","clientName","brand","clientUri","oidc_metadata","client_uri","redirectUris","getOidcCallbackUrl","logoUri","logo_uri","applicationType","contacts","tosUri","tos_uri","terms_and_conditions_links","policyUri","policy_uri","privacy_policy_url","getOidcClientState"],"sources":["../src/BasePlatform.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2020 The Matrix.org Foundation C.I.C.\nCopyright 2018 New Vector Ltd\nCopyright 2016 Aviral Dasgupta\nCopyright 2016 OpenMarket Ltd\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport {\n    MatrixClient,\n    MatrixEvent,\n    Room,\n    SSOAction,\n    encodeUnpaddedBase64,\n    OidcRegistrationClientMetadata,\n} from \"matrix-js-sdk/src/matrix\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\n\nimport dis from \"./dispatcher/dispatcher\";\nimport BaseEventIndexManager from \"./indexing/BaseEventIndexManager\";\nimport { ActionPayload } from \"./dispatcher/payloads\";\nimport { CheckUpdatesPayload } from \"./dispatcher/payloads/CheckUpdatesPayload\";\nimport { Action } from \"./dispatcher/actions\";\nimport { hideToast as hideUpdateToast } from \"./toasts/UpdateToast\";\nimport { MatrixClientPeg } from \"./MatrixClientPeg\";\nimport { idbLoad, idbSave, idbDelete } from \"./utils/StorageAccess\";\nimport { ViewRoomPayload } from \"./dispatcher/payloads/ViewRoomPayload\";\nimport { IConfigOptions } from \"./IConfigOptions\";\nimport SdkConfig from \"./SdkConfig\";\nimport { buildAndEncodePickleKey, encryptPickleKey } from \"./utils/tokens/pickling\";\n\nexport const SSO_HOMESERVER_URL_KEY = \"mx_sso_hs_url\";\nexport const SSO_ID_SERVER_URL_KEY = \"mx_sso_is_url\";\nexport const SSO_IDP_ID_KEY = \"mx_sso_idp_id\";\n\nexport enum UpdateCheckStatus {\n    Checking = \"CHECKING\",\n    Error = \"ERROR\",\n    NotAvailable = \"NOTAVAILABLE\",\n    Downloading = \"DOWNLOADING\",\n    Ready = \"READY\",\n}\n\nexport interface UpdateStatus {\n    /**\n     * The current phase of the manual update check.\n     */\n    status: UpdateCheckStatus;\n    /**\n     * Detail string relating to the current status, typically for error details.\n     */\n    detail?: string;\n}\n\nconst UPDATE_DEFER_KEY = \"mx_defer_update\";\n\n/**\n * Base class for classes that provide platform-specific functionality\n * eg. Setting an application badge or displaying notifications\n *\n * Instances of this class are provided by the application.\n */\nexport default abstract class BasePlatform {\n    protected notificationCount = 0;\n    protected errorDidOccur = false;\n\n    protected constructor() {\n        dis.register(this.onAction);\n        this.startUpdateCheck = this.startUpdateCheck.bind(this);\n    }\n\n    public abstract getConfig(): Promise<IConfigOptions | undefined>;\n\n    public abstract getDefaultDeviceDisplayName(): string;\n\n    protected onAction = (payload: ActionPayload): void => {\n        switch (payload.action) {\n            case \"on_client_not_viable\":\n            case Action.OnLoggedOut:\n                this.setNotificationCount(0);\n                break;\n        }\n    };\n\n    // Used primarily for Analytics\n    public abstract getHumanReadableName(): string;\n\n    public setNotificationCount(count: number): void {\n        this.notificationCount = count;\n    }\n\n    public setErrorStatus(errorDidOccur: boolean): void {\n        this.errorDidOccur = errorDidOccur;\n    }\n\n    /**\n     * Whether we can call checkForUpdate on this platform build\n     */\n    public async canSelfUpdate(): Promise<boolean> {\n        return false;\n    }\n\n    public startUpdateCheck(): void {\n        hideUpdateToast();\n        localStorage.removeItem(UPDATE_DEFER_KEY);\n        dis.dispatch<CheckUpdatesPayload>({\n            action: Action.CheckUpdates,\n            status: UpdateCheckStatus.Checking,\n        });\n    }\n\n    /**\n     * Update the currently running app to the latest available version\n     * and replace this instance of the app with the new version.\n     */\n    public installUpdate(): void {}\n\n    /**\n     * Check if the version update has been deferred and that deferment is still in effect\n     * @param newVersion the version string to check\n     */\n    protected shouldShowUpdate(newVersion: string): boolean {\n        // If the user registered on this client in the last 24 hours then do not show them the update toast\n        if (MatrixClientPeg.userRegisteredWithinLastHours(24)) return false;\n\n        try {\n            const [version, deferUntil] = JSON.parse(localStorage.getItem(UPDATE_DEFER_KEY)!);\n            return newVersion !== version || Date.now() > deferUntil;\n        } catch (e) {\n            return true;\n        }\n    }\n\n    /**\n     * Ignore the pending update and don't prompt about this version\n     * until the next morning (8am).\n     */\n    public deferUpdate(newVersion: string): void {\n        const date = new Date(Date.now() + 24 * 60 * 60 * 1000);\n        date.setHours(8, 0, 0, 0); // set to next 8am\n        localStorage.setItem(UPDATE_DEFER_KEY, JSON.stringify([newVersion, date.getTime()]));\n        hideUpdateToast();\n    }\n\n    /**\n     * Return true if platform supports multi-language\n     * spell-checking, otherwise false.\n     */\n    public supportsSpellCheckSettings(): boolean {\n        return false;\n    }\n\n    /**\n     * Returns true if platform allows overriding native context menus\n     */\n    public allowOverridingNativeContextMenus(): boolean {\n        return false;\n    }\n\n    /**\n     * Returns true if the platform supports displaying\n     * notifications, otherwise false.\n     * @returns {boolean} whether the platform supports displaying notifications\n     */\n    public supportsNotifications(): boolean {\n        return false;\n    }\n\n    /**\n     * Returns true if the application currently has permission\n     * to display notifications. Otherwise false.\n     * @returns {boolean} whether the application has permission to display notifications\n     */\n    public maySendNotifications(): boolean {\n        return false;\n    }\n\n    /**\n     * Requests permission to send notifications. Returns\n     * a promise that is resolved when the user has responded\n     * to the request. The promise has a single string argument\n     * that is 'granted' if the user allowed the request or\n     * 'denied' otherwise.\n     */\n    public abstract requestNotificationPermission(): Promise<string>;\n\n    public displayNotification(\n        title: string,\n        msg: string,\n        avatarUrl: string | null,\n        room: Room,\n        ev?: MatrixEvent,\n    ): Notification {\n        const notifBody: NotificationOptions = {\n            body: msg,\n            silent: true, // we play our own sounds\n        };\n        if (avatarUrl) notifBody[\"icon\"] = avatarUrl;\n        const notification = new window.Notification(title, notifBody);\n\n        notification.onclick = () => {\n            const payload: ViewRoomPayload = {\n                action: Action.ViewRoom,\n                room_id: room.roomId,\n                metricsTrigger: \"Notification\",\n            };\n\n            if (ev?.getThread()) {\n                payload.event_id = ev.getId();\n            }\n\n            dis.dispatch(payload);\n            window.focus();\n        };\n\n        return notification;\n    }\n\n    public loudNotification(ev: MatrixEvent, room: Room): void {}\n\n    public clearNotification(notif: Notification): void {\n        // Some browsers don't support this, e.g Safari on iOS\n        // https://developer.mozilla.org/en-US/docs/Web/API/Notification/close\n        if (notif.close) {\n            notif.close();\n        }\n    }\n\n    /**\n     * Returns true if the platform requires URL previews in tooltips, otherwise false.\n     * @returns {boolean} whether the platform requires URL previews in tooltips\n     */\n    public needsUrlTooltips(): boolean {\n        return false;\n    }\n\n    /**\n     * Returns a promise that resolves to a string representing the current version of the application.\n     */\n    public abstract getAppVersion(): Promise<string>;\n\n    /**\n     * Restarts the application, without necessarily reloading\n     * any application code\n     */\n    public abstract reload(): void;\n\n    public supportsSetting(settingName?: string): boolean {\n        return false;\n    }\n\n    public async getSettingValue(settingName: string): Promise<any> {\n        return undefined;\n    }\n\n    public setSettingValue(settingName: string, value: any): Promise<void> {\n        throw new Error(\"Unimplemented\");\n    }\n\n    /**\n     * Get our platform specific EventIndexManager.\n     *\n     * @return {BaseEventIndexManager} The EventIndex manager for our platform,\n     * can be null if the platform doesn't support event indexing.\n     */\n    public getEventIndexingManager(): BaseEventIndexManager | null {\n        return null;\n    }\n\n    public setLanguage(preferredLangs: string[]): void {}\n\n    public setSpellCheckEnabled(enabled: boolean): void {}\n\n    public async getSpellCheckEnabled(): Promise<boolean> {\n        return false;\n    }\n\n    public setSpellCheckLanguages(preferredLangs: string[]): void {}\n\n    public getSpellCheckLanguages(): Promise<string[]> | null {\n        return null;\n    }\n\n    public async getDesktopCapturerSources(options: GetSourcesOptions): Promise<Array<DesktopCapturerSource>> {\n        return [];\n    }\n\n    public supportsDesktopCapturer(): boolean {\n        return false;\n    }\n\n    public supportsJitsiScreensharing(): boolean {\n        return true;\n    }\n\n    public overrideBrowserShortcuts(): boolean {\n        return false;\n    }\n\n    public navigateForwardBack(back: boolean): void {}\n\n    public getAvailableSpellCheckLanguages(): Promise<string[]> | null {\n        return null;\n    }\n\n    /**\n     * The URL to return to after a successful SSO authentication\n     * @param fragmentAfterLogin optional fragment for specific view to return to\n     */\n    public getSSOCallbackUrl(fragmentAfterLogin = \"\"): URL {\n        const url = new URL(window.location.href);\n        url.hash = fragmentAfterLogin;\n        return url;\n    }\n\n    /**\n     * Begin Single Sign On flows.\n     * @param {MatrixClient} mxClient the matrix client using which we should start the flow\n     * @param {\"sso\"|\"cas\"} loginType the type of SSO it is, CAS/SSO.\n     * @param {string} fragmentAfterLogin the hash to pass to the app during sso callback.\n     * @param {SSOAction} action the SSO flow to indicate to the IdP, optional.\n     * @param {string} idpId The ID of the Identity Provider being targeted, optional.\n     */\n    public startSingleSignOn(\n        mxClient: MatrixClient,\n        loginType: \"sso\" | \"cas\",\n        fragmentAfterLogin?: string,\n        idpId?: string,\n        action?: SSOAction,\n    ): void {\n        // persist hs url and is url for when the user is returned to the app with the login token\n        localStorage.setItem(SSO_HOMESERVER_URL_KEY, mxClient.getHomeserverUrl());\n        if (mxClient.getIdentityServerUrl()) {\n            localStorage.setItem(SSO_ID_SERVER_URL_KEY, mxClient.getIdentityServerUrl()!);\n        }\n        if (idpId) {\n            localStorage.setItem(SSO_IDP_ID_KEY, idpId);\n        }\n        const callbackUrl = this.getSSOCallbackUrl(fragmentAfterLogin);\n        window.location.href = mxClient.getSsoLoginUrl(callbackUrl.toString(), loginType, idpId, action); // redirect to SSO\n    }\n\n    /**\n     * Get a previously stored pickle key.  The pickle key is used for\n     * encrypting libolm objects and react-sdk-crypto data.\n     * @param {string} userId the user ID for the user that the pickle key is for.\n     * @param {string} deviceId the device ID that the pickle key is for.\n     * @returns {string|null} the previously stored pickle key, or null if no\n     *     pickle key has been stored.\n     */\n    public async getPickleKey(userId: string, deviceId: string): Promise<string | null> {\n        let data: { encrypted?: BufferSource; iv?: BufferSource; cryptoKey?: CryptoKey } | undefined;\n        try {\n            data = await idbLoad(\"pickleKey\", [userId, deviceId]);\n        } catch (e) {\n            logger.error(\"idbLoad for pickleKey failed\", e);\n        }\n\n        return (await buildAndEncodePickleKey(data, userId, deviceId)) ?? null;\n    }\n\n    /**\n     * Create and store a pickle key for encrypting libolm objects.\n     * @param {string} userId the user ID for the user that the pickle key is for.\n     * @param {string} deviceId the device ID that the pickle key is for.\n     * @returns {string|null} the pickle key, or null if the platform does not\n     *     support storing pickle keys.\n     */\n    public async createPickleKey(userId: string, deviceId: string): Promise<string | null> {\n        const randomArray = new Uint8Array(32);\n        crypto.getRandomValues(randomArray);\n        const data = await encryptPickleKey(randomArray, userId, deviceId);\n        if (data === undefined) {\n            // no crypto support\n            return null;\n        }\n\n        try {\n            await idbSave(\"pickleKey\", [userId, deviceId], data);\n        } catch (e) {\n            return null;\n        }\n        return encodeUnpaddedBase64(randomArray);\n    }\n\n    /**\n     * Delete a previously stored pickle key from storage.\n     * @param {string} userId the user ID for the user that the pickle key is for.\n     * @param {string} deviceId the device ID that the pickle key is for.\n     */\n    public async destroyPickleKey(userId: string, deviceId: string): Promise<void> {\n        try {\n            await idbDelete(\"pickleKey\", [userId, deviceId]);\n        } catch (e) {\n            logger.error(\"idbDelete failed in destroyPickleKey\", e);\n        }\n    }\n\n    /**\n     * Clear app storage, called when logging out to perform data clean up.\n     */\n    public async clearStorage(): Promise<void> {\n        window.sessionStorage.clear();\n        window.localStorage.clear();\n    }\n\n    /**\n     * Base URL to use when generating external links for this client, for platforms e.g. Desktop this will be a different instance\n     */\n    public get baseUrl(): string {\n        return window.location.origin + window.location.pathname;\n    }\n\n    /**\n     * Fallback Client URI to use for OIDC client registration for if one is not specified in config.json\n     */\n    public get defaultOidcClientUri(): string {\n        return window.location.origin;\n    }\n\n    /**\n     * Metadata to use for dynamic OIDC client registrations\n     */\n    public async getOidcClientMetadata(): Promise<OidcRegistrationClientMetadata> {\n        const config = SdkConfig.get();\n        return {\n            clientName: config.brand,\n            clientUri: config.oidc_metadata?.client_uri ?? this.defaultOidcClientUri,\n            redirectUris: [this.getOidcCallbackUrl().href],\n            logoUri: config.oidc_metadata?.logo_uri ?? new URL(\"vector-icons/1024.png\", this.baseUrl).href,\n            applicationType: \"web\",\n            contacts: config.oidc_metadata?.contacts,\n            tosUri: config.oidc_metadata?.tos_uri ?? config.terms_and_conditions_links?.[0]?.url,\n            policyUri: config.oidc_metadata?.policy_uri ?? config.privacy_policy_url,\n        };\n    }\n\n    /**\n     * Suffix to append to the `state` parameter of OIDC /auth calls. Will be round-tripped to the callback URI.\n     * Currently only required for ElectronPlatform for passing element-desktop-ssoid.\n     */\n    public getOidcClientState(): string {\n        return \"\";\n    }\n\n    /**\n     * The URL to return to after a successful OIDC authentication\n     */\n    public getOidcCallbackUrl(): URL {\n        const url = new URL(window.location.href);\n        // The redirect URL has to exactly match that registered at the OIDC server, so\n        // ensure that the fragment part of the URL is empty.\n        url.hash = \"\";\n        return url;\n    }\n}\n"],"mappings":"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","ignoreList":[]}