@better-auth-ui/react 1.6.3 → 1.6.5

package/dist/mutations/settings/change-password-mutation.d.ts

@@ -0,0 +1,78 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type ChangePasswordParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["changePassword"]>[0];
+export type ChangePasswordOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof changePasswordOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for changing the authenticated user's password.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function changePasswordOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<Omit<{
+    token: string | null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any> & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, ChangePasswordParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for changing the authenticated user's password.
+ *
+ * Wraps `authClient.changePassword` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useChangePassword<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: ChangePasswordOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+    token: string | null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any> & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, ChangePasswordParams<TAuthClient>, unknown>;

package/dist/mutations/settings/change-password-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/change-password-mutation.ts
+function r(n) {
+	let r = e.changePassword;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.changePassword({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as changePasswordOptions, i as useChangePassword };

package/dist/mutations/settings/delete-user-mutation.d.ts

@@ -0,0 +1,26 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type DeleteUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["deleteUser"]>[0];
+export type DeleteUserOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof deleteUserOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for deleting the authenticated user's account.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function deleteUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    success: boolean;
+    message: string;
+}, BetterFetchError, DeleteUserParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for deleting the authenticated user's account.
+ *
+ * Wraps `authClient.deleteUser` and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useDeleteUser<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: DeleteUserOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    success: boolean;
+    message: string;
+}, BetterFetchError, DeleteUserParams<TAuthClient>, unknown>;

package/dist/mutations/settings/delete-user-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/delete-user-mutation.ts
+function r(n) {
+	let r = e.deleteUser;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.deleteUser({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as deleteUserOptions, i as useDeleteUser };

package/dist/mutations/settings/link-social-mutation.d.ts

@@ -0,0 +1,26 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type LinkSocialParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["linkSocial"]>[0];
+export type LinkSocialOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof linkSocialOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for linking a social provider to the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function linkSocialOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    url: string;
+    redirect: boolean;
+}, BetterFetchError, LinkSocialParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for linking a social provider to the current user.
+ *
+ * Wraps `authClient.linkSocial` to initiate a provider redirect and forwards
+ * React Query mutation options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useLinkSocial<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: LinkSocialOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    url: string;
+    redirect: boolean;
+}, BetterFetchError, LinkSocialParams<TAuthClient>, unknown>;

package/dist/mutations/settings/link-social-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/link-social-mutation.ts
+function r(n) {
+	let r = e.linkSocial;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.linkSocial({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as linkSocialOptions, i as useLinkSocial };

package/dist/mutations/settings/revoke-session-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["revokeSession"]>[0];
+export type RevokeSessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof revokeSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for revoking a user session.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function revokeSessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, RevokeSessionParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for revoking a user session.
+ *
+ * Wraps `authClient.revokeSession`, refetches the sessions list on success,
+ * and forwards React Query mutation options such as `onSuccess`, `onError`,
+ * and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useRevokeSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RevokeSessionOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, RevokeSessionParams<TAuthClient>, unknown>;

package/dist/mutations/settings/revoke-session-mutation.js

@@ -0,0 +1,29 @@
+import { useListSessions as e } from "../../queries/settings/list-sessions-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r } from "@tanstack/react-query";
+//#region src/mutations/settings/revoke-session-mutation.ts
+function i(e) {
+	let r = t.revokeSession;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.revokeSession({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, n) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return r({
+		...i(t),
+		...n,
+		onSuccess: async (...e) => {
+			await a(), await n?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as revokeSessionOptions, a as useRevokeSession };

package/dist/mutations/settings/unlink-account-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type UnlinkAccountParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["unlinkAccount"]>[0];
+export type UnlinkAccountOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof unlinkAccountOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for unlinking a social provider from the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function unlinkAccountOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, UnlinkAccountParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for unlinking a social provider from the current user.
+ *
+ * Wraps `authClient.unlinkAccount`, refetches the linked accounts list on
+ * success, and forwards React Query mutation options such as `onSuccess`,
+ * `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useUnlinkAccount<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UnlinkAccountOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, UnlinkAccountParams<TAuthClient>, unknown>;

package/dist/mutations/settings/unlink-account-mutation.js

@@ -0,0 +1,29 @@
+import { useListAccounts as e } from "../../queries/settings/list-accounts-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r } from "@tanstack/react-query";
+//#region src/mutations/settings/unlink-account-mutation.ts
+function i(e) {
+	let r = t.unlinkAccount;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.unlinkAccount({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, n) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return r({
+		...i(t),
+		...n,
+		onSuccess: async (...e) => {
+			await a(), await n?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as unlinkAccountOptions, a as useUnlinkAccount };

package/dist/mutations/settings/update-user-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["updateUser"]>[0];
+export type UpdateUserOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof updateUserOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for updating the authenticated user's profile.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function updateUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, UpdateUserParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for updating the authenticated user's profile.
+ *
+ * Wraps `authClient.updateUser`, optimistically patches the cached session
+ * with the new fields, refetches the session, and forwards React Query
+ * mutation options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useUpdateUser<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UpdateUserOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, UpdateUserParams<TAuthClient>, unknown>;

package/dist/mutations/settings/update-user-mutation.js

@@ -0,0 +1,35 @@
+import { sessionOptions as e, useSession as t } from "../../queries/auth/session-query.js";
+import { authMutationKeys as n } from "@better-auth-ui/core";
+import { mutationOptions as r, useMutation as i, useQueryClient as a } from "@tanstack/react-query";
+//#region src/mutations/settings/update-user-mutation.ts
+function o(e) {
+	let t = n.updateUser;
+	return r({
+		mutationKey: t,
+		mutationFn: (t) => e.updateUser({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function s(n, r) {
+	let { data: s, refetch: c } = t(n, { refetchOnMount: !1 }), l = a();
+	return i({
+		...o(n),
+		...r,
+		onSuccess: async (t, i, ...a) => {
+			s && l.setQueryData(e(n).queryKey, {
+				...s,
+				user: {
+					...s.user,
+					...i
+				}
+			}), c(), await r?.onSuccess?.(t, i, ...a);
+		}
+	});
+}
+//#endregion
+export { o as updateUserOptions, s as useUpdateUser };

package/dist/mutations/username/is-username-available-mutation.d.ts

@@ -0,0 +1,27 @@
+import { BetterFetchError } from 'better-auth/react';
+import { UsernameAuthClient } from '../../lib/auth-client';
+export type IsUsernameAvailableParams<TAuthClient extends UsernameAuthClient> = Parameters<TAuthClient["isUsernameAvailable"]>[0];
+export type IsUsernameAvailableOptions<TAuthClient extends UsernameAuthClient> = Omit<ReturnType<typeof isUsernameAvailableOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for checking username availability.
+ *
+ * Modeled as a mutation because callers typically trigger the check on
+ * user action (debounced input, form submit) rather than on mount.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function isUsernameAvailableOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    available: boolean;
+}, BetterFetchError, IsUsernameAvailableParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for checking whether a username is available.
+ *
+ * Wraps `authClient.isUsernameAvailable` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the username plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useIsUsernameAvailable<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient, options?: IsUsernameAvailableOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    available: boolean;
+}, BetterFetchError, IsUsernameAvailableParams<TAuthClient>, unknown>;

package/dist/mutations/username/is-username-available-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/username/is-username-available-mutation.ts
+function r(n) {
+	let r = e.isUsernameAvailable;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.isUsernameAvailable({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as isUsernameAvailableOptions, i as useIsUsernameAvailable };

package/dist/mutations/username/sign-in-username-mutation.d.ts

@@ -0,0 +1,75 @@
+import { BetterFetchError } from 'better-auth/react';
+import { UsernameAuthClient } from '../../lib/auth-client';
+export type SignInUsernameParams<TAuthClient extends UsernameAuthClient> = Parameters<TAuthClient["signIn"]["username"]>[0];
+export type SignInUsernameOptions<TAuthClient extends UsernameAuthClient> = Omit<ReturnType<typeof signInUsernameOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for username/password sign-in.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {
+        username: string;
+        displayUsername: string;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {} & {
+        username?: string | null | undefined;
+        displayUsername?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInUsernameParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for username/password sign-in.
+ *
+ * Wraps `authClient.signIn.username`, resets the session query on success so
+ * the new session is refetched, and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the username plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignInUsername<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient, options?: SignInUsernameOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {
+        username: string;
+        displayUsername: string;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {} & {
+        username?: string | null | undefined;
+        displayUsername?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInUsernameParams<TAuthClient>, unknown>;

package/dist/mutations/username/sign-in-username-mutation.js

@@ -0,0 +1,29 @@
+import { sessionOptions as e } from "../../queries/auth/session-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r, useQueryClient as i } from "@tanstack/react-query";
+//#region src/mutations/username/sign-in-username-mutation.ts
+function a(e) {
+	let r = t.signIn.username;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.signIn.username({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function o(t, n) {
+	let o = i();
+	return r({
+		...a(t),
+		...n,
+		onSuccess: async (...r) => {
+			o.resetQueries({ queryKey: e(t).queryKey }), await n?.onSuccess?.(...r);
+		}
+	});
+}
+//#endregion
+export { a as signInUsernameOptions, o as useSignInUsername };

package/dist/plugins/captcha-plugin.d.ts

@@ -0,0 +1,29 @@
+import { ComponentType } from 'react';
+/** Props passed to the consumer's `render` component. */
+export type CaptchaRenderProps = {
+    /** Call once the user solves the captcha. */
+    setToken: (token: string) => void;
+    /** Call on error/expire to clear the token. */
+    clearToken: () => void;
+    /**
+     * Register your widget's `reset()`. Forms call it after a failed
+     * submission since captcha tokens are single-use. Pass `null` on unmount.
+     */
+    setReset: (reset: (() => void) | null) => void;
+};
+export type CaptchaPluginOptions = {
+    /** Renders the captcha widget. Wire `setToken`, `clearToken`, `setReset`. */
+    render: ComponentType<CaptchaRenderProps>;
+};
+/**
+ * Provider-agnostic captcha plugin. Forwards the resolved token via the
+ * `x-captcha-response` header on Better Auth requests.
+ */
+export declare const captchaPlugin: ((args_0: CaptchaPluginOptions) => Omit<{
+    render: ComponentType<CaptchaRenderProps>;
+    captchaComponent: import("react/jsx-runtime").JSX.Element;
+}, "id"> & {
+    id: "captcha";
+}) & {
+    id: "captcha";
+};

package/dist/plugins/captcha-plugin.js

@@ -0,0 +1,29 @@
+"use client";
+import { useFetchOptions as e } from "../components/auth/fetch-options-provider.js";
+import { useAuthPlugin as t } from "../hooks/use-auth-plugin.js";
+import { createAuthPlugin as n } from "@better-auth-ui/core";
+import { useCallback as r, useEffect as i } from "react";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/plugins/captcha-plugin.tsx
+function o() {
+	let { render: n } = t(s), { setFetchOptions: o, registerReset: c } = e(), l = r((e) => {
+		o({ headers: { "x-captcha-response": e } });
+	}, [o]), u = r(() => {
+		o(void 0);
+	}, [o]), d = r((e) => {
+		c(e);
+	}, [c]);
+	return i(() => () => {
+		o(void 0), c(null);
+	}, [o, c]), /* @__PURE__ */ a(n, {
+		setToken: l,
+		clearToken: u,
+		setReset: d
+	});
+}
+var s = n("captcha", ({ render: e }) => ({
+	render: e,
+	captchaComponent: /* @__PURE__ */ a(o, {})
+}));
+//#endregion
+export { s as captchaPlugin };

package/dist/plugins.d.ts

@@ -0,0 +1 @@
+export * from './plugins/captcha-plugin';

package/dist/plugins.js

@@ -0,0 +1,3 @@
+"use client";
+import { captchaPlugin as e } from "./plugins/captcha-plugin.js";
+export { e as captchaPlugin };