@arena-im/react-sdk-auth 1.9.0-wid-961.4

package/config/index.d.ts

@@ -0,0 +1,11 @@
+export interface Config {
+    profileServiceUrl: string;
+    identityServiceUrl: string;
+    refreshTokenApiKey: string;
+    authIframeUrl: string;
+    environment: 'development' | 'production';
+    debug: boolean;
+}
+export type Environment = 'development' | 'production';
+export declare const getConfig: (environment: Environment) => Config;
+//# sourceMappingURL=index.d.ts.map

package/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,aAAa,GAAG,YAAY,CAAC;IAC1C,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS,GAAI,aAAa,WAAW,KAAG,MAyBpD,CAAC"}

package/context/anonymous-token-provider.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function AnonymousTokenProvider({ children, }: {
+    children: React.ReactNode;
+}): React.ReactNode;
+//# sourceMappingURL=anonymous-token-provider.d.ts.map

package/context/anonymous-token-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymous-token-provider.d.ts","sourceRoot":"","sources":["../../src/context/anonymous-token-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAKzC,wBAAgB,sBAAsB,CAAC,EACrC,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,mBAoBA"}

package/context/auth-dialog-provider.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { UserProps } from '../services/auth/types';
+import { TrackOptions } from '../types/analytics';
+interface AuthDialogContextType {
+    isOpen: boolean;
+    appName: string | undefined;
+    appDescription: string | undefined;
+    trackOptions: TrackOptions | undefined;
+    onAuthCompleted: ((user: UserProps) => void) | undefined;
+    openDialog: (options: OpenDialogOptions) => void;
+    closeDialog: () => void;
+    onOpenChange: (open: boolean) => void;
+}
+type OpenDialogOptions = {
+    trackOptions: TrackOptions;
+    appName?: string;
+    appDescription?: string;
+    onAuthCompleted?: () => (user: UserProps) => void;
+};
+export declare const AuthDialogProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useAuthDialog: () => AuthDialogContextType;
+export {};
+//# sourceMappingURL=auth-dialog-provider.d.ts.map

package/context/auth-dialog-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-dialog-provider.d.ts","sourceRoot":"","sources":["../../src/context/auth-dialog-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAuC,SAAS,EAAE,MAAM,OAAO,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,UAAU,qBAAqB;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;IACvC,eAAe,EAAE,CAAC,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACzD,UAAU,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACjD,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC;AAMD,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CACnD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,4CA4CvE,CAAC;AAEF,eAAO,MAAM,aAAa,6BAMzB,CAAC"}

package/context/config-provider.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { Environment, Config } from '../config';
+interface ConfigContextType {
+    config: Config;
+    environment: Environment;
+}
+interface ConfigProviderProps {
+    children: ReactNode;
+    environment?: Environment;
+}
+export declare const ConfigProvider: ({ children, environment, }: ConfigProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useConfig: () => ConfigContextType;
+export {};
+//# sourceMappingURL=config-provider.d.ts.map

package/context/config-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-provider.d.ts","sourceRoot":"","sources":["../../src/context/config-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAa,WAAW,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE3D,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;CAC1B;AAID,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc,GAAI,4BAG5B,mBAAmB,4CAQrB,CAAC;AAEF,eAAO,MAAM,SAAS,yBAMrB,CAAC"}

package/context/index.d.ts

@@ -0,0 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
+export declare function AuthProvider({ children, queryClient, environment, }: {
+    children: React.ReactNode;
+    queryClient?: QueryClient;
+    environment?: 'production' | 'development';
+}): import("react/jsx-runtime").JSX.Element;
+export { useAuthDialog } from './auth-dialog-provider';
+//# sourceMappingURL=index.d.ts.map

package/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/context/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAuB,MAAM,uBAAuB,CAAC;AAMzE,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,WAAW,EACX,WAAW,GACZ,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,YAAY,GAAG,aAAa,CAAC;CAC5C,2CAiBA;AAED,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC"}

package/context/user-provider.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function UserProvider({ children }: {
+    children: React.ReactNode;
+}): React.ReactNode;
+//# sourceMappingURL=user-provider.d.ts.map

package/context/user-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-provider.d.ts","sourceRoot":"","sources":["../../src/context/user-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiC,MAAM,OAAO,CAAC;AAMtD,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,mBAyBvE"}

package/dialog/index.d.ts

@@ -0,0 +1,2 @@
+export default function AuthDialog(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

package/dialog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dialog/index.tsx"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,UAAU,UAAU,mDAoFjC"}

package/hooks/use-token-event-listener.d.ts

@@ -0,0 +1,4 @@
+export declare function useTokenEventListener(): {
+    eventSource: string;
+};
+//# sourceMappingURL=use-token-event-listener.d.ts.map

package/hooks/use-token-event-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-token-event-listener.d.ts","sourceRoot":"","sources":["../../src/hooks/use-token-event-listener.ts"],"names":[],"mappings":"AAcA,wBAAgB,qBAAqB;;EAuGpC"}

package/hooks/use-tokens.d.ts

@@ -0,0 +1,19 @@
+export declare function useTokens(): {
+    getToken: (type: import("..").TokenType) => string | null;
+    getMostPrivilegedToken: (options?: Array<import("..").TokenType>) => {
+        type: import("..").TokenType;
+        idToken: string;
+    } | null;
+    getRefreshToken: (type: import("..").TokenType) => string | null;
+    updatePublicTokens: (idToken: string, refreshToken: string) => void;
+    updateAnonymousToken: (idToken: string) => void;
+    updateGuestTokens: (idToken: string) => void;
+    updateCustomToken: (idToken: string) => void;
+    clearTokens: () => void;
+    clearPublicTokens: () => void;
+    clearCustomTokens: () => void;
+};
+export declare function useToken(type: 'anonymous' | 'guest' | 'public' | 'custom'): import("..").TokenPair;
+export declare function useTokenValue(type: 'anonymous' | 'guest' | 'public' | 'custom'): string | null;
+export declare function useRefreshToken(type: 'anonymous' | 'guest' | 'public'): string | null | undefined;
+//# sourceMappingURL=use-tokens.d.ts.map

package/hooks/use-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tokens.d.ts","sourceRoot":"","sources":["../../src/hooks/use-tokens.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS;;;;;;;kCAsBS,MAAM,gBAAgB,MAAM;oCAE1B,MAAM;iCAET,MAAM;iCAEN,MAAM;;;;EAMtC;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,0BAEzE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,iBAGlD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,QAAQ,6BAErE"}

package/hooks/use-track.d.ts

@@ -0,0 +1,3 @@
+import { AnalyticsEvent, TrackOptions } from '../types/analytics';
+export declare function useTrack(trackOptions?: TrackOptions): (event: AnalyticsEvent, userId?: string, properties?: Record<string, string | null>) => void;
+//# sourceMappingURL=use-track.d.ts.map

package/hooks/use-track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-track.d.ts","sourceRoot":"","sources":["../../src/hooks/use-track.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElE,wBAAgB,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,WAGvC,cAAc,WACZ,MAAM,eACF,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,UA2B/C"}

package/hooks/use-user.d.ts

@@ -0,0 +1,25 @@
+export declare function useUser(): import("../services/auth/types").UserProps | null;
+export declare function usePublicProfile(): import("../services/profile/types").PublicProfile | null;
+export declare function useRefreshedTokenLoaded(): boolean;
+export declare function useUserActions(): {
+    setUser: (user: import("../services/auth/types").UserProps | null) => void;
+    setPublicProfile: (publicProfile: import("../services/profile/types").PublicProfile | null) => void;
+    logout: () => void;
+    refreshPublicTokens: (config: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    setUserByTokenId: (idToken: string) => void;
+    loadStoredUser: (config?: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    ssoV2Exchange: (ssoSourceID: string, jwt: string, env?: import("../config").Environment) => Promise<import("../services/auth/types").SsoV2ExchangeResponse>;
+};
+export declare function useUpdateProfile(): {
+    updatePublicProfile: (params: Omit<import("../services/profile/types").PublicProfile, "metadata">) => Promise<void>;
+};
+export declare function useUserWithProfile(): {
+    user: import("../services/auth/types").UserProps | null;
+    publicProfile: import("../services/profile/types").PublicProfile | null;
+    refreshedTokenLoaded: boolean;
+};
+//# sourceMappingURL=use-user.d.ts.map

package/hooks/use-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-user.d.ts","sourceRoot":"","sources":["../../src/hooks/use-user.ts"],"names":[],"mappings":"AAGA,wBAAgB,OAAO,sDAEtB;AAED,wBAAgB,gBAAgB,6DAE/B;AAED,wBAAgB,uBAAuB,YAEtC;AAED,wBAAgB,cAAc;;;;;;;;;;;;EAmB7B;AAED,wBAAgB,gBAAgB;;EAK/B;AAED,wBAAgB,kBAAkB;;;;EAYjC"}

package/index.d.ts

@@ -0,0 +1,249 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { QueryClient } from '@tanstack/react-query';
+import * as zustand from 'zustand';
+
+interface UserProps {
+    uid: string;
+    email: string;
+    displayName: string;
+    photoURL?: string;
+    handle?: string;
+}
+interface SsoV2ExchangeResponse {
+    token: string;
+}
+
+type Nullable<T> = T | null;
+declare enum AnalyticsWidgetType {
+    AvatarProfile = "avatar-profile",
+    AvatarChat = "avatar-chat",
+    Comments = "comments",
+    GlobalProfile = "global-profile",
+    GroupChat = "group-chat",
+    Polls = "polls",
+    UniversalSnippet = "universal-snippet"
+}
+type TrackOptions = {
+    widgetId: string | null;
+    widgetType: AnalyticsWidgetType;
+    siteId: string;
+    rsWriteKey: string;
+    rsDataPlaneUrl: string;
+    trigger: string;
+};
+declare enum AnalyticsEvent {
+    AuthenticationCompleted = "Authentication Completed",
+    AuthenticationStarted = "Authentication Started",
+    AuthenticationViewed = "Authentication Viewed"
+}
+type TrackProps = Nullable<Record<string, unknown>>;
+interface IdentityProps {
+    anonymousId?: string;
+    userId?: string;
+}
+interface RudderContext {
+    channel: 'web';
+    anonymousId?: string;
+    locale?: string;
+    userAgent?: string;
+    timezone?: string;
+    os?: {
+        name: string;
+        version?: string;
+    };
+    page?: {
+        path?: string;
+        referrer?: string;
+        referring_domain?: string;
+        search?: string;
+        title?: string;
+        url?: string;
+        initial_referrer?: string;
+        initial_referring_domain?: string;
+    };
+    screen?: {
+        density?: number;
+        height?: number;
+        width?: number;
+        innerHeight?: number;
+        innerWidth?: number;
+    };
+    campaign?: Record<string, string>;
+}
+
+interface AuthDialogContextType {
+    isOpen: boolean;
+    appName: string | undefined;
+    appDescription: string | undefined;
+    trackOptions: TrackOptions | undefined;
+    onAuthCompleted: ((user: UserProps) => void) | undefined;
+    openDialog: (options: OpenDialogOptions) => void;
+    closeDialog: () => void;
+    onOpenChange: (open: boolean) => void;
+}
+type OpenDialogOptions = {
+    trackOptions: TrackOptions;
+    appName?: string;
+    appDescription?: string;
+    onAuthCompleted?: () => (user: UserProps) => void;
+};
+declare const useAuthDialog: () => AuthDialogContextType;
+
+declare function AuthProvider({ children, queryClient, environment, }: {
+    children: React.ReactNode;
+    queryClient?: QueryClient;
+    environment?: 'production' | 'development';
+}): react_jsx_runtime.JSX.Element;
+
+declare enum TokenType {
+    ANONYMOUS = "anonymous",
+    GUEST = "guest",
+    PUBLIC = "public",
+    CUSTOM = "custom"
+}
+interface TokenPair {
+    idToken: string | null;
+    refreshToken?: string | null;
+}
+type TokensMap = Record<TokenType, TokenPair>;
+declare enum AuthCookie {
+    PUBLIC_ID_TOKEN = "arena-auth-public-id-token",
+    PUBLIC_REFRESH_TOKEN = "arena-auth-public-refresh-token",
+    ANONYMOUS_ID_TOKEN = "arena-auth-anonymous-id-token",
+    GUEST_ID_TOKEN = "arena-auth-guest-id-token",
+    CUSTOM_ID_TOKEN = "arena-auth-custom-id-token",
+    CUSTOM_USER = "arena-auth-custom-user"
+}
+
+interface TokenStore {
+    tokens: TokensMap;
+    getToken: (type: TokenType) => string | null;
+    getMostPrivilegedToken: (options?: Array<TokenType>) => {
+        type: TokenType;
+        idToken: string;
+    } | null;
+    getRefreshToken: (type: TokenType) => string | null;
+    updatePublicTokens: (idToken: string, refreshToken: string, source?: string) => void;
+    updateAnonymousToken: (idToken: string, source?: string) => void;
+    updateGuestTokens: (idToken: string, source?: string) => void;
+    updateCustomToken: (idToken: string, source?: string) => void;
+    clearTokens: (source?: string) => void;
+    clearPublicTokens: (source?: string) => void;
+    clearAnonymousTokens: (source?: string) => void;
+    clearGuestTokens: (source?: string) => void;
+    clearCustomTokens: (source?: string) => void;
+    silentUpdatePublicTokens: (idToken: string, refreshToken: string) => void;
+    silentUpdateAnonymousToken: (idToken: string) => void;
+    silentUpdateGuestTokens: (idToken: string) => void;
+    silentUpdateCustomToken: (idToken: string) => void;
+    silentClearPublicTokens: () => void;
+    silentClearAnonymousTokens: () => void;
+    silentClearGuestTokens: () => void;
+    silentClearCustomTokens: () => void;
+}
+declare const useTokenStore: zustand.UseBoundStore<Omit<zustand.StoreApi<TokenStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: TokenStore, previousSelectedState: TokenStore) => void): () => void;
+        <U>(selector: (state: TokenStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+
+interface PublicProfile {
+    displayName?: string;
+    handle?: string;
+    bio?: string;
+    metadata?: {
+        commentCountBySite?: {
+            [siteId: string]: number;
+        };
+        commentReactionCountBySite?: {
+            [siteId: string]: number;
+        };
+        overallCommentCount?: number;
+        overallCommentReactionCount?: number;
+    };
+    photoURL?: string;
+}
+
+type Environment = 'development' | 'production';
+
+interface UserStore {
+    user: UserProps | null;
+    publicProfile: PublicProfile | null;
+    refreshedTokenLoaded: boolean;
+    setUser: (user: UserProps | null) => void;
+    setPublicProfile: (publicProfile: PublicProfile | null) => void;
+    logout: () => void;
+    refreshPublicTokens: (config: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    setUserByTokenId: (idToken: string) => void;
+    loadStoredUser: (config?: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    ssoV2Exchange: (ssoSourceID: string, jwt: string, env?: Environment) => Promise<SsoV2ExchangeResponse>;
+}
+declare const useUserStore: zustand.UseBoundStore<Omit<zustand.StoreApi<UserStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: UserStore, previousSelectedState: UserStore) => void): () => void;
+        <U>(selector: (state: UserStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+
+declare function useTokens(): {
+    getToken: (type: TokenType) => string | null;
+    getMostPrivilegedToken: (options?: Array<TokenType>) => {
+        type: TokenType;
+        idToken: string;
+    } | null;
+    getRefreshToken: (type: TokenType) => string | null;
+    updatePublicTokens: (idToken: string, refreshToken: string) => void;
+    updateAnonymousToken: (idToken: string) => void;
+    updateGuestTokens: (idToken: string) => void;
+    updateCustomToken: (idToken: string) => void;
+    clearTokens: () => void;
+    clearPublicTokens: () => void;
+    clearCustomTokens: () => void;
+};
+declare function useToken(type: 'anonymous' | 'guest' | 'public' | 'custom'): TokenPair;
+declare function useTokenValue(type: 'anonymous' | 'guest' | 'public' | 'custom'): string | null;
+declare function useRefreshToken(type: 'anonymous' | 'guest' | 'public'): string | null | undefined;
+
+declare function useUser(): UserProps | null;
+declare function usePublicProfile(): PublicProfile | null;
+declare function useRefreshedTokenLoaded(): boolean;
+declare function useUserActions(): {
+    setUser: (user: UserProps | null) => void;
+    setPublicProfile: (publicProfile: PublicProfile | null) => void;
+    logout: () => void;
+    refreshPublicTokens: (config: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    setUserByTokenId: (idToken: string) => void;
+    loadStoredUser: (config?: {
+        refreshTokenApiKey: string;
+    }) => Promise<void>;
+    ssoV2Exchange: (ssoSourceID: string, jwt: string, env?: Environment) => Promise<SsoV2ExchangeResponse>;
+};
+declare function useUpdateProfile(): {
+    updatePublicProfile: (params: Omit<PublicProfile, "metadata">) => Promise<void>;
+};
+declare function useUserWithProfile(): {
+    user: UserProps | null;
+    publicProfile: PublicProfile | null;
+    refreshedTokenLoaded: boolean;
+};
+
+declare function useTokenEventListener(): {
+    eventSource: string;
+};
+
+export { AnalyticsEvent, AnalyticsWidgetType, AuthCookie, AuthProvider, TokenType, useAuthDialog, usePublicProfile, useRefreshToken, useRefreshedTokenLoaded, useToken, useTokenEventListener, useTokenStore, useTokenValue, useTokens, useUpdateProfile, useUser, useUserActions, useUserStore, useUserWithProfile };
+export type { IdentityProps, RudderContext, TokenPair, TokensMap, TrackOptions, TrackProps };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","sources":["../src/services/auth/types.ts","../src/types/analytics.ts","../src/context/auth-dialog-provider.tsx","../src/context/index.tsx","../src/types/token.ts","../src/stores/token-store.ts","../src/services/profile/types.ts","../src/config/index.ts","../src/stores/user-store.ts","../src/hooks/use-tokens.ts","../src/hooks/use-user.ts","../src/hooks/use-token-event-listener.ts"],"sourcesContent":["export interface ExchangeTokensResponse {\n  access_token: string;\n  expiresIn: number;\n}\n\nexport interface UserProps {\n  uid: string;\n  email: string;\n  displayName: string;\n  photoURL?: string;\n  handle?: string;\n}\nexport interface SsoUserProps {\n  sub: string;\n  email: string;\n  displayName: string;\n  photoURL?: string;\n  handle?: string;\n}\n\nexport interface SsoV2ExchangeResponse {\n  token: string;\n}\n\nexport interface SignInResponse {\n  data: {\n    user: UserProps;\n    token: string;\n  };\n}\n\nexport interface FirebaseUser {\n  name: string;\n  picture: string;\n  originalEmail: string;\n  safeDisplayName: string;\n  safePhotoURL: string;\n  initialized: boolean;\n  legacyID: string;\n  handle: string;\n  iss: string;\n  aud: string;\n  auth_time: number;\n  user_id: string;\n  sub: string;\n  iat: number;\n  exp: number;\n  email: string;\n  email_verified: boolean;\n  firebase: {\n    identities: Record<string, string[]>;\n    sign_in_provider: string;\n  };\n}\n","type Nullable<T> = T | null;\n\nexport enum AnalyticsWidgetType {\n  AvatarProfile = 'avatar-profile',\n  AvatarChat = 'avatar-chat',\n  Comments = 'comments',\n  GlobalProfile = 'global-profile',\n  GroupChat = 'group-chat',\n  Polls = 'polls',\n  UniversalSnippet = 'universal-snippet',\n}\n\nexport type TrackOptions = {\n  widgetId: string | null;\n  widgetType: AnalyticsWidgetType;\n  siteId: string;\n  rsWriteKey: string;\n  rsDataPlaneUrl: string;\n  trigger: string;\n};\n\nexport enum AnalyticsEvent {\n  AuthenticationCompleted = 'Authentication Completed',\n  AuthenticationStarted = 'Authentication Started',\n  AuthenticationViewed = 'Authentication Viewed',\n}\n\nexport type TrackProps = Nullable<Record<string, unknown>>;\n\nexport interface IdentityProps {\n  anonymousId?: string;\n  userId?: string;\n}\n\nexport interface RudderContext {\n  channel: 'web';\n  anonymousId?: string;\n  locale?: string;\n  userAgent?: string;\n  timezone?: string;\n  os?: { name: string; version?: string };\n  page?: {\n    path?: string;\n    referrer?: string;\n    referring_domain?: string;\n    search?: string;\n    title?: string;\n    url?: string;\n    initial_referrer?: string;\n    initial_referring_domain?: string;\n  };\n  screen?: {\n    density?: number;\n    height?: number;\n    width?: number;\n    innerHeight?: number;\n    innerWidth?: number;\n  };\n  campaign?: Record<string, string>;\n}\n","import { createContext, useContext, useState, ReactNode } from 'react';\nimport { UserProps } from '../services/auth/types';\nimport { TrackOptions } from '../types/analytics';\n\ninterface AuthDialogContextType {\n  isOpen: boolean;\n  appName: string | undefined;\n  appDescription: string | undefined;\n  trackOptions: TrackOptions | undefined;\n  onAuthCompleted: ((user: UserProps) => void) | undefined;\n  openDialog: (options: OpenDialogOptions) => void;\n  closeDialog: () => void;\n  onOpenChange: (open: boolean) => void;\n}\n\nconst AuthDialogContext = createContext<AuthDialogContextType | undefined>(\n  undefined\n);\n\ntype OpenDialogOptions = {\n  trackOptions: TrackOptions;\n  appName?: string;\n  appDescription?: string;\n  onAuthCompleted?: () => (user: UserProps) => void;\n};\n\nexport const AuthDialogProvider = ({ children }: { children: ReactNode }) => {\n  const [isOpen, setIsOpen] = useState(false);\n  const [appName, setAppName] = useState<string | undefined>(undefined);\n  const [appDescription, setAppDescription] = useState<string | undefined>(\n    undefined\n  );\n  const [onAuthCompleted, setOnAuthCompleted] = useState<\n    ((user: UserProps) => void) | undefined\n  >(undefined);\n  const [trackOptions, setTrackOptions] = useState<TrackOptions | undefined>(\n    undefined\n  );\n  const openDialog = ({\n    trackOptions,\n    appName,\n    appDescription,\n    onAuthCompleted,\n  }: OpenDialogOptions) => {\n    setIsOpen(true);\n    setTrackOptions(trackOptions);\n    setAppName(appName);\n    setAppDescription(appDescription);\n    setOnAuthCompleted(onAuthCompleted);\n  };\n\n  const closeDialog = () => setIsOpen(false);\n  const onOpenChange = (open: boolean) => setIsOpen(open);\n\n  return (\n    <AuthDialogContext.Provider\n      value={{\n        isOpen,\n        appName,\n        appDescription,\n        trackOptions,\n        onAuthCompleted,\n        openDialog,\n        closeDialog,\n        onOpenChange,\n      }}\n    >\n      {children}\n    </AuthDialogContext.Provider>\n  );\n};\n\nexport const useAuthDialog = () => {\n  const context = useContext(AuthDialogContext);\n  if (!context) {\n    throw new Error('useAuthDialog must be used within an AuthDialogProvider');\n  }\n  return context;\n};\n","import { AuthDialogProvider } from './auth-dialog-provider';\nimport { QueryClient, QueryClientProvider } from '@tanstack/react-query';\nimport { UserProvider } from './user-provider';\nimport { ConfigProvider } from './config-provider';\nimport AuthDialog from '../dialog';\nimport { AnonymousTokenProvider } from './anonymous-token-provider';\n\nexport function AuthProvider({\n  children,\n  queryClient,\n  environment,\n}: {\n  children: React.ReactNode;\n  queryClient?: QueryClient;\n  environment?: 'production' | 'development';\n}) {\n  queryClient = queryClient || new QueryClient();\n\n  return (\n    <QueryClientProvider client={queryClient}>\n      <ConfigProvider environment={environment}>\n        <UserProvider>\n          <AuthDialogProvider>\n            <AnonymousTokenProvider>\n              {children}\n              <AuthDialog />\n            </AnonymousTokenProvider>\n          </AuthDialogProvider>\n        </UserProvider>\n      </ConfigProvider>\n    </QueryClientProvider>\n  );\n}\n\nexport { useAuthDialog } from './auth-dialog-provider';\n","export enum TokenType {\n  ANONYMOUS = 'anonymous',\n  GUEST = 'guest',\n  PUBLIC = 'public',\n  CUSTOM = 'custom',\n}\n\nexport interface TokenPair {\n  idToken: string | null;\n  refreshToken?: string | null;\n}\n\nexport type TokensMap = Record<TokenType, TokenPair>;\n\nexport enum AuthCookie {\n  PUBLIC_ID_TOKEN = 'arena-auth-public-id-token',\n  PUBLIC_REFRESH_TOKEN = 'arena-auth-public-refresh-token',\n  ANONYMOUS_ID_TOKEN = 'arena-auth-anonymous-id-token',\n  GUEST_ID_TOKEN = 'arena-auth-guest-id-token',\n  CUSTOM_ID_TOKEN = 'arena-auth-custom-id-token',\n  CUSTOM_USER = 'arena-auth-custom-user',\n}\n","import { create } from 'zustand';\nimport { subscribeWithSelector } from 'zustand/middleware';\nimport Cookies from 'js-cookie';\nimport { AuthCookie, TokensMap, TokenType } from '../types/token';\nimport { dispatchTokenUpdatedEvent } from '../utils/dom-events';\n\ninterface TokenStore {\n  tokens: TokensMap;\n  getToken: (type: TokenType) => string | null;\n  getMostPrivilegedToken: (\n    options?: Array<TokenType>\n  ) => { type: TokenType; idToken: string } | null;\n  getRefreshToken: (type: TokenType) => string | null;\n  updatePublicTokens: (\n    idToken: string,\n    refreshToken: string,\n    source?: string\n  ) => void;\n  updateAnonymousToken: (idToken: string, source?: string) => void;\n  updateGuestTokens: (idToken: string, source?: string) => void;\n  updateCustomToken: (idToken: string, source?: string) => void;\n  clearTokens: (source?: string) => void;\n  clearPublicTokens: (source?: string) => void;\n  clearAnonymousTokens: (source?: string) => void;\n  clearGuestTokens: (source?: string) => void;\n  clearCustomTokens: (source?: string) => void;\n  silentUpdatePublicTokens: (idToken: string, refreshToken: string) => void;\n  silentUpdateAnonymousToken: (idToken: string) => void;\n  silentUpdateGuestTokens: (idToken: string) => void;\n  silentUpdateCustomToken: (idToken: string) => void;\n  silentClearPublicTokens: () => void;\n  silentClearAnonymousTokens: () => void;\n  silentClearGuestTokens: () => void;\n  silentClearCustomTokens: () => void;\n}\n\nconst defaultTokens: TokensMap = {\n  public: {\n    idToken: Cookies.get(AuthCookie.PUBLIC_ID_TOKEN) || null,\n    refreshToken: Cookies.get(AuthCookie.PUBLIC_REFRESH_TOKEN) || null,\n  },\n  anonymous: {\n    idToken: Cookies.get(AuthCookie.ANONYMOUS_ID_TOKEN) || null,\n  },\n  guest: {\n    idToken: Cookies.get(AuthCookie.GUEST_ID_TOKEN) || null,\n  },\n  custom: {\n    idToken: Cookies.get(AuthCookie.CUSTOM_ID_TOKEN) || null,\n  },\n};\n\nexport const useTokenStore = create<TokenStore>()(\n  subscribeWithSelector((set, get) => {\n    const updatePublicTokensHelper = (\n      idToken: string,\n      refreshToken: string,\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      if (\n        idToken === get().tokens.public.idToken &&\n        refreshToken === get().tokens.public.refreshToken\n      ) {\n        return;\n      }\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          public: {\n            idToken,\n            refreshToken,\n          },\n        },\n      }));\n\n      Cookies.set(AuthCookie.PUBLIC_ID_TOKEN, idToken, {\n        expires: 1 / 24,\n      });\n\n      Cookies.set(AuthCookie.PUBLIC_REFRESH_TOKEN, refreshToken, {\n        expires: 30,\n      });\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.PUBLIC, {\n          idToken,\n          refreshToken,\n          source,\n        });\n      }\n    };\n\n    const updateAnonymousTokenHelper = (\n      idToken: string,\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      if (idToken === get().tokens.anonymous.idToken) {\n        return;\n      }\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          anonymous: {\n            idToken,\n          },\n        },\n      }));\n\n      Cookies.set(AuthCookie.ANONYMOUS_ID_TOKEN, idToken, {\n        expires: 1 / 24,\n      });\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.ANONYMOUS, { idToken, source });\n      }\n    };\n\n    const updateGuestTokensHelper = (\n      idToken: string,\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      if (idToken === get().tokens.guest.idToken) {\n        return;\n      }\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          guest: {\n            idToken,\n          },\n        },\n      }));\n\n      Cookies.set(AuthCookie.GUEST_ID_TOKEN, idToken, {\n        expires: 1 / 24,\n      });\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.GUEST, { idToken, source });\n      }\n    };\n\n    const updateCustomTokenHelper = (\n      idToken: string,\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      if (idToken === get().tokens.custom.idToken) {\n        return;\n      }\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          custom: { idToken },\n        },\n      }));\n\n      Cookies.set(AuthCookie.CUSTOM_ID_TOKEN, idToken);\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.CUSTOM, { idToken, source });\n      }\n    };\n\n    const clearPublicTokensHelper = (\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      Cookies.remove(AuthCookie.PUBLIC_ID_TOKEN);\n      Cookies.remove(AuthCookie.PUBLIC_REFRESH_TOKEN);\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          public: { idToken: null, refreshToken: null },\n        },\n      }));\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.PUBLIC, { idToken: null, source });\n      }\n    };\n\n    const clearAnonymousTokensHelper = (\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      Cookies.remove(AuthCookie.ANONYMOUS_ID_TOKEN);\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          anonymous: { idToken: null },\n        },\n      }));\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.ANONYMOUS, {\n          idToken: null,\n          source,\n        });\n      }\n    };\n\n    const clearGuestTokensHelper = (\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      Cookies.remove(AuthCookie.GUEST_ID_TOKEN);\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          guest: { idToken: null },\n        },\n      }));\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.GUEST, { idToken: null, source });\n      }\n    };\n\n    const clearCustomTokensHelper = (\n      dispatchEvent: boolean = true,\n      source?: string\n    ) => {\n      Cookies.remove(AuthCookie.CUSTOM_ID_TOKEN);\n      localStorage.removeItem(AuthCookie.CUSTOM_ID_TOKEN);\n      localStorage.removeItem(AuthCookie.CUSTOM_USER);\n\n      set(state => ({\n        tokens: {\n          ...state.tokens,\n          custom: { idToken: null },\n        },\n      }));\n\n      if (dispatchEvent) {\n        dispatchTokenUpdatedEvent(TokenType.CUSTOM, { idToken: null, source });\n      }\n    };\n\n    return {\n      tokens: defaultTokens,\n\n      getToken: (type: TokenType) => {\n        return get().tokens[type]?.idToken || null;\n      },\n\n      getMostPrivilegedToken: (\n        options = [TokenType.PUBLIC, TokenType.GUEST, TokenType.ANONYMOUS]\n      ) => {\n        if (get().tokens.custom.idToken && options.includes(TokenType.CUSTOM)) {\n          return {\n            type: TokenType.CUSTOM,\n            idToken: get().tokens.custom.idToken!,\n          };\n        }\n        if (get().tokens.public.idToken && options.includes(TokenType.PUBLIC)) {\n          return {\n            type: TokenType.PUBLIC,\n            idToken: get().tokens.public.idToken!,\n          };\n        }\n        if (get().tokens.guest.idToken && options.includes(TokenType.GUEST)) {\n          return {\n            type: TokenType.GUEST,\n            idToken: get().tokens.guest.idToken!,\n          };\n        }\n        if (\n          get().tokens.anonymous.idToken &&\n          options.includes(TokenType.ANONYMOUS)\n        ) {\n          return {\n            type: TokenType.ANONYMOUS,\n            idToken: get().tokens.anonymous.idToken!,\n          };\n        }\n        return null;\n      },\n\n      getRefreshToken: (type: TokenType) => {\n        return get().tokens[type]?.refreshToken || null;\n      },\n\n      updatePublicTokens: (\n        idToken: string,\n        refreshToken: string,\n        source?: string\n      ) => {\n        updatePublicTokensHelper(idToken, refreshToken, true, source);\n      },\n\n      updateAnonymousToken: (idToken: string, source?: string) => {\n        updateAnonymousTokenHelper(idToken, true, source);\n      },\n\n      updateGuestTokens: (idToken: string, source?: string) => {\n        updateGuestTokensHelper(idToken, true, source);\n      },\n\n      updateCustomToken: (idToken: string, source?: string) => {\n        updateCustomTokenHelper(idToken, true, source);\n      },\n\n      clearTokens: (source?: string) => {\n        clearPublicTokensHelper(true, source);\n        clearAnonymousTokensHelper(true, source);\n        clearGuestTokensHelper(true, source);\n        clearCustomTokensHelper(true, source);\n      },\n\n      clearPublicTokens: (source?: string) => {\n        clearPublicTokensHelper(true, source);\n      },\n\n      clearAnonymousTokens: (source?: string) => {\n        clearAnonymousTokensHelper(true, source);\n      },\n\n      clearGuestTokens: (source?: string) => {\n        clearGuestTokensHelper(true, source);\n      },\n\n      clearCustomTokens: (source?: string) => {\n        clearCustomTokensHelper(true, source);\n      },\n\n      silentUpdatePublicTokens: (idToken: string, refreshToken: string) => {\n        updatePublicTokensHelper(idToken, refreshToken, false);\n      },\n\n      silentUpdateAnonymousToken: (idToken: string) => {\n        updateAnonymousTokenHelper(idToken, false);\n      },\n\n      silentUpdateGuestTokens: (idToken: string) => {\n        updateGuestTokensHelper(idToken, false);\n      },\n\n      silentUpdateCustomToken: (idToken: string) => {\n        updateCustomTokenHelper(idToken, false);\n      },\n\n      silentClearPublicTokens: () => {\n        clearPublicTokensHelper(false);\n      },\n\n      silentClearAnonymousTokens: () => {\n        clearAnonymousTokensHelper(false);\n      },\n\n      silentClearGuestTokens: () => {\n        clearGuestTokensHelper(false);\n      },\n\n      silentClearCustomTokens: () => {\n        clearCustomTokensHelper(false);\n      },\n    };\n  })\n);\n","export interface PublicProfile {\n  displayName?: string;\n  handle?: string;\n  bio?: string;\n  metadata?: {\n    commentCountBySite?: {\n      [siteId: string]: number;\n    };\n    commentReactionCountBySite?: {\n      [siteId: string]: number;\n    };\n    overallCommentCount?: number;\n    overallCommentReactionCount?: number;\n  };\n  photoURL?: string;\n}\n","export interface Config {\n  profileServiceUrl: string;\n  identityServiceUrl: string;\n  refreshTokenApiKey: string;\n  authIframeUrl: string;\n  environment: 'development' | 'production';\n  debug: boolean;\n}\n\nexport type Environment = 'development' | 'production';\n\nexport const getConfig = (environment: Environment): Config => {\n  const isDev = environment === 'development';\n\n  return {\n    profileServiceUrl: isDev\n      ? process.env.PROFILE_SERVICE_URL_DEV ||\n        'https://profile-service-dev.arena.im'\n      : process.env.PROFILE_SERVICE_URL_PRD ||\n        'https://profile-service-prd.arena.im',\n    identityServiceUrl: isDev\n      ? process.env.IDENTITY_SERVICE_URL_DEV ||\n        'https://token-service-dev.arena.im'\n      : process.env.IDENTITY_SERVICE_URL_PRD ||\n        'https://token-service-prd.arena.im',\n    refreshTokenApiKey: isDev\n      ? process.env.FIREBASE_PUBLIC_API_KEY_DEV ||\n        'AIzaSyCJhWFCK3ics9kJ2eSgQD7kWHUsOsJyPdk'\n      : process.env.FIREBASE_PUBLIC_API_KEY_PRD ||\n        'AIzaSyD-9tSrQWn73S0qm6BqEH5-12Hq8L0eTsQ',\n    authIframeUrl: isDev\n      ? process.env.AUTH_IFRAME_URL_DEV || 'https://auth2.dev.arena.im'\n      : process.env.AUTH_IFRAME_URL_PRD || 'https://auth2.arena.im',\n    environment,\n    debug: environment === 'development',\n  };\n};\n","import { create } from 'zustand';\nimport { subscribeWithSelector } from 'zustand/middleware';\nimport Cookies from 'js-cookie';\nimport {\n  UserProps,\n  FirebaseUser,\n  SsoUserProps,\n  SsoV2ExchangeResponse,\n} from '../services/auth/types';\nimport { jwtDecode } from 'jwt-decode';\nimport { type PublicProfile } from '../services/profile/types';\nimport { useTokenStore } from './token-store';\nimport { AuthCookie } from '../types/token';\nimport { request } from '../utils/request';\nimport { Environment, getConfig } from '../config';\n\ninterface UserStore {\n  user: UserProps | null;\n  publicProfile: PublicProfile | null;\n  refreshedTokenLoaded: boolean;\n  setUser: (user: UserProps | null) => void;\n  setPublicProfile: (publicProfile: PublicProfile | null) => void;\n  logout: () => void;\n  refreshPublicTokens: (config: {\n    refreshTokenApiKey: string;\n  }) => Promise<void>;\n  setUserByTokenId: (idToken: string) => void;\n  loadStoredUser: (config?: { refreshTokenApiKey: string }) => Promise<void>;\n  ssoV2Exchange: (\n    ssoSourceID: string,\n    jwt: string,\n    env?: Environment\n  ) => Promise<SsoV2ExchangeResponse>;\n}\n\nexport const useUserStore = create<UserStore>()(\n  subscribeWithSelector((set, get) => ({\n    user: null,\n    publicProfile: null,\n    refreshedTokenLoaded: false,\n\n    setUser: (user: UserProps | null) => {\n      set({ user });\n    },\n\n    setPublicProfile: (publicProfile: PublicProfile | null) => {\n      set({ publicProfile });\n    },\n\n    setUserByTokenId: (idToken: string) => {\n      try {\n        const user = jwtDecode<FirebaseUser>(idToken);\n        const userProps: UserProps = {\n          uid: user.user_id,\n          displayName: user.safeDisplayName,\n          email: user.email,\n          photoURL: user.safePhotoURL,\n          handle: user.handle,\n        };\n        set({ user: userProps });\n      } catch (error) {\n        console.error(error);\n      }\n    },\n\n    logout: () => {\n      try {\n        const tokenStore = useTokenStore.getState();\n        tokenStore.clearPublicTokens();\n        tokenStore.clearCustomTokens();\n        set({ user: null });\n        document.dispatchEvent(new Event('arena-comments-logout'));\n      } catch (error) {\n        console.error(error);\n      }\n    },\n\n    refreshPublicTokens: async (config: { refreshTokenApiKey: string }) => {\n      try {\n        const refreshToken = Cookies.get(AuthCookie.PUBLIC_REFRESH_TOKEN);\n\n        if (!refreshToken) {\n          throw new Error('No refresh token found');\n        }\n\n        const prefix = 'https://securetoken.googleapis.com/v1/token?key=';\n        const apiKey = config.refreshTokenApiKey;\n        const url = `${prefix}${apiKey}`;\n        const response = await fetch(url, {\n          method: 'POST',\n          body: new URLSearchParams({\n            refresh_token: refreshToken,\n            grant_type: 'refresh_token',\n          }),\n        });\n        const data = await response.json();\n\n        const { setUserByTokenId } = get();\n        setUserByTokenId(data.id_token);\n\n        const tokenStore = useTokenStore.getState();\n        tokenStore.updatePublicTokens(data.id_token, data.refresh_token);\n      } catch (error) {\n        console.error(error);\n        const { logout } = get();\n        logout();\n      }\n    },\n\n    loadStoredUser: async (config?: { refreshTokenApiKey: string }) => {\n      const publicIdToken = Cookies.get(AuthCookie.PUBLIC_ID_TOKEN);\n      const publicRefreshToken = Cookies.get(AuthCookie.PUBLIC_REFRESH_TOKEN);\n      const customIdToken = localStorage.getItem(AuthCookie.CUSTOM_ID_TOKEN);\n      const customUser = localStorage.getItem(AuthCookie.CUSTOM_USER);\n\n      if (!!customIdToken && !!customUser) {\n        const parsedUser = JSON.parse(customUser);\n\n        set({ user: parsedUser });\n\n        const tokenStore = useTokenStore.getState();\n        tokenStore.updateCustomToken(customIdToken);\n      } else {\n        if (publicIdToken) {\n          const { setUserByTokenId } = get();\n          setUserByTokenId(publicIdToken);\n        } else if (publicRefreshToken && config) {\n          const { refreshPublicTokens } = get();\n          await refreshPublicTokens(config);\n        }\n      }\n\n      set({ refreshedTokenLoaded: true });\n    },\n\n    ssoV2Exchange: async (\n      ssoSourceID: string,\n      jwt: string,\n      env?: Environment\n    ) => {\n      try {\n        const config = getConfig(env ?? 'production');\n        const profileUrl = config.profileServiceUrl;\n\n        const url = `${profileUrl}/sso/sources/${ssoSourceID}/user`;\n        const response: SsoV2ExchangeResponse = await request('POST', url, {\n          body: JSON.stringify({ signedUserData: jwt }),\n        });\n\n        if (response) {\n          const decodedUser = jwtDecode<SsoUserProps>(response.token);\n\n          const { setUser, setPublicProfile } = get();\n\n          setUser({\n            uid: decodedUser?.sub,\n            email: decodedUser?.email,\n            displayName: decodedUser?.displayName,\n            photoURL: decodedUser?.photoURL,\n            handle: decodedUser?.handle,\n          });\n\n          setPublicProfile({\n            displayName: decodedUser?.displayName,\n            photoURL: decodedUser?.photoURL,\n            handle: decodedUser?.handle,\n          });\n\n          const tokenStore = useTokenStore.getState();\n          tokenStore.updateCustomToken(response.token);\n        }\n\n        return response;\n      } catch (error) {\n        console.error('SSO V2 Exchange failed:', error);\n        throw error;\n      }\n    },\n  }))\n);\n","import { useTokenStore } from '../stores/token-store';\nimport { useTokenEventListener } from './use-token-event-listener';\n\nexport function useTokens() {\n  const getToken = useTokenStore(state => state.getToken);\n  const getMostPrivilegedToken = useTokenStore(\n    state => state.getMostPrivilegedToken\n  );\n  const getRefreshToken = useTokenStore(state => state.getRefreshToken);\n  const updatePublicTokens = useTokenStore(state => state.updatePublicTokens);\n  const updateAnonymousToken = useTokenStore(\n    state => state.updateAnonymousToken\n  );\n  const updateGuestTokens = useTokenStore(state => state.updateGuestTokens);\n  const updateCustomToken = useTokenStore(state => state.updateCustomToken);\n  const clearTokens = useTokenStore(state => state.clearTokens);\n  const clearPublicTokens = useTokenStore(state => state.clearPublicTokens);\n  const clearCustomTokens = useTokenStore(state => state.clearCustomTokens);\n\n  const { eventSource } = useTokenEventListener();\n\n  return {\n    getToken,\n    getMostPrivilegedToken,\n    getRefreshToken,\n    updatePublicTokens: (idToken: string, refreshToken: string) =>\n      updatePublicTokens(idToken, refreshToken, eventSource),\n    updateAnonymousToken: (idToken: string) =>\n      updateAnonymousToken(idToken, eventSource),\n    updateGuestTokens: (idToken: string) =>\n      updateGuestTokens(idToken, eventSource),\n    updateCustomToken: (idToken: string) =>\n      updateCustomToken(idToken, eventSource),\n    clearTokens: () => clearTokens(eventSource),\n    clearPublicTokens: () => clearPublicTokens(eventSource),\n    clearCustomTokens: () => clearCustomTokens(eventSource),\n  };\n}\n\nexport function useToken(type: 'anonymous' | 'guest' | 'public' | 'custom') {\n  return useTokenStore(state => state.tokens[type]);\n}\n\nexport function useTokenValue(\n  type: 'anonymous' | 'guest' | 'public' | 'custom'\n) {\n  return useTokenStore(state => state.tokens[type]?.idToken);\n}\n\nexport function useRefreshToken(type: 'anonymous' | 'guest' | 'public') {\n  return useTokenStore(state => state.tokens[type]?.refreshToken);\n}\n","import { useProfileServices } from '../services/profile/use-profile-services';\nimport { useUserStore } from '../stores/user-store';\n\nexport function useUser() {\n  return useUserStore(state => state.user);\n}\n\nexport function usePublicProfile() {\n  return useUserStore(state => state.publicProfile);\n}\n\nexport function useRefreshedTokenLoaded() {\n  return useUserStore(state => state.refreshedTokenLoaded);\n}\n\nexport function useUserActions() {\n  const setUser = useUserStore(state => state.setUser);\n  const setPublicProfile = useUserStore(state => state.setPublicProfile);\n  const logout = useUserStore(state => state.logout);\n  const refreshPublicTokens = useUserStore(state => state.refreshPublicTokens);\n  const setUserByTokenId = useUserStore(state => state.setUserByTokenId);\n  const loadStoredUser = useUserStore(state => state.loadStoredUser);\n  const ssoV2Exchange = useUserStore(state => state.ssoV2Exchange);\n  \n\n  return {\n    setUser,\n    setPublicProfile,\n    logout,\n    refreshPublicTokens,\n    setUserByTokenId,\n    loadStoredUser,\n    ssoV2Exchange,\n  };\n}\n\nexport function useUpdateProfile() {\n  const { updatePublicProfile } = useProfileServices();\n  return {\n    updatePublicProfile,\n  };\n}\n\nexport function useUserWithProfile() {\n  const user = useUserStore(state => state.user);\n  const publicProfile = useUserStore(state => state.publicProfile);\n  const refreshedTokenLoaded = useUserStore(\n    state => state.refreshedTokenLoaded\n  );\n\n  return {\n    user,\n    publicProfile,\n    refreshedTokenLoaded,\n  };\n}\n\n","import { useEffect, useRef } from 'react';\nimport { TokenType } from '../types/token';\nimport { useTokenStore } from '../stores/token-store';\nimport { TOKEN_UPDATED_EVENT } from '../utils/dom-events';\n\ninterface TokenUpdateEvent {\n  detail: {\n    idToken: string | null;\n    refreshToken?: string | null;\n    type: TokenType;\n    source?: string;\n  };\n}\n\nexport function useTokenEventListener() {\n  const updatePublicTokens = useTokenStore(\n    state => state.silentUpdatePublicTokens\n  );\n  const updateAnonymousToken = useTokenStore(\n    state => state.silentUpdateAnonymousToken\n  );\n  const updateGuestTokens = useTokenStore(\n    state => state.silentUpdateGuestTokens\n  );\n  const updateCustomToken = useTokenStore(\n    state => state.silentUpdateCustomToken\n  );\n  const clearTokens = useTokenStore(state => state.clearTokens);\n  const clearPublicTokens = useTokenStore(\n    state => state.silentClearPublicTokens\n  );\n  const clearAnonymousTokens = useTokenStore(\n    state => state.silentClearAnonymousTokens\n  );\n  const clearGuestTokens = useTokenStore(state => state.silentClearGuestTokens);\n  const clearCustomTokens = useTokenStore(\n    state => state.silentClearCustomTokens\n  );\n\n  const eventSourceRef = useRef<string>(\n    `widget-${Math.random().toString(36).substr(2, 9)}`\n  );\n\n  useEffect(() => {\n    const handleTokenUpdate = (\n      event: CustomEvent<TokenUpdateEvent['detail']>\n    ) => {\n      const { idToken, refreshToken, type, source } = event.detail;\n\n      if (source === eventSourceRef.current) {\n        return;\n      }\n\n      switch (type) {\n        case TokenType.PUBLIC:\n          if (idToken) {\n            if (!refreshToken) {\n              throw new Error('Refresh token is required for public tokens');\n            }\n            updatePublicTokens(idToken, refreshToken);\n          } else {\n            clearPublicTokens();\n          }\n          break;\n\n        case TokenType.ANONYMOUS:\n          if (idToken) {\n            updateAnonymousToken(idToken);\n          } else {\n            clearAnonymousTokens();\n          }\n          break;\n\n        case TokenType.GUEST:\n          if (idToken) {\n            updateGuestTokens(idToken);\n          } else {\n            clearGuestTokens();\n          }\n          break;\n\n        case TokenType.CUSTOM:\n          if (idToken) {\n            updateCustomToken(idToken);\n          } else {\n            clearCustomTokens();\n          }\n          break;\n      }\n    };\n\n    document.addEventListener(\n      TOKEN_UPDATED_EVENT,\n      handleTokenUpdate as EventListener\n    );\n\n    return () => {\n      document.removeEventListener(\n        TOKEN_UPDATED_EVENT,\n        handleTokenUpdate as EventListener\n      );\n    };\n  }, [\n    updatePublicTokens,\n    updateAnonymousToken,\n    updateGuestTokens,\n    updateCustomToken,\n    clearTokens,\n    clearPublicTokens,\n    clearAnonymousTokens,\n    clearGuestTokens,\n    clearCustomTokens,\n  ]);\n\n  return {\n    eventSource: eventSourceRef.current,\n  };\n}\n"],"names":[],"mappings":";;;;AAIO;AACP;AACA;AACA;AACA;AACA;AACA;AAQO;AACP;AACA;;ACpBA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIO;;ACrBA;AACP;AACA;AACA;AACA;;ACLO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPO;;ACLP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;;ACvBO;AACP;AACA;;;"}

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACvD,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kCAAkC,CAAC;AACjD,cAAc,SAAS,CAAC"}