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

package/dist/types/account.d.ts

@@ -0,0 +1,48 @@
+import { AccountBaseConfig, LogFunction } from './common';
+import { IdentityBeforeRedirectCallback, VarnishCookieOptions } from './identity';
+import { SessionResponse } from './session';
+/**
+ * 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;
+    /** Callback triggered before a session refresh redirect happens. */
+    callbackBeforeRedirect?: IdentityBeforeRedirectCallback;
+    /** Product or feature ids used by `hasAccess()` when no ids are passed to the method. */
+    defaultProductIds?: string[];
+    /** Optional Varnish cookie setup applied during Account initialization. */
+    varnish?: VarnishCookieOptions;
+};
+type LoginRequestedEventDetail = {
+    url: string;
+    method: 'popup' | 'default';
+};
+type LogoutRequestedEventDetail = {
+    url: string;
+};
+export type AccountEventMap = {
+    /** Emitted with the login URL and method when `login()` initiates a login flow. */
+    loginRequested: CustomEvent<LoginRequestedEventDetail>;
+    /** Emitted with the logout URL when `logout()` is called. */
+    logoutRequested: CustomEvent<LogoutRequestedEventDetail>;
+    /** Emitted when `hasSession()` detects a change in the stored session state. */
+    sessionUpdated: CustomEvent<SessionResponse>;
+    /** 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;
+/**
+ * Native event listener used by Account event subscriptions.
+ *
+ * Payload-bearing events are `CustomEvent` instances and expose their payload through `detail`.
+ *
+ * @group Events
+ */
+export type AccountEventListener<EventName extends AccountEventName = AccountEventName> = (event: AccountEventMap[EventName]) => void;
+export {};

package/dist/types/common.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Log callback used by the SDK for debug output.
+ * Receives a pre-formatted log line.
+ *
+ * @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;
+    /** Redirect uri. Example: "https://site.com" */
+    redirectUri: string;
+    /** Session Service domain. Example: "https://id.site.com" */
+    sessionDomain: string;
+    /** Schibsted account environment. Defaults to PRE. */
+    env?: AccountEnvironment;
+    /** Window object to use. Defaults to the global `window`. */
+    window?: Window;
+};

package/dist/types/identity.d.ts

@@ -0,0 +1,23 @@
+import { AccountBaseConfig, LogFunction } from './common';
+/**
+ * Callback invoked before the SDK performs a full-page session refresh redirect.
+ */
+export type IdentityBeforeRedirectCallback = () => void | Promise<void>;
+/**
+ * Options accepted by the {@link Identity} constructor.
+ */
+export type IdentityOptions = AccountBaseConfig & {
+    /** Receives debug log information. If not set, no logging will be done. */
+    log?: LogFunction;
+    /** Callback triggered before a session refresh redirect happens. */
+    callbackBeforeRedirect?: IdentityBeforeRedirectCallback;
+};
+/**
+ * Options for {@link Identity#enableVarnishCookie}.
+ */
+export type VarnishCookieOptions = {
+    /** Override number of seconds before the Varnish cookie expires. */
+    expiresIn?: number;
+    /** Override cookie domain. E.g. "vg.no" instead of "www.vg.no". */
+    domain?: string;
+};

package/dist/types/login.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Options accepted by {@link Account#login} and related login URL helpers.
+ *
+ * @group Login & Widget
+ */
+export type LoginOptions = {
+    /**
+     * An opaque value used by the client to maintain state between the request and callback.
+     * It's also recommended to prevent CSRF {@link https://tools.ietf.org/html/rfc6749#section-10.12}
+     */
+    state: string;
+    /**
+     * Authentication Context Class Reference values. If omitted, the default account flow is used.
+     * Supported values include `password`, `otp`, `sms`, `otp-email`, `eid`, `eid-no`, `eid-se`,
+     * `eid-fi`, and `eid-dk`. Values other than `otp-email` may be combined as a space-separated
+     * string. Verify the AMR (Authentication Methods References) claim in the ID token on your
+     * backend if you need to enforce a completed authentication method.
+     */
+    acrValues?: 'password' | 'otp' | 'sms' | 'eid-dk' | 'eid-no' | 'eid-se' | 'eid-fi' | 'eid' | 'otp-email' | (string & {});
+    /**
+     * The OAuth scopes for the tokens. This is a list of scopes, separated by space. If the list
+     * of scopes contains `openid`, the generated tokens includes the id token which can be useful
+     * for getting information about the user. Omitting scope is allowed, while `invalid_scope` is
+     * returned when the client asks for a scope you aren't allowed to request.
+     * {@link https://tools.ietf.org/html/rfc6749#section-3.3}
+     * Defaults to `openid`.
+     */
+    scope?: 'openid' | (string & {});
+    /**
+     * Redirect uri that will receive the code. Must exactly match a redirectUri from your client
+     * in self-service
+     */
+    redirectUri?: string;
+    /** Should we try to open a popup window? Defaults to `false`. */
+    preferPopup?: boolean;
+    /** user email or UUID hint */
+    loginHint?: string;
+    /** Pulse tag */
+    tag?: string;
+    /** Teaser slug. Teaser with given slug will be displayed in place of default teaser */
+    teaser?: string;
+    /**
+     * Specifies the allowable elapsed time in seconds since the last time the End-User was actively
+     * authenticated. If last authentication time is more than maxAge seconds in the past,
+     * re-authentication will be required. See the OpenID Connect spec section 3.1.2.1 for more
+     * information. Prefer a number of seconds; strings remain accepted for legacy callers.
+     */
+    maxAge?: number | string;
+    /**
+     * Optional parameter to overwrite client locale setting.
+     * New flows supports nb_NO, fi_FI, sv_SE, en_US
+     */
+    locale?: 'nb_NO' | 'fi_FI' | 'sv_SE' | 'en_US';
+    /** display username and password on one screen. Defaults to `false`. */
+    oneStepLogin?: boolean;
+    /**
+     * String that specifies whether the Authorization Server prompts the End-User for
+     * reauthentication or confirm account screen. Supported values: `select_account` or `login`.
+     * Defaults to `select_account`.
+     */
+    prompt?: 'select_account' | 'login';
+    /** Identifier for cross-domain tracking in Pulse */
+    xDomainId?: string;
+    /** Environment for cross-domain tracking in Pulse */
+    xEnvironmentId?: string;
+    /** Campaign identifier for tracking in Pulse */
+    originCampaign?: string;
+};
+/**
+ * Identical to {@link LoginOptions} except that `state` may also be a (possibly async) function;
+ * all other fields reuse the `LoginOptions` documentation.
+ *
+ * @group Login & Widget
+ */
+export type SimplifiedLoginWidgetLoginOptions = Omit<LoginOptions, 'state'> & {
+    /**
+     * An opaque value used by the client to maintain state between the request and callback.
+     * It's also recommended to prevent CSRF {@link https://tools.ietf.org/html/rfc6749#section-10.12}
+     */
+    state: string | (() => string | Promise<string>);
+};
+/**
+ * Minimal user information used by the simplified login widget flow.
+ *
+ * @group Login & Widget
+ */
+export type SimplifiedLoginData = {
+    /** Deprecated: User UUID used as `loginHint` for {@link Account#login}. */
+    identifier: string;
+    /** Human-readable user identifier */
+    display_text: string;
+    /** Client name */
+    client_name: string;
+    /** Provider id used by the simplified login widget when supplied by the backend. */
+    provider_id?: string;
+};
+/**
+ * Configuration options for {@link Account#showSimplifiedLoginWidget}.
+ *
+ * @group Login & Widget
+ */
+export type SimplifiedLoginWidgetOptions = {
+    /** expected encoding of simplified login widget. Could be utf-8 (default), iso-8859-1 or iso-8859-15 */
+    encoding?: string;
+    /**
+     * expected locale of simplified login widget. Should be provided in a short format like 'nb',
+     * 'sv'. If not set, a value from the env variable is used.
+     */
+    locale?: 'nb' | 'sv' | 'fi' | 'da' | 'en';
+};
+export type SimplifiedLoginWidgetInitialParams = {
+    displayText: string;
+    env: string;
+    clientName: string;
+    clientId: string;
+    providerId?: string;
+    locale?: SimplifiedLoginWidgetOptions['locale'];
+    windowWidth: () => number;
+    windowOnResize: (handler: () => void) => void;
+};
+export type SimplifiedLoginWidgetHandler = () => void | Promise<void>;
+export type OpenSimplifiedLoginWidget = (initialParams: SimplifiedLoginWidgetInitialParams, loginHandler: SimplifiedLoginWidgetHandler, loginNotYouHandler: SimplifiedLoginWidgetHandler, initHandler: SimplifiedLoginWidgetHandler, cancelLoginHandler: SimplifiedLoginWidgetHandler) => unknown;
+export declare const hasOpenSimplifiedLoginWidget: (targetWindow: Window) => targetWindow is Window & {
+    openSimplifiedLoginWidget: OpenSimplifiedLoginWidget;
+};

package/dist/types/monetization.d.ts

@@ -0,0 +1,26 @@
+import { AccountBaseConfig } from './common';
+import { SessionUserId } from './session';
+/**
+ * Result returned by the Session Service `/hasAccess` endpoint, describing whether the user
+ * is entitled to a requested set of products/features.
+ *
+ * @group Access Checks
+ */
+export interface HasAccessResult {
+    /** Whether the user is entitled to at least one of the requested products/features. */
+    entitled: boolean;
+    /** How long this result stays valid, in seconds, before the cache entry expires. */
+    ttl: number;
+    /** Feature ids the user is allowed to access. */
+    allowedFeatures: string[];
+    /** User id the access result belongs to. */
+    userId: SessionUserId;
+    /** Globally unique user id the access result belongs to. */
+    uuid: string;
+    /** Signed response payload. */
+    sig: string;
+}
+/**
+ * Options accepted by the {@link Monetization} constructor.
+ */
+export type MonetizationOptions = Pick<AccountBaseConfig, 'clientId' | 'env' | 'window'> & Partial<Pick<AccountBaseConfig, 'redirectUri' | 'sessionDomain'>>;

package/dist/types/session.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Numeric Schibsted Account user id.
+ *
+ * @group Session
+ */
+export type SessionUserId = number;
+/**
+ * Successful response returned from {@link Account#hasSession}.
+ *
+ * `result` means the has-session call itself succeeded. `result: true` means the user is
+ * connected to the merchant; `result: false` means a session may exist, but the user is not
+ * connected to this client.
+ *
+ * @group Session
+ */
+export type SessionSuccessResponse = {
+    /** Response status code. Example: 200. */
+    code?: number;
+    /** Response type. Example: 'OK'. */
+    type?: string;
+    /** Human-readable response description. Example: 'OK'. */
+    description?: string;
+    /**
+     * Is the user connected to the merchant? This means the merchant id is in the list of
+     * merchants connected to this user.
+     */
+    result: boolean;
+    /** Connection status string. Deprecated; use `Account.isConnected()`. Example: 'connected'. */
+    userStatus?: string;
+    /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+    baseDomain?: string;
+    /** Legacy session id. Obsolete. Example: '58eca10fdbb9f6df72c3368f'. */
+    id?: string;
+    /** A numeric user id which is unique per realm (country). Example: 37162 */
+    userId?: SessionUserId;
+    /** Globally unique user id. Example: 'b3b23aa7-34f2-5d02-a10e-5a3455c6ab2c' */
+    uuid?: string;
+    /** Session token used for the `SP_ID` cookie. Example: 'eyJjbGllbnRfaWQ...'. */
+    sp_id?: string;
+    /** Session response TTL in seconds. Example: 300. */
+    expiresIn?: number;
+    /** Server time as a Unix timestamp in seconds. Example: 1506285759. */
+    serverTime?: number;
+    /**
+     * Example: 'NCdzXaz4ZRb7...' The sig parameter is a concatenation of an HMAC SHA-256
+     * signature string, a dot (.) and a base64url encoded JSON object (session).
+     * {@link http://techdocs.spid.no/sdks/js/response-signature-and-validation/}
+     */
+    sig?: string;
+    /** User display name. Example: 'batman'. */
+    displayName?: string;
+    /** User given name. Example: 'Bruce'. */
+    givenName?: string;
+    /** User family name. Example: 'Wayne'. */
+    familyName?: string;
+    /** User gender value. Example: 'male', 'female', 'undisclosed'. */
+    gender?: string;
+    /** User profile photo URL. Example: 'http://www.srv.com/some/picture.jpg' . */
+    photo?: string;
+    /** Whether tracking is enabled for this session. Example: true. */
+    tracking?: boolean;
+    /** Whether the client agreement is accepted. Example: true. */
+    clientAgreementAccepted?: boolean;
+    /** Whether the default agreement is accepted. Example: true. */
+    defaultAgreementAccepted?: boolean;
+    /** Pairwise user id for this client. Example: 'b2a23caa...'. */
+    pairId?: string;
+    /** User SDRN. Example: 'sdrn:spid.no:user:12345'. */
+    sdrn?: string;
+};
+/**
+ * Successful has-session response for a user connected to the merchant.
+ *
+ * @group Session
+ */
+export type ConnectedSessionResponse = SessionSuccessResponse & {
+    result: true;
+};
+/**
+ * Connected session response that also carries a usable user id.
+ *
+ * @group Session
+ */
+export type ConnectedSessionWithUserIdResponse = ConnectedSessionResponse & {
+    userId: SessionUserId;
+};
+/**
+ * Failure payload returned by Session Service.
+ *
+ * API and network failures usually reject with {@link SDKError}; this shape represents a failure
+ * payload when one is returned by Session Service and reaches the has-session flow.
+ *
+ * @group Session
+ */
+export type SessionFailureResponse = {
+    /** Failure payload returned by Session Service. Usually an object, but tests also pass strings. */
+    error: string | number | boolean | object;
+    response?: {
+        /** Response status code. Example: 404. */
+        code: number;
+        /** Response type. Example: 'NOT_FOUND'. */
+        type: string;
+        /** Human-readable response description. Example: 'No session found'. */
+        description: string;
+        /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+        baseDomain?: string;
+        /** Time span in milliseconds. Example: 30 * 60 * 1000 (for 30 minutes) */
+        expiresIn?: number;
+        result?: boolean;
+        /** Server time in seconds since the Unix Epoch. Example: 1506287788 */
+        serverTime?: number;
+        [key: string]: string | number | boolean | object | null | undefined;
+    };
+};
+/**
+ * Object response that does not match one of the SDK-known has-session shapes.
+ *
+ * This intentionally includes `{}`. Historically `hasSession()` could resolve an empty object or
+ * other object payloads that callers inspected themselves, so the SDK preserves those responses.
+ *
+ * @group Session
+ */
+export type UnrecognizedSessionResponse = object;
+/**
+ * Redirect URL returned by `hasSession()` when Session Service needs a full-page session refresh.
+ *
+ * @group Session
+ */
+export type RedirectSessionResponse = string;
+export type SessionObjectResponse = SessionSuccessResponse | SessionFailureResponse | UnrecognizedSessionResponse;
+export type RedirectSessionPayload = {
+    redirectURL: string;
+};
+/**
+ * Internal shape returned by `normalizeSessionResponse()` before `hasSession()` post-processing.
+ *
+ * It includes regular Session Service object responses and redirect responses used for full-page
+ * session refresh.
+ */
+export type NormalizedSessionPayload = SessionObjectResponse | RedirectSessionPayload;
+/**
+ * Public response union returned from {@link Account#hasSession}.
+ *
+ * @group Session
+ */
+export type SessionResponse = SessionSuccessResponse | SessionFailureResponse | UnrecognizedSessionResponse | RedirectSessionResponse;

package/dist/url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A simple utility function that allows looking up URLs from a dictionary
+ * @param url - A url like http://example.com, or a key used for lookup
+ * @param urlMap - A map of URLs like `{ DEV: 'http://dev.example.com' }`
+ * @returns The resolved URL: the mapped value when `url` is a known key, otherwise `url` itself
+ * @throws {SDKError} - If the url is not a string or is an empty string
+ */
+export declare function urlMapper(url: string, urlMap: Record<string, string>): string;

package/dist/validate.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A utility function that throws an SDKError if an assertion fails. It's mostly useful for
+ * validating function inputs.
+ *
+ * Narrows `condition` for the rest of the enclosing scope (TypeScript assertion signature).
+ * @param condition - The condition that we're asserting
+ * @param message - The error message
+ * @throws {SDKError} - If the condition is falsy it throws the appropriate error
+ */
+export declare function assert(condition: boolean, message?: string): asserts condition;
+/**
+ * Checks if a value is a string or not
+ * @param value - The value to check
+ */
+export declare function isStr(value: unknown): value is string;
+/**
+ * Checks if a value is a non-empty string
+ * @param value - The value to check
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * checks if a given value is an object (but not null)
+ * @param value - The value to check
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a given value is an object with at least one own key
+ * @param value - The value to check
+ */
+export declare function isNonEmptyObj(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a given string is a valid URL
+ * @param value - The string to be tested
+ * @param mandatoryFields - A list of mandatory fields that should exist in the parsed
+ * `URL` object
+ */
+export declare function isUrl(value: string, ...mandatoryFields: (keyof URL)[]): boolean;
+/**
+ * Checks if a given value is a function
+ * @param value - The value to check
+ */
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Checks if a string matches any of the strings in a set of possibilities
+ * @param value
+ * @param possibilities - An array of strings that'll be used to check the string
+ * inclusion. Note that for performance reasons, we don't validate this parameter.
+ * @param caseSensitive - Should the check be case sensitive
+ */
+export declare function isStrIn(value: string, possibilities: string[], caseSensitive?: boolean): boolean;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+declare const version = "6.0.0-alpha.10";
+export default version;

package/package.json

@@ -1,66 +1,48 @@
 {
   "name": "@schibsted/account-sdk-browser",
-  "version": "5.2.7",
+  "version": "6.0.0-alpha.10",
   "description": "Schibsted account SDK for browsers",
-  "main": "index.js",
+  "main": "dist/index.js",
   "type": "module",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "scripts": {
-    "build": "./build.sh",
-    "clean": "rimraf .cache coverage dist docs",
-    "docs": "rimraf docs && jsdoc -c ./jsdoc.conf.json --verbose",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test": "jest",
-    "cover": "jest --coverage"
+    "clean": "rimraf .cache coverage docs dist && npm run clean:legacy",
+    "clean:legacy": "rimraf es5",
+    "docs:build": "typedoc",
+    "docs:watch": "typedoc --watch",
+    "docs:open": "node scripts/open-docs.mjs",
+    "lint": "biome check",
+    "lint:fix": "biome check --fix",
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "precover": "npm run build",
+    "cover": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
   },
   "author": "",
   "license": "MIT",
-  "dependencies": {
-    "tiny-emitter": "^2.1.0"
-  },
   "devDependencies": {
-    "@babel/core": "^7.11.4",
-    "@babel/preset-env": "^7.23.2",
-    "babel-loader": "^8.1.0",
-    "core-js": "^3.6.5",
-    "docdash": "git+https://github.com/torarvid/docdash.git#v0.5.0",
-    "eslint": "^6.8.0",
-    "eslint-plugin-import": "^2.20.2",
-    "jest": "^26.4.2",
-    "jest-junit": "^10.0.0",
-    "jsdoc": "^3.6.11",
-    "node-fetch": "^2.6.0",
-    "regenerator-runtime": "^0.13.7",
-    "webpack": "^4.44.1",
-    "webpack-cli": "^3.3.12",
-    "whatwg-url": "^8.0.0"
+    "@biomejs/biome": "2.4.15",
+    "@vitest/coverage-v8": "^4.1.7",
+    "jsdom": "^29.1.1",
+    "open": "^11.0.0",
+    "rimraf": "^6.1.3",
+    "typedoc": "^0.28.19",
+    "typedoc-plugin-mdn-links": "^5.1.1",
+    "typescript": "^6.0.3",
+    "unplugin-dts": "^1.0.1",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
   },
   "repository": {
     "type": "git",
     "url": "git://schibsted.ghe.com/user-identity/account-sdk-browser.git"
-  },
-  "babel": {
-    "presets": [
-      [
-        "@babel/preset-env",
-        {
-          "useBuiltIns": "usage",
-          "corejs": 3,
-          "targets": {
-            "browsers": [
-              "> 1%",
-              "last 10 chrome major versions",
-              "last 10 firefox major versions",
-              "last 10 opera major versions",
-              "last 2 safari major versions",
-              "last 2 ios major versions",
-              "last 2 ie major versions",
-              "last 5 edge major versions"
-            ]
-          }
-        }
-      ]
-    ]
-  },
-  "typings": "index.d.ts"
+  }
 }

package/src/account-sdk.ts

@@ -0,0 +1,92 @@
+/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
+ * See LICENSE.md in the project root.
+ */
+
+import { Account } from './account.js';
+import { resolveBrowserWindow } from './resolve-browser-window.js';
+import type { AccountConfig } from './types/account.js';
+
+const ACCOUNT_READY_EVENT = 'schAccount:ready';
+const GET_ACCOUNT_SDK_TIMEOUT_MS = 4000;
+
+let pendingAccountPromise: Promise<Account> | undefined;
+
+const createUnavailableError = (): Error =>
+    new Error('Schibsted Account SDK is not available in this browser context');
+
+const createTimeoutError = (): Error =>
+    new Error(`Schibsted Account SDK was not initialized within ${GET_ACCOUNT_SDK_TIMEOUT_MS} ms`);
+
+/**
+ * Creates and registers the single Account SDK instance for the current browser window.
+ *
+ * The created instance is stored on `window.schAccount` and the SDK emits
+ * `schAccount:ready` with the instance in `event.detail.instance`.
+ *
+ * @param config - Client, redirect, environment, and Session Service configuration.
+ * @throws {SDKError} If the SDK cannot run in the current browser context, if an Account instance
+ * has already been initialized, or if configuration validation fails.
+ * @group Core API
+ */
+export function createAccountSdk(config: AccountConfig): Account {
+    return new Account(config);
+}
+
+/**
+ * Resolves the Account SDK instance registered by `createAccountSdk()`.
+ *
+ * If the instance already exists, the promise resolves immediately. Otherwise it waits for
+ * `schAccount:ready` and rejects if initialization does not happen within the SDK timeout.
+ * @group Core API
+ */
+export function getAccountSdk(): Promise<Account> {
+    const browserWindow = resolveBrowserWindow();
+
+    if (!browserWindow) {
+        const error = createUnavailableError();
+        console.error(error.message);
+        return Promise.reject(error);
+    }
+
+    if (browserWindow.schAccount) {
+        return Promise.resolve(browserWindow.schAccount);
+    }
+
+    if (pendingAccountPromise) {
+        return pendingAccountPromise;
+    }
+
+    pendingAccountPromise = new Promise<Account>((resolve, reject) => {
+        let timeoutId: number | undefined;
+
+        const cleanup = () => {
+            browserWindow.removeEventListener(ACCOUNT_READY_EVENT, resolveRegisteredAccount);
+            if (timeoutId !== undefined) {
+                browserWindow.clearTimeout(timeoutId);
+            }
+            pendingAccountPromise = undefined;
+        };
+
+        const resolveRegisteredAccount = () => {
+            const account = browserWindow.schAccount;
+            if (!account) {
+                return;
+            }
+
+            cleanup();
+            resolve(account);
+        };
+
+        browserWindow.addEventListener(ACCOUNT_READY_EVENT, resolveRegisteredAccount);
+        timeoutId = browserWindow.setTimeout(() => {
+            const error = createTimeoutError();
+            console.error(error.message);
+            cleanup();
+            reject(error);
+        }, GET_ACCOUNT_SDK_TIMEOUT_MS);
+
+        resolveRegisteredAccount();
+    });
+
+    return pendingAccountPromise;
+}