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

package/dist/account.d.ts

@@ -1,30 +1,161 @@
-import { AccountConfig, AccountEventHandler, AccountEventName } from './types/account.js';
+import { AccountConfig, AccountEventListener, AccountEventName } from './types/account.js';
 import { LoginOptions, SimplifiedLoginData, SimplifiedLoginWidgetLoginOptions, SimplifiedLoginWidgetOptions } from './types/login.js';
 import { HasAccessResult } from './types/monetization.js';
 import { ConnectedSessionResponse, SessionResponse, SessionUserId } from './types/session.js';
 /**
  * Unified client-side interface for a configured Schibsted Account integration.
+ *
+ * Create an instance with `createAccountSdk()` unless you explicitly need to construct it
+ * yourself. The instance coordinates identity, login, session, and access-check features for one
+ * configured client.
+ *
+ * @group Core API
  */
 export declare class Account {
     #private;
     constructor(config: AccountConfig);
+    /**
+     * Queries Session Service and returns the current browser session state.
+     *
+     * This call may trigger a full-page session refresh redirect. Configure
+     * `callbackBeforeRedirect` if your app needs to persist state before that navigation.
+     *
+     * @throws {SDKError} If the Session Service call fails.
+     */
     hasSession(): Promise<SessionResponse>;
+    /**
+     * Checks whether the browser currently has a Schibsted Account session.
+     *
+     * Returns `false` instead of throwing when the session lookup fails.
+     */
     isLoggedIn(): Promise<boolean>;
+    /**
+     * Checks whether the current user is connected to the configured client.
+     *
+     * A user can be logged in to Schibsted Account without being connected to your client, for
+     * example before accepting required terms.
+     */
     isConnected(): Promise<boolean>;
+    /**
+     * Returns the connected user session data.
+     *
+     * @throws {SDKError} If the user is not connected to the configured client.
+     */
     getUser(): Promise<ConnectedSessionResponse>;
+    /**
+     * Returns the realm-specific Schibsted Account user id as a string.
+     *
+     * Use `getUserUuid()` when you need the globally unique user id.
+     *
+     * @throws {SDKError} If the user is not connected to the configured client.
+     */
     getUserId(): Promise<string>;
+    /**
+     * Returns the globally unique user id from the current session.
+     *
+     * @throws {SDKError} If the user is not connected to the configured client.
+     */
+    getUserUuid(): Promise<string>;
+    /**
+     * Returns the user SDRN from the current session.
+     *
+     * @throws {SDKError} If the SDRN is missing from the session response.
+     */
     getUserSDRN(): Promise<string>;
+    /**
+     * Returns minimal user context for simplified login prompts.
+     *
+     * Returns `null` if the global account session cannot be read.
+     */
     getUserContextData(): Promise<SimplifiedLoginData | null>;
+    /**
+     * Returns the Varnish `sp_id` value from the current session when present.
+     */
     getSpId(): Promise<string | null>;
+    /**
+     * Starts the login flow with either a full-page redirect or a popup.
+     *
+     * Call this from a user gesture when `preferPopup` is enabled, otherwise browser popup blockers
+     * may block the popup and the SDK will fall back to redirect navigation.
+     *
+     * @param options - Login URL parameters.
+     * @returns A popup window reference when a popup is opened; otherwise `null`.
+     */
     login(options: LoginOptions): Window | null;
+    /**
+     * Logs the user out from the brand Session Service session and redirects the browser.
+     *
+     * @param redirectUri - Where Session Service should redirect the browser after logout.
+     */
     logout(redirectUri?: string): void;
+    /**
+     * Builds the login URL without navigating the browser.
+     *
+     * @param options - Login URL parameters.
+     */
     loginUrl(options: LoginOptions): string;
+    /**
+     * Builds the Schibsted Account profile page URL.
+     *
+     * @param redirectUri - Where the account page should redirect the browser afterwards.
+     */
     accountUrl(redirectUri?: string): string;
+    /**
+     * Loads and displays the simplified login widget when user context is available.
+     *
+     * Your application decides how often to call this method. The `state` field in `loginParams`
+     * may be a string or a function that resolves to a string.
+     * Widget open and cancel events can be observed with `on()`.
+     *
+     * @returns `true` when the widget was displayed.
+     * @throws {SDKError} If user context data is missing or the widget script cannot be loaded.
+     */
     showSimplifiedLoginWidget(loginParams: SimplifiedLoginWidgetLoginOptions, options?: SimplifiedLoginWidgetOptions): Promise<boolean>;
+    /**
+     * Enables or disables caching for subsequent session lookups.
+     *
+     * Changing this setting does not remove an existing cached session.
+     */
+    setSessionCachingEnabled(enabled: boolean): void;
+    /**
+     * Removes the cached Session Service user session response.
+     */
     clearCachedUserSession(): void;
+    /**
+     * Checks whether a user has access to any of the requested products or features.
+     *
+     * Results are cached according to the TTL returned by Session Service.
+     *
+     * @param productIds - Product or feature ids to check.
+     * @param userId - Current user id, usually from `getUserId()`.
+     * @returns Access data, or `null` when the user is not entitled.
+     * @throws {SDKError} If `sessionDomain` is missing, input is invalid, or the request fails.
+     */
     hasAccess(productIds: string[], userId: SessionUserId): Promise<HasAccessResult | null>;
+    /**
+     * Removes a cached access-check result.
+     *
+     * @param productIds - Product or feature ids used for the cached lookup.
+     * @param userId - User id used for the cached lookup.
+     */
     clearCachedAccessResult(productIds: string[], userId: SessionUserId): void;
-    on(event: AccountEventName, callback: AccountEventHandler, ctx?: unknown): this;
-    off(event: AccountEventName, callback?: AccountEventHandler): this;
+    /**
+     * Subscribes to Account events.
+     *
+     * Supported event names are defined by {@link AccountEventName}.
+     *
+     * @param event - Event name.
+     * @param listener - Listener that receives an `Event` or `CustomEvent`.
+     */
+    on<EventName extends AccountEventName>(event: EventName, listener: AccountEventListener<EventName>): this;
+    /**
+     * Unsubscribes from Account events.
+     *
+     * Supported event names are defined by {@link AccountEventName}.
+     *
+     * @param event - Event name.
+     * @param listener - Listener to remove.
+     */
+    off<EventName extends AccountEventName>(event: EventName, listener: AccountEventListener<EventName>): this;
 }
 export default Account;

package/dist/globals.d.ts

@@ -1,11 +1,7 @@
 import { Account } from './account.js';
-import { Identity } from './identity.js';
-import { Monetization } from './monetization.js';
 declare global {
     interface Window {
         schAccount?: Account;
-        schIdentity?: Identity;
-        schMonetization?: Monetization;
         SPiD?: {
             Talk?: {
                 response?: (callbackName: string, data: unknown) => unknown;

package/dist/identity.d.ts

@@ -1,12 +1,7 @@
-import { TinyEmitter } from 'tiny-emitter';
-import { default as Cache } from './cache.js';
-import { default as RESTClient } from './rest-client.js';
-import { LogFunction } from './types/common.js';
-import { IdentityBeforeRedirectCallback, IdentityOptions, VarnishCookieOptions } from './types/identity.js';
+import { AccountEventName } from './types/account.js';
+import { IdentityOptions, VarnishCookieOptions } from './types/identity.js';
 import { LoginOptions, OpenSimplifiedLoginWidget, SimplifiedLoginData, SimplifiedLoginWidgetLoginOptions, SimplifiedLoginWidgetOptions } from './types/login.js';
-import { ConnectedSessionResponse, SessionObjectResponse, SessionResponse } from './types/session.js';
-export { isConnectedSessionResponse, isSessionSuccessResponse } from './session-response.js';
-export type { ConnectedSessionResponse, SessionFailureResponse, SessionObjectResponse, SessionResponse, SessionSuccessResponse, SessionUserId, } from './types/session.js';
+import { ConnectedSessionResponse, SessionResponse } from './types/session.js';
 declare global {
     interface Window {
         openSimplifiedLoginWidget?: OpenSimplifiedLoginWidget;
@@ -15,34 +10,33 @@ declare global {
 /**
  * Provides Identity functionalty to a web page
  */
-export declare 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 declare class Identity {
+    private readonly eventTarget;
+    private readonly window;
+    private readonly clientId;
+    private readonly redirectUri;
+    private readonly env;
+    private readonly log?;
+    private readonly callbackBeforeRedirect;
+    private readonly sessionStorageCache;
+    private readonly localStorageCache;
+    private enableSessionCaching;
+    private readonly spid;
+    private readonly oauthService;
+    private readonly bffService;
+    private readonly sessionService;
+    private readonly globalSessionService;
+    private readonly usedSessionServiceGetSessionEndpoint;
     /**
      * @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;
+    private hasSessionInProgress?;
+    private popup?;
+    private setVarnishCookie?;
+    private varnishExpiresIn?;
+    private varnishCookieDomain?;
     /**
      * @param options
      * @param options.clientId - Example: "1234567890abcdef12345678"
@@ -56,6 +50,8 @@ export declare class Identity extends TinyEmitter {
      * @throws {SDKError} - If any of options are invalid
      */
     constructor({ clientId, redirectUri, sessionDomain, env, log, window, callbackBeforeRedirect, }: IdentityOptions);
+    addEventListener(type: AccountEventName, listener: EventListener): void;
+    removeEventListener(type: AccountEventName, listener: EventListener): void;
     /**
      * Read tabId from session storage
      * @private
@@ -79,13 +75,6 @@ export declare class Identity extends TinyEmitter {
      *
      */
     _unblockSessionCall(): void;
-    /**
-     * Emits the relevant events based on the previous and new reply from hasSession
-     * @private
-     * @param previous
-     * @param current
-     */
-    _emitSessionEvent(previous: object, current: object): void;
     /**
      * Close this.popup if it exists and is open
      * @private
@@ -116,25 +105,12 @@ export declare class Identity extends TinyEmitter {
      * @private
      */
     _clearVarnishCookie(): void;
-    /**
-     * Log used settings and version
-     * @throws {SDKError} - If log method is not provided
-     */
-    logSettings(): void;
     /**
      * @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>;
     /**
@@ -143,6 +119,13 @@ export declare class Identity extends TinyEmitter {
      * effect that it might perform an auto-login on the user
      */
     isLoggedIn(): Promise<boolean>;
+    /**
+     * 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;
     /**
      * Removes the cached user session.
      */
@@ -166,8 +149,7 @@ export declare class Identity extends TinyEmitter {
     getUser(): Promise<ConnectedSessionResponse>;
     /**
      * @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
@@ -179,28 +161,6 @@ export declare class Identity extends TinyEmitter {
      * @return The `userId` field (not to be confused with the `uuid`)
      */
     getUserId(): Promise<string>;
-    /**
-     * @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`
-     */
-    getExternalId(externalParty: string, optionalSuffix?: string): Promise<string>;
     /**
      * @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
@@ -253,6 +213,7 @@ export declare 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({ state, acrValues, scope, redirectUri, preferPopup, loginHint, tag, teaser, maxAge, locale, oneStepLogin, prompt, xDomainId, xEnvironmentId, originCampaign, }: LoginOptions): Window | null;
@@ -265,8 +226,8 @@ export declare class Identity extends TinyEmitter {
     getSpId(): Promise<string | null>;
     /**
      * @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): void;
     /**
@@ -300,11 +261,6 @@ export declare class Identity extends TinyEmitter {
      * @param redirectUri
      */
     accountUrl(redirectUri?: string): string;
-    /**
-     * The phone editing page url
-     * @param redirectUri
-     */
-    phonesUrl(redirectUri?: string): string;
     /**
      * Function responsible for loading and displaying simplified login widget. How often
      * widget will be display is up to you. Preferred way would be to show it once per user,

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { Account } from './account.js';
 export { createAccountSdk, getAccountSdk } from './account-sdk.js';
+export * from './globals.js';
 export { default as SDKError } from './sdk-error.js';
-export type { AccountConfig, AccountEventHandler, AccountEventName, AccountSessionEventName, } from './types/account.js';
+export type { AccountConfig, AccountEventListener, AccountEventName, } from './types/account.js';
 export type { AccountEnvironment, LogFunction } from './types/common.js';
 export type { LoginOptions, SimplifiedLoginData, SimplifiedLoginWidgetLoginOptions, SimplifiedLoginWidgetOptions, } from './types/login.js';
 export type { HasAccessResult } from './types/monetization.js';