@schibsted/account-sdk-browser 5.2.7 → 6.0.0-alpha.10

package/dist/config.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Core configuration used by the SDK.
+ * - `ENDPOINTS.SPiD` — SPiD endpoints per environment
+ * - `ENDPOINTS.BFF` — Endpoints used with new GDPR-compliant web flows
+ * - `ENDPOINTS.SESSION_SERVICE` — Endpoints to check global user session data
+ *
+ */
+declare const config: {
+    readonly ENDPOINTS: {
+        readonly SPiD: {
+            readonly LOCAL: "http://id.localhost";
+            readonly DEV: "https://identity-dev.schibsted.com";
+            readonly PRE: "https://identity-pre.schibsted.com";
+            readonly PRO: "https://login.schibsted.com";
+            readonly PRO_NO: "https://payment.schibsted.no";
+            readonly PRO_FI: "https://login.schibsted.fi";
+            readonly PRO_DK: "https://login.schibsted.dk";
+        };
+        readonly BFF: {
+            readonly LOCAL: "http://id.localhost/authn/";
+            readonly DEV: "https://identity-dev.schibsted.com/authn/";
+            readonly PRE: "https://identity-pre.schibsted.com/authn/";
+            readonly PRO: "https://login.schibsted.com/authn/";
+            readonly PRO_NO: "https://payment.schibsted.no/authn/";
+            readonly PRO_FI: "https://login.schibsted.fi/authn/";
+            readonly PRO_DK: "https://login.schibsted.dk/authn/";
+        };
+        readonly SESSION_SERVICE: {
+            readonly LOCAL: "http://session-service.id.localhost";
+            readonly DEV: "https://session-service.identity-dev.schibsted.com";
+            readonly PRE: "https://session-service.identity-pre.schibsted.com";
+            readonly PRO: "https://session-service.login.schibsted.com";
+            readonly PRO_NO: "https://session-service.payment.schibsted.no";
+            readonly PRO_FI: "https://session-service.login.schibsted.fi";
+            readonly PRO_DK: "https://session-service.login.schibsted.dk";
+        };
+    };
+    readonly NAMESPACE: {
+        readonly LOCAL: "id.localhost";
+        readonly DEV: "schibsted.com";
+        readonly PRE: "schibsted.com";
+        readonly PRO: "schibsted.com";
+        readonly PRO_NO: "spid.no";
+        readonly PRO_FI: "schibsted.fi";
+        readonly PRO_DK: "schibsted.dk";
+    };
+};
+export default config;
+export declare const ENDPOINTS: {
+    readonly SPiD: {
+        readonly LOCAL: "http://id.localhost";
+        readonly DEV: "https://identity-dev.schibsted.com";
+        readonly PRE: "https://identity-pre.schibsted.com";
+        readonly PRO: "https://login.schibsted.com";
+        readonly PRO_NO: "https://payment.schibsted.no";
+        readonly PRO_FI: "https://login.schibsted.fi";
+        readonly PRO_DK: "https://login.schibsted.dk";
+    };
+    readonly BFF: {
+        readonly LOCAL: "http://id.localhost/authn/";
+        readonly DEV: "https://identity-dev.schibsted.com/authn/";
+        readonly PRE: "https://identity-pre.schibsted.com/authn/";
+        readonly PRO: "https://login.schibsted.com/authn/";
+        readonly PRO_NO: "https://payment.schibsted.no/authn/";
+        readonly PRO_FI: "https://login.schibsted.fi/authn/";
+        readonly PRO_DK: "https://login.schibsted.dk/authn/";
+    };
+    readonly SESSION_SERVICE: {
+        readonly LOCAL: "http://session-service.id.localhost";
+        readonly DEV: "https://session-service.identity-dev.schibsted.com";
+        readonly PRE: "https://session-service.identity-pre.schibsted.com";
+        readonly PRO: "https://session-service.login.schibsted.com";
+        readonly PRO_NO: "https://session-service.payment.schibsted.no";
+        readonly PRO_FI: "https://session-service.login.schibsted.fi";
+        readonly PRO_DK: "https://session-service.login.schibsted.dk";
+    };
+};
+export declare const NAMESPACE: {
+    readonly LOCAL: "id.localhost";
+    readonly DEV: "schibsted.com";
+    readonly PRE: "schibsted.com";
+    readonly PRO: "schibsted.com";
+    readonly PRO_NO: "spid.no";
+    readonly PRO_FI: "schibsted.fi";
+    readonly PRO_DK: "schibsted.dk";
+};

package/dist/globals.d.ts

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

package/dist/has-access-response.d.ts

@@ -0,0 +1,2 @@
+import { HasAccessResult } from './types/monetization.js';
+export declare function parseHasAccessResult(value: unknown): HasAccessResult;

package/dist/identity.d.ts

@@ -0,0 +1,302 @@
+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, SessionResponse } from './types/session.js';
+declare global {
+    interface Window {
+        openSimplifiedLoginWidget?: OpenSimplifiedLoginWidget;
+    }
+}
+/**
+ * Provides Identity functionalty to a web page
+ */
+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().
+     */
+    private session;
+    private hasSessionInProgress?;
+    private popup?;
+    private setVarnishCookie?;
+    private varnishExpiresIn?;
+    private varnishCookieDomain?;
+    /**
+     * @param options
+     * @param options.clientId - Example: "1234567890abcdef12345678"
+     * @param options.sessionDomain - Example: "https://id.site.com"
+     * @param options.redirectUri - Example: "https://site.com"
+     * @param options.env - Schibsted account environment: `PRE` (default), `PRO`, `PRO_NO`, `PRO_FI` or `PRO_DK`
+     * @param options.log - A function that receives debug log information. If not set,
+     * no logging will be done
+     * @param options.window - window object
+     * @param options.callbackBeforeRedirect - callback triggered before session refresh redirect happen
+     * @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
+     */
+    _getTabId(): number | undefined;
+    /**
+     * Checks if getting session is blocked
+     * @private
+     *
+     */
+    _isSessionCallBlocked(): boolean;
+    /**
+     * Block calls to get session
+     * @private
+     *
+     */
+    _blockSessionCall(): void;
+    /**
+     * Unblocks calls to get session
+     * @private
+     *
+     */
+    _unblockSessionCall(): void;
+    /**
+     * Close this.popup if it exists and is open
+     * @private
+     */
+    _closePopup(): void;
+    /**
+     * Set the Varnish cookie (`SP_ID`) when hasSession() is called. Note that most browsers require
+     * that you are on a "real domain" for this to work — so, **not** `localhost`
+     * @param options
+     * @param options.expiresIn Override this to set number of seconds before the varnish
+     * cookie expires. The default is to use the same time that hasSession responses are cached for
+     * @param options.domain Override cookie domain. E.g. «vg.no» instead of «www.vg.no»
+     */
+    enableVarnishCookie(options: VarnishCookieOptions): void;
+    /**
+     * Set the Varnish cookie if configured
+     * @private
+     * @param sessionData
+     */
+    _maybeSetVarnishCookie(sessionData: object): void;
+    /**
+     * Clear the Varnish cookie if configured
+     * @private
+     */
+    _maybeClearVarnishCookie(): void;
+    /**
+     * Clear the Varnish cookie
+     * @private
+     */
+    _clearVarnishCookie(): 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#sessionUpdated
+     */
+    hasSession(): Promise<SessionResponse>;
+    /**
+     * @summary Allows the client app to check if the user is logged in to Schibsted account
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * 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.
+     */
+    clearCachedUserSession(): void;
+    /**
+     * @summary Allows the caller to check if the current user is connected to the client_id in
+     * Schibsted account. Being connected means that the user has agreed for their account to be
+     * used by your web app and have accepted the required terms
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @summary Check if the user is connected to the client_id
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * @summary Returns information about the user
+     * @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 user isn't connected to the merchant
+     * @throws {SDKError} If we couldn't get the user
+     */
+    getUser(): Promise<ConnectedSessionResponse>;
+    /**
+     * @summary
+     * 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
+     * legacy reasons. The `uuid` is universally unique, and so — if we could disregard a lot of
+     * Schibsted components depending on the numeric `userId` — it would be a good identifier to use
+     * @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 user isn't connected to the merchant
+     * @return The `userId` field (not to be confused with the `uuid`)
+     */
+    getUserId(): Promise<number>;
+    /**
+     * @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
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the SDRN is missing in user session object.
+     */
+    getUserSDRN(): Promise<string>;
+    /**
+     * @summary In Schibsted account, there are two ways of identifying a user; the `userId` and the
+     * `uuid`. There are reasons for them both existing. 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
+     * legacy reasons. The `uuid` is universally unique, and so — if we could disregard a lot of
+     * Schibsted components depending on the numeric `userId` — it would be a good identifier to use
+     * @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 user isn't connected to the merchant
+     * @return The `uuid` field (not to be confused with the `userId`)
+     */
+    getUserUuid(): Promise<string>;
+    /**
+     * @summary Get basic information about any user currently logged-in to their Schibsted account
+     * in this browser. Can be used to provide context in a continue-as prompt.
+     * @remarks This function relies on the global Schibsted account user session cookie, which
+     * is a third-party cookie and hence might be blocked by the browser (for example due to ITP in
+     * Safari). So there's no guarantee any data is returned, even though a user is logged-in in
+     * the current browser.
+     */
+    getUserContextData(): Promise<SimplifiedLoginData | null>;
+    /**
+     * If a popup is desired, this function needs to be called in response to a user event (like
+     * click or tap) in order to work correctly. Otherwise the popup will be blocked by the
+     * browser's popup blockers and has to be explicitly authorized to be shown.
+     * @summary Perform a login, either using a full-page redirect or a popup
+     * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+     *
+     * @param options
+     * @param options.state
+     * @param options.acrValues
+     * @param options.scope
+     * @param options.redirectUri
+     * @param options.preferPopup
+     * @param options.loginHint
+     * @param options.tag
+     * @param options.teaser
+     * @param options.maxAge
+     * @param options.locale
+     * @param options.oneStepLogin
+     * @param options.prompt
+     * @param options.xDomainId
+     * @param options.xEnvironmentId
+     * @param options.originCampaign
+     * @fires Identity#loginRequested
+     * @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;
+    /**
+     * @summary Retrieve the sp_id (Varnish ID)
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @return - The sp_id string or null (if the server didn't return it)
+     */
+    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
+     * @fires Identity#logoutRequested
+     */
+    logout(redirectUri?: string): void;
+    /**
+     * Generates the link to the new login page that'll be used in the popup or redirect flow
+     * @param options
+     * @param options.state
+     * @param options.acrValues
+     * @param options.scope
+     * @param options.redirectUri
+     * @param options.loginHint
+     * @param options.tag
+     * @param options.teaser
+     * @param options.maxAge
+     * @param options.locale
+     * @param options.oneStepLogin
+     * @param options.prompt
+     * @param options.xDomainId
+     * @param options.xEnvironmentId
+     * @param options.originCampaign
+     * @return - The url
+     */
+    loginUrl({ state, acrValues, scope, redirectUri, loginHint, tag, teaser, maxAge, locale, oneStepLogin, prompt, xDomainId, xEnvironmentId, originCampaign, }: LoginOptions): string;
+    /**
+     * The url for logging the user out
+     * @param redirectUri
+     * @return url
+     */
+    logoutUrl(redirectUri?: string): string;
+    /**
+     * The account summary page url
+     * @param redirectUri
+     */
+    accountUrl(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,
+     * and store that info in localStorage. Widget will be display only if user is logged in to SSO.
+     *
+     * @param loginParams - the same as `options` param for login function. Login will be called on user
+     * continue action. `state` might be string or async function.
+     * @param options - additional configuration of Simplified Login Widget
+     * @fires Identity#simplifiedLoginOpened
+     * @fires Identity#simplifiedLoginCancelled
+     * @throws {SDKError} - If user context data is missing or the widget script cannot be loaded
+     * @return - will resolve to true if widget will be displayed
+     */
+    showSimplifiedLoginWidget(loginParams: SimplifiedLoginWidgetLoginOptions, options?: SimplifiedLoginWidgetOptions): Promise<boolean>;
+}
+export default Identity;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { Account } from './account.js';
+export { createAccountSdk, getAccountSdk } from './account-sdk.js';
+export * from './globals.js';
+export { default as SDKError } from './sdk-error.js';
+/** session response type guards */
+export { isConnectedSessionResponse, isConnectedSessionWithUserIdResponse, isSessionFailureResponse, isSessionSuccessResponse, } from './session-response.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';
+export type { ConnectedSessionResponse, ConnectedSessionWithUserIdResponse, RedirectSessionResponse, SessionFailureResponse, SessionResponse, SessionSuccessResponse, SessionUserId, } from './types/session.js';