@schibsted/account-sdk-browser 6.0.0-alpha.4 → 6.0.0-alpha.6

package/src/identity.ts

@@ -2,10 +2,8 @@
  * See LICENSE.md in the project root.
  */
 
-import { TinyEmitter } from 'tiny-emitter';
 import Cache from './cache.js';
 import { ENDPOINTS } from './config.js';
-import { registerAndDispatchInGlobal } from './global-registry.js';
 import { cloneDeep } from './object.js';
 import * as popup from './popup.js';
 import type RESTClient from './rest-client.js';
@@ -20,6 +18,7 @@ import {
     normalizeSessionResponse,
 } from './session-response.js';
 import * as spidTalk from './spid-talk.js';
+import type { AccountEventName } from './types/account.js';
 import type { LogFunction } from './types/common.js';
 import type {
     IdentityBeforeRedirectCallback,
@@ -45,16 +44,6 @@ import { urlMapper } from './url.js';
 import { assert, isNonEmptyString, isObject, isStr, isStrIn, isUrl } from './validate.js';
 import version from './version.js';
 
-export { isConnectedSessionResponse, isSessionSuccessResponse } from './session-response.js';
-export type {
-    ConnectedSessionResponse,
-    SessionFailureResponse,
-    SessionObjectResponse,
-    SessionResponse,
-    SessionSuccessResponse,
-    SessionUserId,
-} from './types/session.js';
-
 declare global {
     interface Window {
         openSimplifiedLoginWidget?: OpenSimplifiedLoginWidget;
@@ -74,34 +63,44 @@ const globalWindow = () => window;
 /**
  * Provides Identity functionalty to a web page
  */
-export class Identity extends TinyEmitter {
-    _sessionInitiatedSent: boolean;
-    window: Window;
-    clientId: string;
-    sessionStorageCache: Cache;
-    localStorageCache: Cache;
-    redirectUri: string;
-    env: string;
-    log?: LogFunction;
-    callbackBeforeRedirect: IdentityBeforeRedirectCallback;
-    _sessionDomain: string;
-    _enableSessionCaching: boolean;
+export class Identity {
+    // Event bus
+    private readonly eventTarget = new EventTarget();
+
+    // Configuration
+    private readonly window: Window;
+    private readonly clientId: string;
+    private readonly redirectUri: string;
+    private readonly env: string;
+    private readonly log?: LogFunction;
+    private readonly callbackBeforeRedirect: IdentityBeforeRedirectCallback;
+
+    // Caches
+    private readonly sessionStorageCache: Cache;
+    private readonly localStorageCache: Cache;
+    private enableSessionCaching: boolean;
+
+    // REST clients
+    private readonly spid: RESTClient;
+    private readonly oauthService: RESTClient;
+    private readonly bffService: RESTClient;
+    private readonly sessionService: RESTClient;
+    private readonly globalSessionService: RESTClient;
+    private readonly usedSessionServiceGetSessionEndpoint: 'v2/session' | 'session';
+
+    // Session state
     /**
      * @internal Starts as `{}` before the first `hasSession()` call, then stores the latest
      * object response from hasSession().
      */
-    _session: SessionObjectResponse;
-    _spid: RESTClient;
-    _oauthService: RESTClient;
-    _bffService: RESTClient;
-    _sessionService: RESTClient;
-    _globalSessionService: RESTClient;
-    _usedSessionServiceGetSessionEndpoint: 'v2/session' | 'session';
-    _hasSessionInProgress?: false | Promise<SessionResponse>;
-    popup?: Window | null;
-    setVarnishCookie?: boolean;
-    varnishExpiresIn?: number;
-    varnishCookieDomain?: string;
+    private session: SessionObjectResponse;
+    private hasSessionInProgress?: false | Promise<SessionResponse>;
+
+    // Popup & Varnish cookie state
+    private popup?: Window | null;
+    private setVarnishCookie?: boolean;
+    private varnishExpiresIn?: number;
+    private varnishCookieDomain?: string;
 
     /**
      * @param options
@@ -124,7 +123,6 @@ export class Identity extends TinyEmitter {
         window = globalWindow(),
         callbackBeforeRedirect = () => {},
     }: IdentityOptions) {
-        super();
         assert(isNonEmptyString(clientId), 'clientId parameter is required');
         assert(isObject(window), 'The reference to window is missing');
         assert(!redirectUri || isUrl(redirectUri), 'redirectUri parameter is invalid');
@@ -135,64 +133,66 @@ export class Identity extends TinyEmitter {
         assert(isStr(env), `env parameter is invalid: ${env}`);
 
         spidTalk.emulate(window);
-        this._sessionInitiatedSent = false;
         this.window = window;
         this.clientId = clientId;
-        this.sessionStorageCache = new Cache(() => this.window && this.window.sessionStorage);
-        this.localStorageCache = new Cache(() => this.window && this.window.localStorage);
         this.redirectUri = redirectUri;
         this.env = env;
         this.log = log;
         this.callbackBeforeRedirect = callbackBeforeRedirect;
-        this._sessionDomain = sessionDomain;
 
+        this.sessionStorageCache = new Cache(() => this.window && this.window.sessionStorage);
+        this.localStorageCache = new Cache(() => this.window && this.window.localStorage);
         // Internal hack: set to false to always refresh from hassession
-        this._enableSessionCaching = true;
+        this.enableSessionCaching = true;
 
-        // Old session
-        this._session = {};
+        this.session = {};
 
         const accountClientParams = { client_id: this.clientId, redirect_uri: this.redirectUri };
         const clientSdrn = buildClientSdrn(this.env, this.clientId);
 
-        this._sessionService = createAccountRestClient({
-            serverUrl: sessionDomain,
+        this.spid = createAccountRestClient({
+            serverUrl: urlMapper(env, ENDPOINTS.SPiD),
             log: this.log,
-            defaultParams: {
-                client_sdrn: clientSdrn,
-                redirect_uri: this.redirectUri,
-                sdk_version: version,
-            },
+            defaultParams: accountClientParams,
         });
-        this._usedSessionServiceGetSessionEndpoint =
-            this._sessionService.url.pathname && this._sessionService.url.pathname.length <= 1
-                ? 'v2/session'
-                : 'session';
-
-        this._spid = createAccountRestClient({
+        this.oauthService = createAccountRestClient({
             serverUrl: urlMapper(env, ENDPOINTS.SPiD),
             log: this.log,
             defaultParams: accountClientParams,
         });
-        this._bffService = createAccountRestClient({
+        this.bffService = createAccountRestClient({
             serverUrl: urlMapper(env, ENDPOINTS.BFF),
             log: this.log,
             defaultParams: accountClientParams,
         });
-        this._oauthService = createAccountRestClient({
-            serverUrl: urlMapper(env, ENDPOINTS.SPiD),
+        this.sessionService = createAccountRestClient({
+            serverUrl: sessionDomain,
             log: this.log,
-            defaultParams: accountClientParams,
+            defaultParams: {
+                client_sdrn: clientSdrn,
+                redirect_uri: this.redirectUri,
+                sdk_version: version,
+            },
         });
-        this._globalSessionService = createAccountRestClient({
+        this.globalSessionService = createAccountRestClient({
             serverUrl: urlMapper(env, ENDPOINTS.SESSION_SERVICE),
             log: this.log,
             defaultParams: { client_sdrn: clientSdrn, sdk_version: version },
         });
+        this.usedSessionServiceGetSessionEndpoint =
+            this.sessionService.url.pathname && this.sessionService.url.pathname.length <= 1
+                ? 'v2/session'
+                : 'session';
 
         this._unblockSessionCall();
+    }
 
-        registerAndDispatchInGlobal(window, 'schIdentity', this);
+    addEventListener(type: AccountEventName, listener: EventListener): void {
+        this.eventTarget.addEventListener(type, listener);
+    }
+
+    removeEventListener(type: AccountEventName, listener: EventListener): void {
+        this.eventTarget.removeEventListener(type, listener);
     }
 
     /**
@@ -200,7 +200,7 @@ export class Identity extends TinyEmitter {
      * @private
      */
     _getTabId(): number | undefined {
-        if (this._enableSessionCaching) {
+        if (this.enableSessionCaching) {
             const tabId = this.sessionStorageCache.get(TAB_ID_KEY);
             if (typeof tabId !== 'number') {
                 this.sessionStorageCache.set(TAB_ID_KEY, TAB_ID, TAB_ID_TTL);
@@ -244,80 +244,6 @@ export class Identity extends TinyEmitter {
         this.localStorageCache.delete(SESSION_CALL_BLOCKED_CACHE_KEY);
     }
 
-    /**
-     * Emits the relevant events based on the previous and new reply from hasSession
-     * @private
-     * @param previous
-     * @param current
-     */
-    _emitSessionEvent(previous: object, current: object): void {
-        const previousUserId = isSessionSuccessResponse(previous) ? previous.userId : undefined;
-        const currentUserId = isSessionSuccessResponse(current) ? current.userId : undefined;
-        const previousUserStatus = isSessionSuccessResponse(previous)
-            ? previous.userStatus
-            : undefined;
-        const currentUserStatus = isSessionSuccessResponse(current)
-            ? current.userStatus
-            : undefined;
-
-        /**
-         * Emitted when the user is logged in (This happens as a result of calling
-         * {@link Identity#hasSession}, so it is also emitted if the user was previously logged in)
-         * @event Identity#login
-         */
-        if (currentUserId) {
-            this.emit('login', current);
-        }
-        /**
-         * Emitted when the user logged out
-         * @event Identity#logout
-         */
-        if (previousUserId && !currentUserId) {
-            this.emit('logout', current);
-        }
-        /**
-         * Emitted when the user is changed. This happens as a result of calling
-         * {@link Identity#hasSession}, and is emitted if there was a user both before and after
-         * this invocation, and the userId has now changed
-         * @event Identity#userChange
-         */
-        if (previousUserId && currentUserId && previousUserId !== currentUserId) {
-            this.emit('userChange', current);
-        }
-        if (previousUserId || currentUserId) {
-            /**
-             * Emitted when the session is changed. More accurately, this event is emitted if there
-             * was a logged-in user either before or after {@link Identity#hasSession} was called.
-             * In practice, this means the event is emitted a lot
-             * @event Identity#sessionChange
-             */
-            this.emit('sessionChange', current);
-        } else {
-            /**
-             * Emitted when there is no logged-in user. More specifically, it means that there was
-             * no logged-in user neither before nor after {@link Identity#hasSession} was called
-             * @event Identity#notLoggedin
-             */
-            this.emit('notLoggedin', current);
-        }
-        /**
-         * Emitted when the session is first created
-         * @event Identity#sessionInit
-         */
-        if (currentUserId && !this._sessionInitiatedSent) {
-            this._sessionInitiatedSent = true;
-            this.emit('sessionInit', current);
-        }
-        /**
-         * Emitted when the user status changes. This happens as a result of calling
-         * {@link Identity#hasSession}
-         * @event Identity#statusChange
-         */
-        if (previousUserStatus !== currentUserStatus) {
-            this.emit('statusChange', current);
-        }
-    }
-
     /**
      * Close this.popup if it exists and is open
      * @private
@@ -406,10 +332,10 @@ export class Identity extends TinyEmitter {
      */
     _clearVarnishCookie(): void {
         const baseDomain =
-            this._session &&
-            isSessionSuccessResponse(this._session) &&
-            typeof this._session.baseDomain === 'string'
-                ? this._session.baseDomain
+            this.session &&
+            isSessionSuccessResponse(this.session) &&
+            typeof this.session.baseDomain === 'string'
+                ? this.session.baseDomain
                 : this.window.location.hostname;
 
         const domain = this.varnishCookieDomain || baseDomain || '';
@@ -417,53 +343,23 @@ export class Identity extends TinyEmitter {
         document.cookie = `SP_ID=nothing; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=.${domain}`;
     }
 
-    /**
-     * Log used settings and version
-     * @throws {SDKError} - If log method is not provided
-     */
-    logSettings(): void {
-        if (!this.log && !window.console) {
-            throw new SDKError('You have to provide log method in constructor');
-        }
-
-        const log = this.log || console.log;
-
-        const settings = {
-            clientId: this.clientId,
-            redirectUri: this.redirectUri,
-            env: this.env,
-            sessionDomain: this._sessionDomain,
-            sdkVersion: version,
-        };
-
-        log(`Schibsted account SDK for browsers settings: \n${JSON.stringify(settings, null, 2)}`);
-    }
-
     /**
      * @summary Queries the hassession endpoint and returns information about the status of the user
      * @remarks When we send a request to this endpoint, cookies sent along with the request
      * determines the status of the user.
      * @throws {SDKError} - If the call to the hasSession service fails in any way (this will happen
      * if, say, the user is not logged in)
-     * @fires Identity#login
-     * @fires Identity#logout
-     * @fires Identity#userChange
-     * @fires Identity#sessionChange
-     * @fires Identity#notLoggedin
-     * @fires Identity#sessionInit
-     * @fires Identity#statusChange
-     * @fires Identity#error
      */
     hasSession(): Promise<SessionResponse> {
         const isSessionCallBlocked = this._isSessionCallBlocked();
 
         if (isSessionCallBlocked) {
-            const sessionData = normalizeSessionResponse(this._session);
+            const sessionData = normalizeSessionResponse(this.session);
             return Promise.resolve(isRedirectSessionPayload(sessionData) ? {} : sessionData);
         }
 
-        if (this._hasSessionInProgress) {
-            return this._hasSessionInProgress;
+        if (this.hasSessionInProgress) {
+            return this.hasSessionInProgress;
         }
 
         const _postProcess = (sessionData: SessionObjectResponse): SessionObjectResponse => {
@@ -474,8 +370,7 @@ export class Identity extends TinyEmitter {
                 throw new SDKError('HasSession failed', errorObject);
             }
             this._maybeSetVarnishCookie(sessionData);
-            this._emitSessionEvent(this._session, sessionData);
-            this._session = sessionData;
+            this.session = sessionData;
             return sessionData;
         };
 
@@ -485,7 +380,7 @@ export class Identity extends TinyEmitter {
         };
 
         const _getSession = async (): Promise<SessionResponse> => {
-            if (this._enableSessionCaching) {
+            if (this.enableSessionCaching) {
                 // Try to resolve from cache (it has a TTL)
                 const cachedSession = _getCachedSession();
                 if (cachedSession) {
@@ -497,14 +392,14 @@ export class Identity extends TinyEmitter {
             }
             let sessionData: NormalizedSessionPayload | null = null;
             try {
-                sessionData = await this._sessionService.get(
-                    this._usedSessionServiceGetSessionEndpoint,
+                sessionData = await this.sessionService.get(
+                    this.usedSessionServiceGetSessionEndpoint,
                     { tabId: this._getTabId() },
                     normalizeSessionResponse,
                 );
             } catch (err: unknown) {
                 const cacheableError = isObject(err) ? err : undefined;
-                if (cacheableError?.code === 400 && this._enableSessionCaching) {
+                if (cacheableError?.code === 400 && this.enableSessionCaching) {
                     const errorExpiresIn =
                         typeof cacheableError.expiresIn === 'number'
                             ? cacheableError.expiresIn
@@ -516,7 +411,7 @@ export class Identity extends TinyEmitter {
                     typeof cacheableError.code === 'number' &&
                     cacheableError.code >= 500 &&
                     cacheableError.code < 600 &&
-                    this._enableSessionCaching
+                    this.enableSessionCaching
                 ) {
                     // Temporary fix: 30 seconds cache to limit number of calls when service is unavailable
                     this.sessionStorageCache.set(HAS_SESSION_CACHE_KEY, { error: err }, 30 * 1000);
@@ -531,13 +426,13 @@ export class Identity extends TinyEmitter {
 
                     await this.callbackBeforeRedirect();
 
-                    const redirectUrl = this._sessionService.makeUrl(sessionData.redirectURL, {
+                    const redirectUrl = this.sessionService.makeUrl(sessionData.redirectURL, {
                         tabId: this._getTabId(),
                     });
                     return redirectUrl;
                 }
 
-                if (this._enableSessionCaching) {
+                if (this.enableSessionCaching) {
                     const expiresIn =
                         1000 *
                         (isSessionSuccessResponse(sessionData)
@@ -549,22 +444,21 @@ export class Identity extends TinyEmitter {
 
             return _postProcess(sessionData ?? {});
         };
-        this._hasSessionInProgress = _getSession().then(
+        this.hasSessionInProgress = _getSession().then(
             (sessionData) => {
-                this._hasSessionInProgress = false;
+                this.hasSessionInProgress = false;
                 if (typeof sessionData === 'string') {
                     this.window.location.href = sessionData;
                 }
                 return sessionData;
             },
             (err) => {
-                this.emit('error', err);
-                this._hasSessionInProgress = false;
+                this.hasSessionInProgress = false;
                 throw new SDKError('HasSession failed', err);
             },
         );
 
-        return this._hasSessionInProgress;
+        return this.hasSessionInProgress;
     }
 
     /**
@@ -581,6 +475,16 @@ export class Identity extends TinyEmitter {
         }
     }
 
+    /**
+     * Enables or disables caching for subsequent session lookups.
+     *
+     * Changing this setting does not remove an existing cached session. Use
+     * {@link Identity#clearCachedUserSession} to clear the cache explicitly.
+     */
+    setSessionCachingEnabled(enabled: boolean): void {
+        this.enableSessionCaching = enabled;
+    }
+
     /**
      * Removes the cached user session.
      */
@@ -618,11 +522,9 @@ export class Identity extends TinyEmitter {
         }
         return cloneDeep(user);
     }
-
     /**
      * @summary
-     * In Schibsted account, there are multiple ways of identifying a user; the `userId`,
-     * `uuid` and `externalId` used for identifying a user-merchant pair (see {@link Identity#getExternalId}).
+     * In Schibsted account, there are multiple ways of identifying a user; the `userId` or `uuid`.
      * There are reasons for them all to exist. The `userId` is a numeric identifier, but
      * since Schibsted account is deployed separately in Norway and Sweden, there are a lot of
      * duplicates. The `userId` was introduced early, so many sites still need to use them for
@@ -641,65 +543,6 @@ export class Identity extends TinyEmitter {
         throw new SDKError('The user is not connected to this merchant');
     }
 
-    /**
-     * @function
-     * @summary
-     * Retrieves the external identifier (`externalId`) for the authenticated user.
-     *
-     * In Schibsted Account there are multiple ways of identifying users, however for integrations with
-     * third-parties it's recommended to use `externalId` as it does not disclose
-     * any critical data whilst allowing for user identification.
-     *
-     * `externalId` is merchant-scoped using a pairwise identifier (`pairId`),
-     * meaning the same user's ID will differ between merchants.
-     * Additionally, this identifier is bound to the external party provided as argument.
-     *
-     * @param externalParty
-     * @param optionalSuffix
-     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
-     * effect that it might perform an auto-login on the user
-     * @throws {SDKError} If the `pairId` is missing in user session.
-     * @throws {SDKError} If the `externalParty` is not defined
-     * @return The merchant- and 3rd-party-specific `externalId`
-     */
-    async getExternalId(externalParty: string, optionalSuffix: string = ''): Promise<string> {
-        const user = await this.hasSession();
-        const pairId = isSessionSuccessResponse(user) ? user.pairId : undefined;
-
-        if (!pairId) throw new SDKError('pairId missing in user session!');
-
-        if (!externalParty || externalParty.length === 0) {
-            throw new SDKError('externalParty cannot be empty');
-        }
-        const _toHexDigest = (hashBuffer: ArrayBuffer) => {
-            // convert buffer to byte array
-            const hashArray = Array.from(new Uint8Array(hashBuffer));
-            // convert bytes to hex string
-            return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
-        };
-
-        const _getSha256Digest = (data: BufferSource) => {
-            return crypto.subtle.digest('SHA-256', data);
-        };
-
-        const _hashMessage = async (message: string) => {
-            const msgUint8 = new TextEncoder().encode(message);
-            return _getSha256Digest(msgUint8).then((it) => _toHexDigest(it));
-        };
-
-        const _constructMessage = (
-            pairId: string,
-            externalParty: string,
-            optionalSuffix: string,
-        ) => {
-            return optionalSuffix
-                ? `${pairId}:${externalParty}:${optionalSuffix}`
-                : `${pairId}:${externalParty}`;
-        };
-
-        return _hashMessage(_constructMessage(pairId, externalParty, optionalSuffix));
-    }
-
     /**
      * @summary Enables brands to programmatically get the current the SDRN based on the user's session.
      * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
@@ -744,7 +587,7 @@ export class Identity extends TinyEmitter {
      */
     async getUserContextData(): Promise<SimplifiedLoginData | null> {
         try {
-            return await this._globalSessionService.get('user-context', undefined, (value) =>
+            return await this.globalSessionService.get('user-context', undefined, (value) =>
                 isObject(value) && isStr(value.identifier)
                     ? {
                           identifier: value.identifier,
@@ -782,6 +625,7 @@ export class Identity extends TinyEmitter {
      * @param options.xDomainId
      * @param options.xEnvironmentId
      * @param options.originCampaign
+     * @fires Identity#login
      * @return - Reference to popup window if created (or `null` otherwise)
      */
     login({
@@ -825,11 +669,25 @@ export class Identity extends TinyEmitter {
                 width: 360,
                 height: 570,
             });
+
             if (this.popup) {
+                this.eventTarget.dispatchEvent(
+                    new CustomEvent('login', {
+                        detail: { url, method: 'popup' },
+                    }),
+                );
+
                 return this.popup;
             }
         }
+
+        this.eventTarget.dispatchEvent(
+            new CustomEvent('login', {
+                detail: { url, method: 'default' },
+            }),
+        );
         this.window.location.href = url;
+
         return null;
     }
 
@@ -854,14 +712,19 @@ export class Identity extends TinyEmitter {
 
     /**
      * @summary Logs the user out from the Identity platform
-     * @param redirectUri - Where to redirect the browser after logging out of Schibsted
-     * account
+     * @param redirectUri - Where to redirect the browser after logging out of Schibsted account
+     * @fires Identity#logout
      */
     logout(redirectUri: string = this.redirectUri): void {
         this.sessionStorageCache.delete(HAS_SESSION_CACHE_KEY);
         this._maybeClearVarnishCookie();
-        this.emit('logout');
-        this.window.location.href = this.logoutUrl(redirectUri);
+        const url = this.logoutUrl(redirectUri);
+        this.eventTarget.dispatchEvent(
+            new CustomEvent('logout', {
+                detail: { url },
+            }),
+        );
+        this.window.location.href = url;
     }
 
     /**
@@ -920,7 +783,7 @@ export class Identity extends TinyEmitter {
             `the state parameter should be a non empty string but it is ${state}`,
         );
 
-        return this._oauthService.makeUrl('oauth/authorize', {
+        return this.oauthService.makeUrl('oauth/authorize', {
             response_type: 'code',
             redirect_uri: redirectUri,
             scope,
@@ -947,7 +810,7 @@ export class Identity extends TinyEmitter {
     logoutUrl(redirectUri: string = this.redirectUri): string {
         assert(isUrl(redirectUri), `logoutUrl(): redirectUri is invalid`);
         const params = { redirect_uri: redirectUri };
-        return this._sessionService.makeUrl('logout', params);
+        return this.sessionService.makeUrl('logout', params);
     }
 
     /**
@@ -955,18 +818,7 @@ export class Identity extends TinyEmitter {
      * @param redirectUri
      */
     accountUrl(redirectUri: string = this.redirectUri): string {
-        return this._spid.makeUrl('profile-pages', {
-            response_type: 'code',
-            redirect_uri: redirectUri,
-        });
-    }
-
-    /**
-     * The phone editing page url
-     * @param redirectUri
-     */
-    phonesUrl(redirectUri: string = this.redirectUri): string {
-        return this._spid.makeUrl('profile-pages/about-you/phone', {
+        return this.spid.makeUrl('profile-pages', {
             response_type: 'code',
             redirect_uri: redirectUri,
         });
@@ -996,7 +848,7 @@ export class Identity extends TinyEmitter {
         if (options && options.encoding) {
             queryParams.encoding = options.encoding;
         }
-        const widgetUrl = this._bffService.makeUrl('simplified-login-widget', queryParams, false);
+        const widgetUrl = this.bffService.makeUrl('simplified-login-widget', queryParams, false);
 
         const prepareLoginParams = async (
             loginParams: SimplifiedLoginWidgetLoginOptions,
@@ -1056,11 +908,11 @@ export class Identity extends TinyEmitter {
                  * Emitted when the simplified login widget is displayed on the screen
                  * @event Identity#simplifiedLoginOpened
                  */
-                this.emit('simplifiedLoginOpened');
+                this.eventTarget.dispatchEvent(new Event('simplifiedLoginOpened'));
             };
 
             const cancelLoginHandler = () => {
-                this.emit('simplifiedLoginCancelled');
+                this.eventTarget.dispatchEvent(new Event('simplifiedLoginCancelled'));
             };
 
             if (hasOpenSimplifiedLoginWidget(window)) {

package/src/index.ts

@@ -4,14 +4,14 @@
 
 export { Account } from './account.js';
 export { createAccountSdk, getAccountSdk } from './account-sdk.js';
+export * from './globals.js';
 export { default as SDKError } from './sdk-error.js';
 
 /* public available types */
 export type {
     AccountConfig,
-    AccountEventHandler,
+    AccountEventListener,
     AccountEventName,
-    AccountSessionEventName,
 } from './types/account.js';
 export type { AccountEnvironment, LogFunction } from './types/common.js';
 export type {