@okta/spa-platform 0.6.0

package/dist/types/orchestrators/HostOrchestrator/index.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @module
+ * @mergeModuleWith TokenOrchestrators
+ */
+import { type TokenOrchestrator, type AcrValues, type JsonRecord, type TokenPrimitiveInit, Token } from '@okta/auth-foundation/core';
+import { HostOrchestrator as HostApp } from './Host.ts';
+import { SubAppOrchestrator } from './SubApp.ts';
+export declare namespace HostOrchestrator {
+    /**
+     * Receives and fulfills delegated {@link Platform.Token | Token} requests from {@link HostOrchestrator.SubApp} instances
+     *
+     * @group Host
+     */
+    abstract class Host<E extends HostEvents = HostEvents> extends HostApp<E> {
+    }
+    /**
+     * A {@link AuthFoundation!TokenOrchestrator | TokenOrchestrator} instance which delegates all {@link Platform.Token | Token}
+     * requests to a {@link HostOrchestrator.Host}
+     *
+     * @group SubApp
+     */
+    class SubApp<E extends SubAppEvents = SubAppEvents> extends SubAppOrchestrator<E> {
+    }
+    /**
+     * A utility class to adapt any {@link AuthFoundation!TokenOrchestrator | TokenOrchestrator} instance into a {@link HostOrchestrator.Host}
+     * @group ProxyHost
+     */
+    class ProxyHost<E extends HostEvents = HostEvents> extends HostOrchestrator.Host<E> {
+        protected readonly orchestrator: Exclude<TokenOrchestrator, HostOrchestrator.SubApp>;
+        constructor(name: string, orchestrator: Exclude<TokenOrchestrator, HostOrchestrator.SubApp>);
+        findToken(params?: TokenOrchestrator.AuthorizeParams): Promise<Token | ErrorResponse>;
+    }
+    /**
+     * @group Host
+     */
+    type HostOptions = {
+        allowedOrigins?: string[];
+    };
+    /**
+     * @group Host
+     */
+    type HostEvents = {
+        'duplicate_host': {
+            id: string;
+            duplicateId: string;
+        };
+        'login_prompt_required': Record<string, any>;
+        'request_received': {
+            request: RequestEvent[keyof RequestEvent];
+        };
+        'request_fulfilled': {
+            request: RequestEvent[keyof RequestEvent];
+            response: ResponseEvent[keyof ResponseEvent];
+        };
+    };
+    /**
+     * @group SubApp
+     */
+    type SubAppOptions = TokenOrchestrator.AuthorizeParams & {
+        targetOrigin?: string;
+    };
+    /**
+     * @group SubApp
+     */
+    type SubAppEvents = {
+        'no_host_found': void;
+    } & TokenOrchestrator.Events;
+    /**
+     * @group Types
+     */
+    type TokenRequestEventPayloads = {
+        'TOKEN': TokenRequest;
+        'AUTHORIZE': AuthorizeRequest;
+        'PROFILE': TokenRequest;
+    };
+    /**
+     * @group Types
+     * Payload for "host_activated" events.
+     * Sent once a {@link HostOrchestrator.Host} instantiates. Used to detect multiple hosts
+     */
+    type ActivatedEvent = {
+        eventName: 'ACTIVATED';
+        hostId: string;
+        data: undefined;
+    };
+    /**
+     * @group Types
+     */
+    type PingEvent = {
+        eventName: 'PING';
+        data: undefined;
+    };
+    /**
+     * @group Types
+     * Lose typing of the request event object structure. Provides slightly more type-safety than
+     * using `any` or `unknown` like most generic messaging APIs
+     */
+    type RequestEvent = ({
+        [K in keyof TokenRequestEventPayloads]: {
+            eventName: K;
+            data: TokenRequestEventPayloads[K];
+            requestId: string;
+            subAppId: string;
+        };
+    } & {
+        ACTIVATED: ActivatedEvent;
+        PING: PingEvent;
+    });
+    /**
+     * @group Types
+     */
+    type TokenRequest = {
+        issuer?: string;
+        clientId?: string;
+        scopes?: string[];
+        acrValues?: AcrValues;
+        maxAge?: number;
+    };
+    /**
+     * @group Types
+     */
+    type AuthorizeRequest = TokenRequest & {
+        url?: string;
+        method?: string;
+        nonce?: string;
+    };
+    /**
+     * @group Types
+     * Map of responses from a HostOrchestrator request event
+     */
+    type ResponseEvent = {
+        'TOKEN': TokenResponse;
+        'AUTHORIZE': AuthorizeResponse;
+        'PROFILE': ProfileResponse;
+        'PING': PingResponse;
+        'ACTIVATED': object;
+    };
+    /**
+     * @group Types
+     */
+    type ErrorResponse = {
+        error: string;
+    };
+    /**
+     * @group Types
+     */
+    type PingResponse = {
+        message: 'PONG';
+    };
+    /**
+     * @group Types
+     */
+    type TokenResponse = {
+        token: TokenPrimitiveInit;
+    } | ErrorResponse;
+    /**
+     * @group Types
+     */
+    type AuthorizeResponse = {
+        tokenType: string;
+        dpop?: string;
+        authorization: string;
+    } | ErrorResponse;
+    /**
+     * @group Types
+     */
+    type ProfileResponse = {
+        profile: JsonRecord;
+    } | ErrorResponse;
+}

package/dist/types/orchestrators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module TokenOrchestrators
+ */
+export * from './AuthorizationCodeFlowOrchestrator.ts';
+export * from './HostOrchestrator/index.ts';

package/dist/types/platform/OAuth2Client.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module
+ * @mergeModuleWith Platform
+ */
+import { Token, OAuth2Client as OAuth2ClientBase, OAuth2ErrorResponse } from '@okta/auth-foundation/core';
+/**
+ * Browser-specific implementation of {@link OAuth2Client}
+ *
+ * @group OAuth2Client
+ */
+export declare class OAuth2Client extends OAuth2ClientBase {
+    protected prepareRefreshRequest(token: Token, scopes?: string[]): Promise<Token | OAuth2ErrorResponse>;
+}

package/dist/types/platform/defaults.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformDependencies } from '@okta/auth-foundation/core';
+export declare const PlatformDefaults: PlatformDependencies;

package/dist/types/platform/dpop/authority.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+import { DPoPSigningAuthority } from '@okta/auth-foundation/core';
+export declare const DefaultSigningAuthority: DPoPSigningAuthority;

package/dist/types/platform/dpop/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+export * from './nonceCache.ts';

package/dist/types/platform/dpop/nonceCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+import type { DPoPNonceCache } from '@okta/auth-foundation/core';
+/**
+ * @internal
+ * Implementation of persistent cache; backed via `LocalStorage`
+ */
+export declare class PersistentCache implements DPoPNonceCache {
+    #private;
+    constructor(storageKey: string, clearOnParseError?: boolean);
+    getNonce(key: string): Promise<string | undefined>;
+    cacheNonce(key: string, nonce: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/platform/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module Platform
+ */
+export * from './OAuth2Client.ts';
+/**
+ * Clears all DPoP public / private key pairs from storage
+ *
+ * @remarks
+ * Recommended to be called when performing sign out
+ *
+ */
+export declare function clearDPoPKeyPairs(): Promise<void>;

package/dist/types/utils/IndexedDBStore.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+/**
+ * Lightweight wrapper around IndexedDB ObjectStore instances
+ *
+ * @internal
+ */
+export declare class IndexedDBStore<T> {
+    private readonly storeName;
+    private readonly dbName;
+    constructor(storeName: string);
+    private keyStore;
+    private invokeStoreMethod;
+    get(id: string): Promise<T | null>;
+    add(id: string, item: T): Promise<void>;
+    remove(id: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/utils/LocalBroadcastChannel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+import type { JsonRecord, BroadcastChannelLike } from '@okta/auth-foundation/core';
+export type LocalBroadcastChannelMessage<M = any> = {
+    name: string;
+    source: string;
+    message: M;
+};
+export type LocalBroadcastChannelMessageHandler<M extends JsonRecord = JsonRecord, R extends JsonRecord = M> = (event: {
+    data: M;
+}, reply?: (message: R) => any) => any;
+export type LocalBroadcastChannelOptions = {
+    targetOrigin?: string;
+    allowedOrigins?: string[];
+};
+/**
+ * @internal
+ *
+ * Based off of `BroadcastChannel`, but backed by `window.postMessage`
+ * Designed for situations when broadcasts should be limited to current window
+ *
+ * Supports cross-origin, but not cross-domain communication
+ */
+export declare class LocalBroadcastChannel<M extends JsonRecord = JsonRecord> implements BroadcastChannelLike<M> {
+    #private;
+    readonly name: string;
+    constructor(name: string, targetOrigin?: string);
+    constructor(name: string, options: LocalBroadcastChannelOptions);
+    close(): void;
+    private isTrustedMessage;
+    private isValidMessage;
+    get boundHandler(): ((event: MessageEvent<LocalBroadcastChannelMessage<M>>) => any) | null;
+    set boundHandler(handler: ((event: MessageEvent<LocalBroadcastChannelMessage<M>>) => any) | null);
+    get onmessage(): LocalBroadcastChannelMessageHandler<M> | null;
+    set onmessage(handler: LocalBroadcastChannelMessageHandler<M> | null);
+    postMessage(message: M): void;
+}

package/dist/types/utils/LocalStorageCache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+import { type Json, type JsonPrimitive, type Seconds } from '@okta/auth-foundation/core';
+/**
+ * @internal
+ * A `LocalStorage`-based cache, which holds items for a duration of time
+ * in attempt to avoid orphaned records in `LocalStorage`
+ */
+export declare class LocalStorageCache<T extends Json | JsonPrimitive = string> {
+    protected storageKey: string;
+    ttl: Seconds;
+    clearOnParseError: boolean;
+    constructor(storageKey: string, options?: Partial<LocalStorageCache.Options>);
+    static DefaultOptions: LocalStorageCache.Options;
+    protected getStore(): Record<string, {
+        item: T;
+        ts: number;
+    }>;
+    protected updateStore(store: any): void;
+    add(key: string, item: T): void;
+    get(key: string): T | null;
+    remove(key: string): void;
+    clear(): void;
+}
+/**
+ * @internal
+ */
+export declare namespace LocalStorageCache {
+    type Options = {
+        ttl: Seconds;
+        clearOnParseError: boolean;
+    };
+}

package/dist/types/utils/SynchronizedResult.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+export type SynchronizedResultOptions<T = any, R = any> = {
+    timeout: number;
+    lockFreedDelay: number;
+    retries: number;
+    seralizer?: (obj: T) => R;
+    deseralizer?: (input: R) => T;
+};
+/**
+ * Synchronizes the result of an `async` action between multiple subscribers
+ *
+ * `T` is return type of `task()`
+ * `R` is raw type used to transfer `task()` result between tabs
+ *
+ * @remarks
+ * Current implementation only works in browser environments
+ */
+export declare class SynchronizedResult<T, R = T> {
+    readonly name: string;
+    private task;
+    private channel;
+    private options;
+    constructor(name: string, task: () => Promise<T>, options?: Partial<SynchronizedResultOptions<T, R>>);
+    private onResultFromOtherTab;
+    private onLockFreedPlusDelay;
+    private onTimeout;
+    private whenLockIsTaken;
+    private whenLockIsGranted;
+    exec(overrides?: Partial<SynchronizedResultOptions<T, R>>): Promise<T>;
+    /**
+     * Closes the underlying BroadcastChannel, useful for testing environments to avoid open handles
+     *
+     * @see
+     * {@link https://jestjs.io/docs/cli#--detectopenhandles | jest --detectOpenHandles}
+     */
+    close(): void;
+}

package/dist/types/utils/UserAgent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+/** @internal */
+export declare function isFirefox(): boolean;

package/dist/types/utils/isModernBrowser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Utils
+ */
+/**
+ * Verifies the browser supports all features this library depends on
+ *
+ * @returns boolean
+ */
+export declare function isModernBrowser(): boolean;

package/package.json

@@ -0,0 +1 @@
+{"name":"@okta/spa-platform","version":"0.6.0","type":"module","main":"dist/esm/index.js","module":"dist/esm/index.js","types":"dist/types/index.d.ts","license":"Apache-2.0","files":["./LICENSE","./dist","*.md","package.json"],"exports":{".":{"types":"./dist/types/index.d.ts","import":"./dist/esm/index.js"},"./package.json":"./package.json"},"scripts":{"lint":"eslint --ext .js,.ts,.jsx .","build":"yarn build:esm && yarn build:types","build:watch":"yarn build:esm --watch & yarn build:types --watch","build:esm":"rollup -c","build:types":"tsc","test":"yarn test:unit","test:watch":"jest --watchAll","test:unit":"jest"},"dependencies":{},"peerDependencies":{"@okta/auth-foundation":"*","@okta/oauth2-flows":"*"},"peerDependenciesMeta":{"@okta/oauth2-flows":{"optional":true}},"devDependencies":{"@repo/eslint-config":"*","@repo/jest-helpers":"*","@repo/typescript-config":"*","@repo/rollup-config":"*","@okta/auth-foundation":"*","@okta/oauth2-flows":"*","eslint":"^8.56.0","jest":"^29.7.0","rollup":"^4.52.4","typescript":"^5.9.2"},"devEngines":{"runtime":{"name":"node","version":">=22.13.1","onFail":"warn"},"packageManager":{"name":"yarn","version":">=1.19.0","onFail":"warn"}},"okta":{"commitSha":"533d076fb5f59d4214751d8414be8f0f3adac2f5","fullVersion":"0.6.0-g533d076-g533d076"}}