@schibsted/account-sdk-browser 6.0.0-alpha.5 → 6.0.0-alpha.7

package/src/identity.ts

@@ -2,7 +2,6 @@
  * See LICENSE.md in the project root.
  */
 
-import { TinyEmitter } from 'tiny-emitter';
 import Cache from './cache.js';
 import { ENDPOINTS } from './config.js';
 import { cloneDeep } from './object.js';
@@ -19,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,
@@ -63,33 +63,44 @@ const globalWindow = () => window;
 /**
  * Provides Identity functionalty to a web page
  */
-export class Identity extends TinyEmitter {
-    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
@@ -112,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');
@@ -125,67 +135,72 @@ export class Identity extends TinyEmitter {
         spidTalk.emulate(window);
         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();
     }
 
+    addEventListener(type: AccountEventName, listener: EventListener): void {
+        this.eventTarget.addEventListener(type, listener);
+    }
+
+    removeEventListener(type: AccountEventName, listener: EventListener): void {
+        this.eventTarget.removeEventListener(type, listener);
+    }
+
     /**
      * Read tabId from session storage
      * @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);
@@ -229,33 +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;
-
-        /**
-         * 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);
-        }
-    }
-
     /**
      * Close this.popup if it exists and is open
      * @private
@@ -344,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 || '';
@@ -361,19 +349,17 @@ export class Identity extends TinyEmitter {
      * 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
      */
     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 => {
@@ -384,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;
         };
 
@@ -395,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) {
@@ -407,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
@@ -426,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);
@@ -441,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)
@@ -459,21 +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._hasSessionInProgress = false;
+                this.hasSessionInProgress = false;
                 throw new SDKError('HasSession failed', err);
             },
         );
 
-        return this._hasSessionInProgress;
+        return this.hasSessionInProgress;
     }
 
     /**
@@ -490,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.
      */
@@ -592,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,
@@ -630,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({
@@ -673,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;
     }
 
@@ -702,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;
     }
 
     /**
@@ -768,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,
@@ -795,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);
     }
 
     /**
@@ -803,7 +818,7 @@ export class Identity extends TinyEmitter {
      * @param redirectUri
      */
     accountUrl(redirectUri: string = this.redirectUri): string {
-        return this._spid.makeUrl('profile-pages', {
+        return this.spid.makeUrl('profile-pages', {
             response_type: 'code',
             redirect_uri: redirectUri,
         });
@@ -833,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,
@@ -893,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

@@ -10,7 +10,7 @@ export { default as SDKError } from './sdk-error.js';
 /* public available types */
 export type {
     AccountConfig,
-    AccountEventHandler,
+    AccountEventListener,
     AccountEventName,
 } from './types/account.js';
 export type { AccountEnvironment, LogFunction } from './types/common.js';

package/src/monetization.ts

@@ -3,7 +3,6 @@
  */
 
 import Cache from './cache.js';
-import { ENDPOINTS } from './config.js';
 import { parseHasAccessResult } from './has-access-response.js';
 import type RESTClient from './rest-client.js';
 import { buildClientSdrn, createAccountRestClient } from './rest-clients.js';
@@ -11,7 +10,6 @@ import SDKError from './sdk-error.js';
 import * as spidTalk from './spid-talk.js';
 import type { HasAccessResult, MonetizationOptions } from './types/monetization.js';
 import type { SessionUserId } from './types/session.js';
-import { urlMapper } from './url.js';
 import { assert, isNonEmptyString, isStr, isUrl } from './validate.js';
 import version from './version.js';
 
@@ -21,13 +19,9 @@ const globalWindow = () => window;
  * Provides features related to monetization
  */
 export class Monetization {
-    cache: Cache;
-    clientId: string;
-    env: string;
-    redirectUri?: string;
-    _spid: RESTClient;
-    _sessionService?: RESTClient;
-    private pendingHasAccessRequests: Record<string, Promise<HasAccessResult>>;
+    private readonly cache: Cache;
+    private readonly sessionService?: RESTClient;
+    private readonly pendingHasAccessRequests: Record<string, Promise<HasAccessResult>>;
 
     /**
      * @param options - Monetization configuration
@@ -43,24 +37,18 @@ export class Monetization {
         spidTalk.emulate(window);
         assert(isNonEmptyString(clientId), 'clientId parameter is required');
         assert(isStr(env), `env parameter is invalid: ${env}`);
+        const clientSdrn = buildClientSdrn(env, clientId);
 
         this.cache = new Cache(() => window && window.sessionStorage);
-        this.clientId = clientId;
-        this.env = env;
-        this.redirectUri = redirectUri;
         this.pendingHasAccessRequests = {};
-        this._spid = createAccountRestClient({
-            serverUrl: urlMapper(env, ENDPOINTS.SPiD),
-            defaultParams: { client_id: this.clientId, redirect_uri: this.redirectUri },
-        });
 
         if (sessionDomain) {
             assert(isUrl(sessionDomain), 'sessionDomain parameter is not a valid URL');
-            this._sessionService = createAccountRestClient({
+            this.sessionService = createAccountRestClient({
                 serverUrl: sessionDomain,
                 defaultParams: {
-                    client_sdrn: buildClientSdrn(this.env, this.clientId),
-                    redirect_uri: this.redirectUri,
+                    client_sdrn: clientSdrn,
+                    redirect_uri: redirectUri,
                     sdk_version: version,
                 },
             });
@@ -77,7 +65,7 @@ export class Monetization {
      * doesn't have access to any of the given products/features)
      */
     async hasAccess(productIds: string[], userId: SessionUserId): Promise<HasAccessResult | null> {
-        if (!this._sessionService) {
+        if (!this.sessionService) {
             throw new SDKError(`hasAccess can only be called if 'sessionDomain' is configured`);
         }
         if (!userId) {
@@ -88,11 +76,11 @@ export class Monetization {
         }
 
         const sortedIds = [...productIds].sort();
-        const cacheKey = this._accessCacheKey(sortedIds, userId);
+        const cacheKey = this.accessCacheKey(sortedIds, userId);
         let data = this.cache.get(cacheKey) as HasAccessResult | null;
         if (!data) {
             if (!this.pendingHasAccessRequests[cacheKey]) {
-                this.pendingHasAccessRequests[cacheKey] = this._sessionService.get(
+                this.pendingHasAccessRequests[cacheKey] = this.sessionService.get(
                     `/hasAccess/${sortedIds.join(',')}`,
                     undefined,
                     parseHasAccessResult,
@@ -123,7 +111,7 @@ export class Monetization {
      * @param userId - id of currently logged in user
      */
     clearCachedAccessResult(productIds: string[], userId: SessionUserId): void {
-        this.cache.delete(this._accessCacheKey(productIds, userId));
+        this.cache.delete(this.accessCacheKey(productIds, userId));
     }
 
     /**
@@ -132,7 +120,7 @@ export class Monetization {
      * @param productIds - which products/features to check
      * @param userId - id of currently logged in user
      */
-    private _accessCacheKey(productIds: string[], userId: SessionUserId): string {
+    private accessCacheKey(productIds: string[], userId: SessionUserId): string {
         return `prd_${[...productIds].sort()}_${userId}`;
     }
 }

package/src/sdk-error.ts

@@ -14,6 +14,8 @@ const STRINGIFY_TYPES = ['boolean', 'number', 'string'];
  * Custom error class thrown by all SDK methods on failure.
  *
  * All rejected promises from API calls reject with an instance of this class.
+ *
+ * @group Errors
  */
 export default class SDKError extends Error {
     /** HTTP status code from the server error payload;

package/src/types/account.ts

@@ -1,6 +1,11 @@
 import type { AccountBaseConfig, LogFunction } from './common';
 import type { IdentityBeforeRedirectCallback, VarnishCookieOptions } from './identity';
 
+/**
+ * Configuration used to create an {@link Account} instance.
+ *
+ * @group Configuration
+ */
 export type AccountConfig = AccountBaseConfig & {
     /** Receives debug log information. If not set, no logging will be done. */
     log?: LogFunction;
@@ -10,19 +15,36 @@ export type AccountConfig = AccountBaseConfig & {
     varnish?: VarnishCookieOptions;
 };
 
+type LoginEventDetail = {
+    url: string;
+    method: 'popup' | 'default';
+};
+
+type LogoutEventDetail = {
+    url: string;
+};
+
+export type AccountEventMap = {
+    /** Emitted with the login URL and method when `login()` initiates a login flow. */
+    login: CustomEvent<LoginEventDetail>;
+    /** Emitted with the logout URL when `logout()` is called. */
+    logout: CustomEvent<LogoutEventDetail>;
+    /** Emitted when the simplified login widget is displayed. */
+    simplifiedLoginOpened: Event;
+    /** Emitted when the simplified login widget is closed. */
+    simplifiedLoginCancelled: Event;
+};
+
+/** Account event names emitted by the SDK. */
+export type AccountEventName = keyof AccountEventMap;
+
 /**
- * Identity events emitted by the SDK.
+ * Native event listener used by Account event subscriptions.
+ *
+ * Payload-bearing events are `CustomEvent` instances and expose their payload through `detail`.
  *
- * - `login`: emitted when `hasSession()` resolves with a logged-in user payload.
- * - `logout`: emitted when a previously logged-in user is no longer logged in, or when
- *   `logout()` is called.
- * - `simplifiedLoginOpened`: emitted when the simplified login widget is displayed.
- * - `simplifiedLoginCancelled`: emitted when the simplified login widget is closed.
+ * @group Events
  */
-export type AccountEventName =
-    | 'login'
-    | 'logout'
-    | 'simplifiedLoginOpened'
-    | 'simplifiedLoginCancelled';
-
-export type AccountEventHandler = (...args: unknown[]) => void;
+export type AccountEventListener<EventName extends AccountEventName = AccountEventName> = (
+    event: AccountEventMap[EventName],
+) => void;

package/src/types/common.ts

@@ -3,15 +3,21 @@
 /**
  * Log callback used by the SDK for debug output.
  * Receives a pre-formatted log line.
- * @internal
+ *
+ * @group Configuration
  */
 export type LogFunction = (message: string) => void;
 
 /**
  * Supported Schibsted account environment keys.
+ *
+ * @group Configuration
  */
 export type AccountEnvironment = 'LOCAL' | 'DEV' | 'PRE' | 'PRO' | 'PRO_NO' | 'PRO_FI' | 'PRO_DK';
 
+/**
+ * Shared Account configuration fields.
+ */
 export type AccountBaseConfig = {
     /** Mandatory client id. Example: "1234567890abcdef12345678" */
     clientId: string;