@masheev/better-auth 0.0.0-stage → 1.7.5

package/dist/client/session-refresh.mjs

@@ -0,0 +1,131 @@
+import { getGlobalBroadcastChannel } from "./broadcast-channel.mjs";
+import { getGlobalFocusManager } from "./focus-manager.mjs";
+import { getGlobalOnlineManager } from "./online-manager.mjs";
+//#region src/client/session-refresh.ts
+const now = () => Math.floor(Date.now() / 1e3);
+/**
+* Rate limit: don't refetch on focus if a session request was made within this many seconds
+*/
+const FOCUS_REFETCH_RATE_LIMIT_SECONDS = 5;
+function createSessionRefreshManager(opts) {
+	const { fetchSession, shouldPollSession = () => true, sessionSignal, options = {} } = opts;
+	const refetchInterval = options.sessionOptions?.refetchInterval ?? 0;
+	const refetchOnWindowFocus = options.sessionOptions?.refetchOnWindowFocus ?? true;
+	const refetchWhenOffline = options.sessionOptions?.refetchWhenOffline ?? false;
+	const state = {
+		isInitialized: false,
+		lastSessionRequest: 0
+	};
+	const shouldRefetch = () => {
+		return refetchWhenOffline || getGlobalOnlineManager().isOnline;
+	};
+	const triggerRefetch = (event) => {
+		if (!shouldRefetch()) return;
+		if (event?.event === "storage") {
+			fetchSession();
+			return;
+		}
+		if (event?.event === "poll") {
+			state.lastSessionRequest = now();
+			fetchSession();
+			return;
+		}
+		if (event?.event === "visibilitychange") {
+			if (now() - state.lastSessionRequest < FOCUS_REFETCH_RATE_LIMIT_SECONDS) return;
+			state.lastSessionRequest = now();
+			fetchSession();
+			return;
+		}
+		fetchSession();
+	};
+	const broadcastSessionUpdate = (trigger) => {
+		getGlobalBroadcastChannel().post({
+			event: "session",
+			data: { trigger },
+			clientId: Math.random().toString(36).substring(7)
+		});
+	};
+	const setupPolling = () => {
+		if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
+			if (shouldPollSession()) triggerRefetch({ event: "poll" });
+		}, refetchInterval * 1e3);
+	};
+	const setupBroadcast = () => {
+		state.unsubscribeBroadcast = getGlobalBroadcastChannel().subscribe(() => {
+			triggerRefetch({ event: "storage" });
+		});
+	};
+	const setupFocusRefetch = () => {
+		if (!refetchOnWindowFocus) return;
+		state.unsubscribeFocus = getGlobalFocusManager().subscribe(() => {
+			triggerRefetch({ event: "visibilitychange" });
+		});
+	};
+	const setupOnlineRefetch = () => {
+		state.unsubscribeOnline = getGlobalOnlineManager().subscribe((online) => {
+			if (online) triggerRefetch({ event: "visibilitychange" });
+		});
+	};
+	const setupSignalSubscription = () => {
+		state.unsubscribeSignal = sessionSignal.listen(() => {
+			fetchSession();
+		});
+	};
+	const init = () => {
+		if (state.isInitialized) return;
+		state.isInitialized = true;
+		setupPolling();
+		setupBroadcast();
+		setupFocusRefetch();
+		setupOnlineRefetch();
+		setupSignalSubscription();
+		state.cleanupBroadcastSetup = getGlobalBroadcastChannel().setup();
+		state.cleanupFocusSetup = getGlobalFocusManager().setup();
+		state.cleanupOnlineSetup = getGlobalOnlineManager().setup();
+	};
+	const cleanup = () => {
+		if (!state.isInitialized) return;
+		if (state.pollInterval) {
+			clearInterval(state.pollInterval);
+			state.pollInterval = void 0;
+		}
+		if (state.unsubscribeBroadcast) {
+			state.unsubscribeBroadcast();
+			state.unsubscribeBroadcast = void 0;
+		}
+		if (state.unsubscribeFocus) {
+			state.unsubscribeFocus();
+			state.unsubscribeFocus = void 0;
+		}
+		if (state.unsubscribeOnline) {
+			state.unsubscribeOnline();
+			state.unsubscribeOnline = void 0;
+		}
+		if (state.unsubscribeSignal) {
+			state.unsubscribeSignal();
+			state.unsubscribeSignal = void 0;
+		}
+		if (state.cleanupBroadcastSetup) {
+			state.cleanupBroadcastSetup();
+			state.cleanupBroadcastSetup = void 0;
+		}
+		if (state.cleanupFocusSetup) {
+			state.cleanupFocusSetup();
+			state.cleanupFocusSetup = void 0;
+		}
+		if (state.cleanupOnlineSetup) {
+			state.cleanupOnlineSetup();
+			state.cleanupOnlineSetup = void 0;
+		}
+		state.isInitialized = false;
+		state.lastSessionRequest = 0;
+	};
+	return {
+		init,
+		cleanup,
+		triggerRefetch,
+		broadcastSessionUpdate
+	};
+}
+//#endregion
+export { createSessionRefreshManager };

package/dist/client/solid/index.d.mts

@@ -0,0 +1,44 @@
+import { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection } from "../../types/helper.mjs";
+import { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "../types.mjs";
+import { getClientConfig } from "../config.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
+import { Accessor } from "solid-js";
+export * from "nanostores";
+export * from "@better-fetch/fetch";
+
+//#region src/client/solid/index.d.ts
+type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
+  plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends {
+  getAtoms?: infer GetAtoms;
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => Accessor<ReturnType<Atoms[key]["get"]>> } : {} : {} : {}> : {};
+type ClientConfig = ReturnType<typeof getClientConfig>;
+type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
+  getSession: () => Promise<infer Res>;
+} ? Res extends BetterFetchResponse<infer S> ? S : Res : never;
+/**
+ * Solid client returned by `createAuthClient`.
+ */
+type SolidAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+  hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
+  useSession: () => Accessor<{
+    data: ClientSession<Option>;
+    isPending: boolean;
+    isRefetching: boolean;
+    error: BetterFetchError | null;
+    refetch: (queryParams?: {
+      query?: SessionQueryParams;
+    } | undefined) => Promise<void>;
+  }>;
+  $Infer: {
+    Session: NonNullable<ClientSession<Option>>;
+  };
+  $fetch: ClientConfig["$fetch"];
+  $store: ClientConfig["$store"];
+  $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): SolidAuthClient<Option>;
+//#endregion
+export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, SolidAuthClient, StripEmptyObjects, type UnionToIntersection, createAuthClient };

package/dist/client/solid/index.mjs

@@ -0,0 +1,22 @@
+import { getClientConfig } from "../config.mjs";
+import { createDynamicPathProxy } from "../proxy.mjs";
+import { useStore } from "./solid-store.mjs";
+import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
+//#region src/client/solid/index.ts
+function getAtomKey(str) {
+	return `use${capitalizeFirstLetter(str)}`;
+}
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $fetch, $store, atomListeners } = getClientConfig(options);
+	const resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		hydrateSession,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+//#endregion
+export { createAuthClient };

package/dist/client/solid/solid-store.mjs

@@ -0,0 +1,21 @@
+import { onCleanup } from "solid-js";
+import { createStore, reconcile } from "solid-js/store";
+//#region src/client/solid/solid-store.ts
+/**
+* Subscribes to store changes and gets store’s value.
+*
+* @param store Store instance.
+* @returns Store value.
+*/
+function useStore(store) {
+	const unbindActivation = store.listen(() => {});
+	const [state, setState] = createStore({ value: store.get() });
+	const unsubscribe = store.subscribe((newValue) => {
+		setState("value", reconcile(newValue));
+	});
+	onCleanup(() => unsubscribe());
+	unbindActivation();
+	return () => state.value;
+}
+//#endregion
+export { useStore };

package/dist/client/svelte/index.d.mts

@@ -0,0 +1,44 @@
+import { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection } from "../../types/helper.mjs";
+import { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "../types.mjs";
+import { getClientConfig } from "../config.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+import { Atom } from "nanostores";
+import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
+export * from "nanostores";
+export * from "@better-fetch/fetch";
+
+//#region src/client/svelte/index.d.ts
+type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
+  plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends {
+  getAtoms?: infer GetAtoms;
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => Atoms[key] } : {} : {} : {}> : {};
+type ClientConfig = ReturnType<typeof getClientConfig>;
+type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
+  getSession: () => Promise<infer Res>;
+} ? Res extends BetterFetchResponse<infer S> ? S : Res : never;
+/**
+ * Svelte client returned by `createAuthClient`.
+ */
+type SvelteAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+  hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
+  useSession: () => Atom<{
+    data: ClientSession<Option>;
+    error: BetterFetchError | null;
+    isPending: boolean;
+    isRefetching: boolean;
+    refetch: (queryParams?: {
+      query?: SessionQueryParams;
+    } | undefined) => Promise<void>;
+  }>;
+  $fetch: ClientConfig["$fetch"];
+  $store: ClientConfig["$store"];
+  $Infer: {
+    Session: NonNullable<ClientSession<Option>>;
+  };
+  $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): SvelteAuthClient<Option>;
+//#endregion
+export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, SvelteAuthClient, type UnionToIntersection, createAuthClient };

package/dist/client/svelte/index.mjs

@@ -0,0 +1,18 @@
+import { getClientConfig } from "../config.mjs";
+import { createDynamicPathProxy } from "../proxy.mjs";
+import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
+//#region src/client/svelte/index.ts
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $fetch, atomListeners, $store } = getClientConfig(options);
+	const resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[`use${capitalizeFirstLetter(key)}`] = () => value;
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		hydrateSession,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+//#endregion
+export { createAuthClient };

package/dist/client/types.d.mts

@@ -0,0 +1,51 @@
+import { InferFieldsInputClient } from "../db/field.mjs";
+import { StripEmptyObjects, UnionToIntersection } from "../types/helper.mjs";
+import { InferRoutes } from "./path-to-object.mjs";
+import { Session as Session$1, User as User$1 } from "../types/models.mjs";
+import { Auth } from "../types/auth.mjs";
+import { BetterAuthClientOptions as BetterAuthClientOptions$1, BetterAuthClientPlugin, ClientAtomListener as ClientAtomListener$1, ClientStore as ClientStore$1 } from "@better-auth/core";
+import { DBFieldAttribute, InferDBFieldsOutput } from "@better-auth/core/db";
+
+//#region src/client/types.d.ts
+type ClientPluginError<K extends string = string> = {
+  readonly code: K;
+  message: string;
+};
+type InferPluginEndpoints<Plugins> = Plugins extends Array<infer Pl> ? UnionToIntersection<Pl extends {
+  $InferServerPlugin?: infer Plug;
+} ? Plug extends {
+  endpoints?: infer Endpoints;
+} ? Endpoints extends Record<string, unknown> ? Endpoints : {} : {} : {}> : {};
+type InferClientAPI<O extends BetterAuthClientOptions$1> = InferRoutes<O["plugins"] extends Array<any> ? Omit<Auth["api"], keyof InferPluginEndpoints<O["plugins"]>> & InferPluginEndpoints<O["plugins"]> : Auth["api"], O>;
+type InferActions<O extends BetterAuthClientOptions$1> = (O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
+  getActions?: infer GetActions;
+} ? GetActions extends ((...args: any) => infer Actions) ? Actions : {} : {}> : {}) & InferRoutes<O["$InferAuth"] extends {
+  plugins: infer Plugins;
+} ? Plugins extends Array<infer Plugin> ? Plugin extends {
+  endpoints?: infer Endpoints;
+} ? Endpoints extends Record<string, unknown> ? Endpoints : {} : {} : {} : {}, O>;
+type InferErrorCodes<O extends BetterAuthClientOptions$1> = O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
+  $InferServerPlugin?: infer ServerPlugin;
+} ? ServerPlugin extends {
+  $ERROR_CODES?: infer E;
+} ? { [K in keyof E & string]: E[K] extends ClientPluginError ? ClientPluginError<K> : never } : {} : {}> : {};
+/**
+ * signals are just used to recall a computed value.
+ * as a convention they start with "$"
+ */
+type IsSignal<T> = T extends `$${infer _}` ? true : false;
+type InferSessionFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<Session$1 & UnionToIntersection<InferAdditionalFromClient<O, "session", "output">>>;
+type InferUserFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<User$1 & UnionToIntersection<InferAdditionalFromClient<O, "user", "output">>>;
+type InferAdditionalFromClient<Options extends BetterAuthClientOptions$1, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends Array<infer Plugin> ? Plugin extends {
+  $InferServerPlugin?: infer ServerPlugin;
+} ? ServerPlugin extends {
+  schema?: infer Schema;
+} ? Schema extends Record<Key, {
+  fields: infer Fields;
+}> ? Fields extends Record<string, DBFieldAttribute> ? Format extends "input" ? InferFieldsInputClient<Fields> : InferDBFieldsOutput<Fields> : {} : {} : {} : {} : {};
+type SessionQueryParams = {
+  disableCookieCache?: boolean | undefined;
+  disableRefresh?: boolean | undefined;
+};
+//#endregion
+export { type BetterAuthClientOptions$1 as BetterAuthClientOptions, type BetterAuthClientPlugin, type ClientAtomListener$1 as ClientAtomListener, type ClientStore$1 as ClientStore, InferActions, InferAdditionalFromClient, InferClientAPI, InferErrorCodes, InferSessionFromClient, InferUserFromClient, IsSignal, SessionQueryParams };

package/dist/client/vanilla.d.mts

@@ -0,0 +1,42 @@
+import { PrettifyDeep, UnionToIntersection } from "../types/helper.mjs";
+import { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "./types.mjs";
+import { getClientConfig } from "./config.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+import { Atom } from "nanostores";
+import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
+
+//#region src/client/vanilla.d.ts
+type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
+  plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends {
+  getAtoms?: infer GetAtoms;
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: Atoms[key] } : {} : {} : {}> : {};
+type ClientConfig = ReturnType<typeof getClientConfig>;
+type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
+  getSession: () => Promise<infer Res>;
+} ? Res extends BetterFetchResponse<infer S> ? S : Res : never;
+/**
+ * Client returned by `createAuthClient`.
+ */
+type AuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+  hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
+  useSession: Atom<{
+    data: ClientSession<Option>;
+    error: BetterFetchError | null;
+    isPending: boolean;
+    isRefetching: boolean;
+    refetch: (queryParams?: {
+      query?: SessionQueryParams;
+    } | undefined) => Promise<void>;
+  }>;
+  $fetch: ClientConfig["$fetch"];
+  $store: ClientConfig["$store"];
+  $Infer: {
+    Session: NonNullable<ClientSession<Option>>;
+  };
+  $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): AuthClient<Option>;
+//#endregion
+export { AuthClient, createAuthClient };

package/dist/client/vanilla.mjs

@@ -0,0 +1,18 @@
+import { getClientConfig } from "./config.mjs";
+import { createDynamicPathProxy } from "./proxy.mjs";
+import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
+//#region src/client/vanilla.ts
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $fetch, atomListeners, $store } = getClientConfig(options);
+	const resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[`use${capitalizeFirstLetter(key)}`] = value;
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		hydrateSession,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+//#endregion
+export { createAuthClient };

package/dist/client/vue/index.d.mts

@@ -0,0 +1,67 @@
+import { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection } from "../../types/helper.mjs";
+import { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "../types.mjs";
+import { getClientConfig } from "../config.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
+import { DeepReadonly, Ref, WatchSource } from "vue";
+export * from "nanostores";
+export * from "@better-fetch/fetch";
+
+//#region src/client/vue/index.d.ts
+type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
+  plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends {
+  getAtoms?: infer GetAtoms;
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => DeepReadonly<Ref<ReturnType<Atoms[key]["get"]>>> } : {} : {} : {}> : {};
+type ClientConfig = ReturnType<typeof getClientConfig>;
+type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
+  getSession: () => Promise<infer Res>;
+} ? Res extends BetterFetchResponse<infer S> ? S : Res : never;
+/**
+ * Minimal Nuxt-compatible fetch contract for `useSession(useFetch)`.
+ * Compatibility with Nuxt's `useFetch` and `UseFetchOptions` is checked by the Nuxt fixture type test.
+ */
+type SessionFetch = (url: string, options: {
+  headers?: HeadersInit;
+  key: string;
+  watch: WatchSource<unknown>[];
+}) => Promise<{
+  data: Ref<unknown>;
+  error: Ref<unknown>;
+}>;
+type VueSessionState<Option extends BetterAuthClientOptions> = DeepReadonly<Ref<{
+  data: ClientSession<Option>;
+  isPending: boolean;
+  isRefetching: boolean;
+  error: BetterFetchError | null;
+  refetch: (queryParams?: {
+    query?: SessionQueryParams;
+  } | undefined) => Promise<void>;
+}>>;
+type SessionFetchResult<Option extends BetterAuthClientOptions> = {
+  data: Ref<ClientSession<Option>>;
+  isPending: false;
+  error: Ref<{
+    message?: string | undefined;
+    status: number;
+    statusText: string;
+  }>;
+};
+/**
+ * Vue client returned by `createAuthClient`.
+ */
+type VueAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+  hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
+  useSession(): VueSessionState<Option>;
+  useSession(useFetch: SessionFetch): Promise<SessionFetchResult<Option>>;
+  $Infer: {
+    Session: NonNullable<ClientSession<Option>>;
+  };
+  $fetch: ClientConfig["$fetch"];
+  $store: ClientConfig["$store"];
+  $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): VueAuthClient<Option>;
+//#endregion
+export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, type UnionToIntersection, VueAuthClient, createAuthClient };

package/dist/client/vue/index.mjs

@@ -0,0 +1,54 @@
+import { getClientConfig } from "../config.mjs";
+import { createDynamicPathProxy } from "../proxy.mjs";
+import { useStore } from "./vue-store.mjs";
+import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
+//#region src/client/vue/index.ts
+function getAtomKey(str) {
+	return `use${capitalizeFirstLetter(str)}`;
+}
+/** Preserves standard `HeadersInit` values and removes undefined record entries. */
+function toHeadersInit(headers) {
+	if (!headers) return void 0;
+	if (headers instanceof Headers || Array.isArray(headers)) return headers;
+	const normalizedHeaders = {};
+	for (const [name, value] of Object.entries(headers)) if (value !== void 0) normalizedHeaders[name] = value;
+	return normalizedHeaders;
+}
+function createAuthClient(options) {
+	const { baseURL, pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $sessionSignal, $fetch, $store, atomListeners } = getClientConfig(options, false);
+	const sessionCacheKey = [
+		"better-auth",
+		"session",
+		options?.baseURL || "inferred",
+		options?.basePath ?? "/api/auth"
+	].join(":");
+	const resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
+	function useSession(useFetch) {
+		if (useFetch) {
+			const sessionSignal = useStore($sessionSignal);
+			return useFetch(`${baseURL}/get-session`, {
+				headers: toHeadersInit(options?.fetchOptions?.headers),
+				key: sessionCacheKey,
+				watch: [sessionSignal]
+			}).then((result) => {
+				return {
+					data: result.data,
+					isPending: false,
+					error: result.error
+				};
+			});
+		}
+		return resolvedHooks.useSession();
+	}
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		hydrateSession,
+		useSession,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+//#endregion
+export { createAuthClient };

package/dist/client/vue/vue-store.mjs

@@ -0,0 +1,23 @@
+import { getCurrentInstance, getCurrentScope, onScopeDispose, readonly, shallowRef } from "vue";
+//#region src/client/vue/vue-store.ts
+function registerStore(store) {
+	const instance = getCurrentInstance();
+	if (instance && instance.proxy) {
+		const vm = instance.proxy;
+		("_nanostores" in vm ? vm._nanostores : vm._nanostores = []).push(store);
+	}
+}
+function useStore(store) {
+	const state = shallowRef();
+	const unsubscribe = store.subscribe((value) => {
+		state.value = value;
+	});
+	if (getCurrentScope()) onScopeDispose(unsubscribe);
+	if (process.env.NODE_ENV !== "production") {
+		registerStore(store);
+		return readonly(state);
+	}
+	return state;
+}
+//#endregion
+export { useStore };