@take-out/better-auth-utils 0.0.28

package/src/createAuthClient.ts

@@ -0,0 +1,324 @@
+/**
+ * Better-auth helpers for React / React Native applications
+ *
+ * Features:
+ *  - JWT support (for Zero, Tauri, React Native)
+ *  - Session persistence in local storage
+ *  - Token validation and refresh
+ *  - State management with emitters
+ *  - Automatic retry on errors
+ */
+
+import {
+  createEmitter,
+  createLocalStorageValue,
+  type Emitter,
+  isEqualDeepLite,
+  useEmitterValue,
+} from '@take-out/helpers'
+import type { Session, User } from 'better-auth'
+import { type BetterAuthClientOptions, createAuthClient } from 'better-auth/client'
+
+export interface StorageKeys {
+  token: string
+  session: string
+}
+
+export type AuthState<U extends User = User> = {
+  state: 'loading' | 'logged-in' | 'logged-out'
+  session: Session | null
+  user: U | null
+  token: string | null
+}
+
+export interface BetterAuthClientProps<TUser extends User = User>
+  extends BetterAuthClientOptions {
+  /**
+   * Callback to transform and type the user object
+   * This allows you to add app-specific fields and ensure proper typing
+   * @default (user) => user
+   */
+  createUser?: (user: User) => TUser
+  /**
+   * Optional callback when authentication state changes
+   */
+  onAuthStateChange?: (state: AuthState<TUser>) => void
+  /**
+   * Optional callback for handling auth errors
+   */
+  onAuthError?: (error: any) => void
+  /**
+   * Storage key prefix for local storage
+   * @default 'auth'
+   */
+  storagePrefix?: string
+  /**
+   * Retry delay in milliseconds after auth errors
+   * @default 4000
+   */
+  retryDelay?: number
+  /**
+   * Custom token validation endpoint
+   * @default '/api/auth/validateToken'
+   */
+  tokenValidationEndpoint?: string
+}
+
+export interface BetterAuthClientReturn<U extends User = User, TClient = any> {
+  clearState: () => void
+  authState: ReturnType<typeof createEmitter<AuthState<U>>>
+  authClient: TClient
+  setAuthClientToken: (props: { token: string; session: string }) => Promise<void>
+  clearAuthClientToken: () => void
+  useAuth: () => AuthState<U>
+  getAuth: () => AuthState<U> & { loggedIn: boolean }
+  getValidToken: () => Promise<string | undefined>
+  updateAuthClient: (session: string) => void
+  authClientVersion: Emitter<number>
+}
+
+type InferUser<T> = T extends { createUser?: (user: User) => infer R }
+  ? R extends User
+    ? R
+    : User
+  : User
+
+export function createBetterAuthClient<const Opts extends BetterAuthClientProps<any>>(
+  options: Opts
+): BetterAuthClientReturn<InferUser<Opts>, ReturnType<typeof createAuthClient<Opts>>> {
+  type TUser = InferUser<Opts>
+  const {
+    onAuthStateChange,
+    onAuthError,
+    createUser,
+    storagePrefix = 'auth',
+    retryDelay = 4000,
+    tokenValidationEndpoint = '/api/auth/validateToken',
+    ...authClientOptions
+  } = options
+
+  const empty: AuthState<TUser> = {
+    state: 'logged-out',
+    session: null,
+    user: null,
+    token: null,
+  }
+
+  const createAuthClientWithSession = (session: string) => {
+    return createAuthClient({
+      ...authClientOptions,
+      fetchOptions: {
+        headers: {
+          Authorization: `Bearer ${session}`,
+        },
+      },
+    })
+  }
+
+  const keysStorage = createLocalStorageValue<StorageKeys>(`${storagePrefix}-keys`)
+  const stateStorage = createLocalStorageValue<AuthState<TUser>>(`${storagePrefix}-state`)
+
+  let authClient = (() => {
+    const existingSession = keysStorage.get()?.session
+    return existingSession
+      ? createAuthClientWithSession(existingSession)
+      : createAuthClient(authClientOptions as Opts)
+  })()
+
+  const authState = createEmitter<AuthState<TUser>>(
+    'authState',
+    stateStorage.get() || empty,
+    {
+      comparator: isEqualDeepLite,
+    }
+  )
+
+  const authClientVersion = createEmitter<number>('authClientVersion', 0)
+
+  const setState = (update: Partial<AuthState<TUser>>) => {
+    const current = authState.value!
+    const next = { ...current, ...update }
+    stateStorage.set(next)
+    authState.emit(next)
+
+    // update storage keys
+    if (next.token && next.session) {
+      keysStorage.set({
+        token: next.token,
+        session: next.session.token,
+      })
+    } else {
+      keysStorage.set({
+        token: '',
+        session: '',
+      })
+    }
+
+    // call optional callback
+    onAuthStateChange?.(next)
+  }
+
+  const setAuthClientToken = async (props: { token: string; session: string }) => {
+    keysStorage.set(props)
+    updateAuthClient(props.session)
+  }
+
+  function updateAuthClient(session: string) {
+    authClient = createAuthClientWithSession(session)
+    authClientVersion.emit(Math.random())
+    subscribeToAuthEffect()
+  }
+
+  let dispose: Function | null = null
+  let retryTimer: ReturnType<typeof setTimeout> | null = null
+
+  function subscribeToAuthEffect() {
+    dispose?.()
+
+    dispose = authClient.useSession.subscribe(async (props) => {
+      const { data: dataGeneric, isPending, error } = props
+
+      if (error) {
+        onAuthError?.(error)
+        // retry by re-subscribing after a delay to recover from transient errors
+        scheduleAuthRetry(retryDelay)
+        return
+      }
+
+      const data = dataGeneric as
+        | undefined
+        | {
+            session?: AuthState<TUser>['session']
+            user?: AuthState<TUser>['user']
+          }
+
+      setState({
+        state: isPending ? 'loading' : data?.session ? 'logged-in' : 'logged-out',
+        session: data?.session,
+        user: data?.user
+          ? createUser
+            ? createUser(data.user as User)
+            : (data.user as any)
+          : null,
+      })
+
+      // get token on creating a new session (for native + tauri)
+      if (data?.session && !authState.value.token) {
+        getValidToken().then((token) => {
+          if (token) {
+            setState({ token })
+          }
+        })
+      }
+    })
+  }
+
+  function scheduleAuthRetry(delayMs: number) {
+    if (retryTimer) {
+      clearTimeout(retryTimer)
+    }
+    retryTimer = setTimeout(() => {
+      retryTimer = null
+      subscribeToAuthEffect()
+    }, delayMs)
+  }
+
+  async function getValidToken(): Promise<string | undefined> {
+    const existing = keysStorage.get()?.token
+
+    if (existing) {
+      try {
+        const response = await fetch(tokenValidationEndpoint, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            token: existing,
+          }),
+        }).then((res) => res.json())
+
+        if (response?.valid) {
+          return existing
+        }
+      } catch (error) {
+        console.error('Error validating token:', error)
+      }
+    }
+
+    const res = await authClient.$fetch('/token')
+    if (res.error) {
+      console.error(`Error fetching token: ${res.error.statusText}`)
+      return undefined
+    }
+    const data = res.data as any
+    return data?.token as string | undefined
+  }
+
+  const clearAuthClientToken = () => {
+    keysStorage.remove()
+  }
+
+  const getAuth = () => {
+    const state = authState?.value || empty
+    return {
+      ...state,
+      loggedIn: !!state.session,
+    }
+  }
+
+  const useAuth = () => {
+    return useEmitterValue(authState) || empty
+  }
+
+  function clearState() {
+    keysStorage.clear()
+    stateStorage.clear()
+    setState(empty)
+  }
+
+  // initialize subscription
+  subscribeToAuthEffect()
+
+  // cleanup on unmount
+  if (typeof window !== 'undefined' && window.addEventListener) {
+    const cleanup = () => {
+      dispose?.()
+      if (retryTimer) {
+        clearTimeout(retryTimer)
+      }
+    }
+    window.addEventListener('beforeunload', cleanup)
+  }
+
+  const proxiedAuthClient = new Proxy(authClient, {
+    get(_target, key) {
+      if (key === 'signOut') {
+        return async () => {
+          clearState()
+          // @ts-expect-error better-auth type issue, signOut does exist
+          await authClient.signOut?.()
+          // force refresh to clear any remaining state
+          if (typeof window !== 'undefined') {
+            window.location?.reload?.()
+          }
+        }
+      }
+      // ensure always latest authClient after login
+      return Reflect.get(authClient, key)
+    },
+  }) as ReturnType<typeof createAuthClient<Opts>>
+
+  return {
+    authClientVersion,
+    clearState,
+    authState,
+    authClient: proxiedAuthClient,
+    setAuthClientToken,
+    clearAuthClientToken,
+    useAuth,
+    getAuth,
+    getValidToken,
+    updateAuthClient,
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './createAuthClient'

package/types/client.d.ts

@@ -0,0 +1,10 @@
+/**
+* Client-specific exports for better-auth
+*/
+export { createBetterAuthClient } from "./createAuthClient";
+export type { AuthState, BetterAuthClientConfig, BetterAuthClientReturn, StorageKeys } from "./createAuthClient";
+// re-export useful better-auth types
+export type { BetterAuthClientOptions, BetterAuthClientPlugin } from "better-auth/client";
+export type { Session, User } from "better-auth";
+
+//# sourceMappingURL=client.d.ts.map

package/types/client.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;AAIA,SAAS,8BAA8B;AACvC,cACE,WACA,wBACA,wBACA,mBACK;;AAGP,cAAc,yBAAyB,8BAA8B;AACrE,cAAc,SAAS,YAAY",
+  "names": [],
+  "sources": [
+    "src/client.ts"
+  ],
+  "sourcesContent": [
+    "/**\n * Client-specific exports for better-auth\n */\n\nexport { createBetterAuthClient } from './createAuthClient'\nexport type {\n  AuthState,\n  BetterAuthClientConfig,\n  BetterAuthClientReturn,\n  StorageKeys,\n} from './createAuthClient'\n\n// re-export useful better-auth types\nexport type { BetterAuthClientOptions, BetterAuthClientPlugin } from 'better-auth/client'\nexport type { Session, User } from 'better-auth'\n"
+  ],
+  "version": 3
+}

package/types/createAuthClient.d.ts

@@ -0,0 +1,81 @@
+/**
+* Better-auth helpers for React / React Native applications
+*
+* Features:
+*  - JWT support (for Zero, Tauri, React Native)
+*  - Session persistence in local storage
+*  - Token validation and refresh
+*  - State management with emitters
+*  - Automatic retry on errors
+*/
+import { createEmitter, type Emitter } from "@take-out/helpers";
+import type { Session, User } from "better-auth";
+import { type BetterAuthClientOptions, createAuthClient } from "better-auth/client";
+export interface StorageKeys {
+	token: string;
+	session: string;
+}
+export type AuthState<U extends User = User> = {
+	state: "loading" | "logged-in" | "logged-out";
+	session: Session | null;
+	user: U | null;
+	token: string | null;
+};
+export interface BetterAuthClientProps<TUser extends User = User> extends BetterAuthClientOptions {
+	/**
+	* Callback to transform and type the user object
+	* This allows you to add app-specific fields and ensure proper typing
+	* @default (user) => user
+	*/
+	createUser?: (user: User) => TUser;
+	/**
+	* Optional callback when authentication state changes
+	*/
+	onAuthStateChange?: (state: AuthState<TUser>) => void;
+	/**
+	* Optional callback for handling auth errors
+	*/
+	onAuthError?: (error: any) => void;
+	/**
+	* Storage key prefix for local storage
+	* @default 'auth'
+	*/
+	storagePrefix?: string;
+	/**
+	* Retry delay in milliseconds after auth errors
+	* @default 4000
+	*/
+	retryDelay?: number;
+	/**
+	* Custom token validation endpoint
+	* @default '/api/auth/validateToken'
+	*/
+	tokenValidationEndpoint?: string;
+}
+export interface BetterAuthClientReturn<
+	U extends User = User,
+	TClient = any
+> {
+	clearState: () => void;
+	authState: ReturnType<typeof createEmitter<AuthState<U>>>;
+	authClient: TClient;
+	setAuthClientToken: (props: {
+		token: string;
+		session: string;
+	}) => Promise<void>;
+	clearAuthClientToken: () => void;
+	useAuth: () => AuthState<U>;
+	getAuth: () => AuthState<U> & {
+		loggedIn: boolean;
+	};
+	getValidToken: () => Promise<string | undefined>;
+	updateAuthClient: (session: string) => void;
+	authClientVersion: Emitter<number>;
+}
+type InferUser<T> = T extends {
+	createUser?: (user: User) => infer R;
+} ? R extends User ? R : User : User;
+export declare function createBetterAuthClient<const Opts extends BetterAuthClientProps<any>>(options: Opts): BetterAuthClientReturn<InferUser<Opts>, ReturnType<typeof createAuthClient<Opts>>>;
+export {};
+
+//# sourceMappingURL=createAuthClient.d.ts.map

package/types/createAuthClient.d.ts.map

@@ -0,0 +1,18 @@
+{
+  "mappings": ";;;;;;;;;;AAWA,SACE,oBAEK,eAGA,mBAAmB;AAC1B,cAAc,SAAS,YAAY,aAAa;AAChD,cAAc,yBAAyB,wBAAwB,oBAAoB;AAEnF,iBAAiB,YAAY;CAC3B;CACA;AACD;AAED,YAAY,UAAU,UAAU,OAAO,QAAQ;CAC7C,OAAO,YAAY,cAAc;CACjC,SAAS;CACT,MAAM;CACN;AACD;AAED,iBAAiB,sBAAsB,cAAc,OAAO,cAClD,wBAAwB;;;;;;CAMhC,cAAcA,MAAM,SAAS;;;;CAI7B,qBAAqBC,OAAO,UAAU;;;;CAItC,eAAeC;;;;;CAKf;;;;;CAKA;;;;;CAKA;AACD;AAED,iBAAiB;CAAuB,UAAU,OAAO;CAAM;EAAe;CAC5E;CACA,WAAW,kBAAkB,cAAc,UAAU;CACrD,YAAY;CACZ,qBAAqBC,OAAO;EAAE;EAAe;CAAiB,MAAK;CACnE;CACA,eAAe,UAAU;CACzB,eAAe,UAAU,KAAK;EAAE;CAAmB;CACnD,qBAAqB;CACrB,mBAAmBC;CACnB,mBAAmB;AACpB;KAEI,UAAU,KAAK,UAAU;CAAE,cAAcJ,MAAM,eAAe;AAAG,IAClE,UAAU,OACR,IACA,OACF;AAEJ,OAAO,iBAAS,6BAA6B,aAAa,4BACxDK,SAAS,OACR,uBAAuB,UAAU,OAAO,kBAAkB,iBAAiB",
+  "names": [
+    "user: User",
+    "state: AuthState<TUser>",
+    "error: any",
+    "props: { token: string; session: string }",
+    "session: string",
+    "options: Opts"
+  ],
+  "sources": [
+    "src/createAuthClient.ts"
+  ],
+  "sourcesContent": [
+    "/**\n * Better-auth helpers for React / React Native applications\n *\n * Features:\n *  - JWT support (for Zero, Tauri, React Native)\n *  - Session persistence in local storage\n *  - Token validation and refresh\n *  - State management with emitters\n *  - Automatic retry on errors\n */\n\nimport {\n  createEmitter,\n  createLocalStorageValue,\n  type Emitter,\n  isEqualDeepLite,\n  useEmitterValue,\n} from '@take-out/helpers'\nimport type { Session, User } from 'better-auth'\nimport { type BetterAuthClientOptions, createAuthClient } from 'better-auth/client'\n\nexport interface StorageKeys {\n  token: string\n  session: string\n}\n\nexport type AuthState<U extends User = User> = {\n  state: 'loading' | 'logged-in' | 'logged-out'\n  session: Session | null\n  user: U | null\n  token: string | null\n}\n\nexport interface BetterAuthClientProps<TUser extends User = User>\n  extends BetterAuthClientOptions {\n  /**\n   * Callback to transform and type the user object\n   * This allows you to add app-specific fields and ensure proper typing\n   * @default (user) => user\n   */\n  createUser?: (user: User) => TUser\n  /**\n   * Optional callback when authentication state changes\n   */\n  onAuthStateChange?: (state: AuthState<TUser>) => void\n  /**\n   * Optional callback for handling auth errors\n   */\n  onAuthError?: (error: any) => void\n  /**\n   * Storage key prefix for local storage\n   * @default 'auth'\n   */\n  storagePrefix?: string\n  /**\n   * Retry delay in milliseconds after auth errors\n   * @default 4000\n   */\n  retryDelay?: number\n  /**\n   * Custom token validation endpoint\n   * @default '/api/auth/validateToken'\n   */\n  tokenValidationEndpoint?: string\n}\n\nexport interface BetterAuthClientReturn<U extends User = User, TClient = any> {\n  clearState: () => void\n  authState: ReturnType<typeof createEmitter<AuthState<U>>>\n  authClient: TClient\n  setAuthClientToken: (props: { token: string; session: string }) => Promise<void>\n  clearAuthClientToken: () => void\n  useAuth: () => AuthState<U>\n  getAuth: () => AuthState<U> & { loggedIn: boolean }\n  getValidToken: () => Promise<string | undefined>\n  updateAuthClient: (session: string) => void\n  authClientVersion: Emitter<number>\n}\n\ntype InferUser<T> = T extends { createUser?: (user: User) => infer R }\n  ? R extends User\n    ? R\n    : User\n  : User\n\nexport function createBetterAuthClient<const Opts extends BetterAuthClientProps<any>>(\n  options: Opts\n): BetterAuthClientReturn<InferUser<Opts>, ReturnType<typeof createAuthClient<Opts>>> {\n  type TUser = InferUser<Opts>\n  const {\n    onAuthStateChange,\n    onAuthError,\n    createUser,\n    storagePrefix = 'auth',\n    retryDelay = 4000,\n    tokenValidationEndpoint = '/api/auth/validateToken',\n    ...authClientOptions\n  } = options\n\n  const empty: AuthState<TUser> = {\n    state: 'logged-out',\n    session: null,\n    user: null,\n    token: null,\n  }\n\n  const createAuthClientWithSession = (session: string) => {\n    return createAuthClient({\n      ...authClientOptions,\n      fetchOptions: {\n        headers: {\n          Authorization: `Bearer ${session}`,\n        },\n      },\n    })\n  }\n\n  const keysStorage = createLocalStorageValue<StorageKeys>(`${storagePrefix}-keys`)\n  const stateStorage = createLocalStorageValue<AuthState<TUser>>(`${storagePrefix}-state`)\n\n  let authClient = (() => {\n    const existingSession = keysStorage.get()?.session\n    return existingSession\n      ? createAuthClientWithSession(existingSession)\n      : createAuthClient(authClientOptions as Opts)\n  })()\n\n  const authState = createEmitter<AuthState<TUser>>(\n    'authState',\n    stateStorage.get() || empty,\n    {\n      comparator: isEqualDeepLite,\n    }\n  )\n\n  const authClientVersion = createEmitter<number>('authClientVersion', 0)\n\n  const setState = (update: Partial<AuthState<TUser>>) => {\n    const current = authState.value!\n    const next = { ...current, ...update }\n    stateStorage.set(next)\n    authState.emit(next)\n\n    // update storage keys\n    if (next.token && next.session) {\n      keysStorage.set({\n        token: next.token,\n        session: next.session.token,\n      })\n    } else {\n      keysStorage.set({\n        token: '',\n        session: '',\n      })\n    }\n\n    // call optional callback\n    onAuthStateChange?.(next)\n  }\n\n  const setAuthClientToken = async (props: { token: string; session: string }) => {\n    keysStorage.set(props)\n    updateAuthClient(props.session)\n  }\n\n  function updateAuthClient(session: string) {\n    authClient = createAuthClientWithSession(session)\n    authClientVersion.emit(Math.random())\n    subscribeToAuthEffect()\n  }\n\n  let dispose: Function | null = null\n  let retryTimer: ReturnType<typeof setTimeout> | null = null\n\n  function subscribeToAuthEffect() {\n    dispose?.()\n\n    dispose = authClient.useSession.subscribe(async (props) => {\n      const { data: dataGeneric, isPending, error } = props\n\n      if (error) {\n        onAuthError?.(error)\n        // retry by re-subscribing after a delay to recover from transient errors\n        scheduleAuthRetry(retryDelay)\n        return\n      }\n\n      const data = dataGeneric as\n        | undefined\n        | {\n            session?: AuthState<TUser>['session']\n            user?: AuthState<TUser>['user']\n          }\n\n      setState({\n        state: isPending ? 'loading' : data?.session ? 'logged-in' : 'logged-out',\n        session: data?.session,\n        user: data?.user\n          ? createUser\n            ? createUser(data.user as User)\n            : (data.user as any)\n          : null,\n      })\n\n      // get token on creating a new session (for native + tauri)\n      if (data?.session && !authState.value.token) {\n        getValidToken().then((token) => {\n          if (token) {\n            setState({ token })\n          }\n        })\n      }\n    })\n  }\n\n  function scheduleAuthRetry(delayMs: number) {\n    if (retryTimer) {\n      clearTimeout(retryTimer)\n    }\n    retryTimer = setTimeout(() => {\n      retryTimer = null\n      subscribeToAuthEffect()\n    }, delayMs)\n  }\n\n  async function getValidToken(): Promise<string | undefined> {\n    const existing = keysStorage.get()?.token\n\n    if (existing) {\n      try {\n        const response = await fetch(tokenValidationEndpoint, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          body: JSON.stringify({\n            token: existing,\n          }),\n        }).then((res) => res.json())\n\n        if (response?.valid) {\n          return existing\n        }\n      } catch (error) {\n        console.error('Error validating token:', error)\n      }\n    }\n\n    const res = await authClient.$fetch('/token')\n    if (res.error) {\n      console.error(`Error fetching token: ${res.error.statusText}`)\n      return undefined\n    }\n    const data = res.data as any\n    return data?.token as string | undefined\n  }\n\n  const clearAuthClientToken = () => {\n    keysStorage.remove()\n  }\n\n  const getAuth = () => {\n    const state = authState?.value || empty\n    return {\n      ...state,\n      loggedIn: !!state.session,\n    }\n  }\n\n  const useAuth = () => {\n    return useEmitterValue(authState) || empty\n  }\n\n  function clearState() {\n    keysStorage.clear()\n    stateStorage.clear()\n    setState(empty)\n  }\n\n  // initialize subscription\n  subscribeToAuthEffect()\n\n  // cleanup on unmount\n  if (typeof window !== 'undefined' && window.addEventListener) {\n    const cleanup = () => {\n      dispose?.()\n      if (retryTimer) {\n        clearTimeout(retryTimer)\n      }\n    }\n    window.addEventListener('beforeunload', cleanup)\n  }\n\n  const proxiedAuthClient = new Proxy(authClient, {\n    get(_target, key) {\n      if (key === 'signOut') {\n        return async () => {\n          clearState()\n          // @ts-expect-error better-auth type issue, signOut does exist\n          await authClient.signOut?.()\n          // force refresh to clear any remaining state\n          if (typeof window !== 'undefined') {\n            window.location?.reload?.()\n          }\n        }\n      }\n      // ensure always latest authClient after login\n      return Reflect.get(authClient, key)\n    },\n  }) as ReturnType<typeof createAuthClient<Opts>>\n\n  return {\n    authClientVersion,\n    clearState,\n    authState,\n    authClient: proxiedAuthClient,\n    setAuthClientToken,\n    clearAuthClientToken,\n    useAuth,\n    getAuth,\n    getValidToken,\n    updateAuthClient,\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/hooks/useAuthSession.d.ts

@@ -0,0 +1,8 @@
+import type { Session } from "better-auth";
+import type { BetterAuthClientReturn } from "../createAuthClient";
+/**
+* Hook to access just the auth session
+*/
+export declare function useAuthSession<U = any>(client: BetterAuthClientReturn<U>): Session | null;
+
+//# sourceMappingURL=useAuthSession.d.ts.map

package/types/hooks/useAuthSession.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,cAAc,eAAe,aAAa;AAC1C,cAAc,8BAA8B,qBAAqB;;;;AAKjE,OAAO,iBAAS,eAAe,SAC7BA,QAAQ,uBAAuB,KAC9B",
+  "names": [
+    "client: BetterAuthClientReturn<U>"
+  ],
+  "sources": [
+    "src/hooks/useAuthSession.ts"
+  ],
+  "sourcesContent": [
+    "import type { Session } from 'better-auth'\nimport type { BetterAuthClientReturn } from '../createAuthClient'\n\n/**\n * Hook to access just the auth session\n */\nexport function useAuthSession<U = any>(\n  client: BetterAuthClientReturn<U>\n): Session | null {\n  const state = client.useAuth()\n  return state.session\n}"
+  ],
+  "version": 3
+}

package/types/hooks/useAuthState.d.ts

@@ -0,0 +1,7 @@
+import type { AuthState, BetterAuthClientReturn } from "../createAuthClient";
+/**
+* Hook to access the full auth state
+*/
+export declare function useAuthState<U = any>(client: BetterAuthClientReturn<U>): AuthState<U>;
+
+//# sourceMappingURL=useAuthState.d.ts.map

package/types/hooks/useAuthState.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AACA,cAAc,WAAW,8BAA8B,qBAAqB;;;;AAK5E,OAAO,iBAAS,aAAa,SAC3BA,QAAQ,uBAAuB,KAC9B,UAAU",
+  "names": [
+    "client: BetterAuthClientReturn<U>"
+  ],
+  "sources": [
+    "src/hooks/useAuthState.ts"
+  ],
+  "sourcesContent": [
+    "import { useEmitterValue } from '@vxrn/helpers'\nimport type { AuthState, BetterAuthClientReturn } from '../createAuthClient'\n\n/**\n * Hook to access the full auth state\n */\nexport function useAuthState<U = any>(\n  client: BetterAuthClientReturn<U>\n): AuthState<U> {\n  return client.useAuth()\n}"
+  ],
+  "version": 3
+}

package/types/hooks/useAuthUser.d.ts

@@ -0,0 +1,8 @@
+import type { User } from "better-auth";
+import type { BetterAuthClientReturn } from "../createAuthClient";
+/**
+* Hook to access just the authenticated user
+*/
+export declare function useAuthUser<U extends User = User>(client: BetterAuthClientReturn<U>): U | null;
+
+//# sourceMappingURL=useAuthUser.d.ts.map

package/types/hooks/useAuthUser.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,cAAc,YAAY,aAAa;AACvC,cAAc,8BAA8B,qBAAqB;;;;AAKjE,OAAO,iBAAS,YAAY,UAAU,OAAO,MAC3CA,QAAQ,uBAAuB,KAC9B",
+  "names": [
+    "client: BetterAuthClientReturn<U>"
+  ],
+  "sources": [
+    "src/hooks/useAuthUser.ts"
+  ],
+  "sourcesContent": [
+    "import type { User } from 'better-auth'\nimport type { BetterAuthClientReturn } from '../createAuthClient'\n\n/**\n * Hook to access just the authenticated user\n */\nexport function useAuthUser<U extends User = User>(\n  client: BetterAuthClientReturn<U>\n): U | null {\n  const state = client.useAuth()\n  return state.user\n}"
+  ],
+  "version": 3
+}

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./createAuthClient";
+
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc",
+  "names": [],
+  "sources": [
+    "src/index.ts"
+  ],
+  "sourcesContent": [
+    "export * from './createAuthClient'\n"
+  ],
+  "version": 3
+}