payload-auth 1.1.2 → 1.3.0

package/dist/better-auth/plugin/payload/views/admin-login/client.js

@@ -0,0 +1,175 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { AdminSocialProviderButtons } from "../../components/social-provider-buttons";
+import { getSafeRedirect } from "../../utils/get-safe-redirect";
+import { useConfig, Link, toast, useTranslation } from "@payloadcms/ui";
+import React, { useMemo, useState } from "react";
+import { adminRoutes } from "../../../constants";
+import { useAppForm } from "../../../../../shared/form";
+import { Form, FormError, FormInputWrap } from "../../../../../shared/form/ui";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+import { createLoginSchema, isValidEmail } from "../../../../../shared/form/validation";
+import { createAuthClient } from "better-auth/client";
+import { usernameClient } from "better-auth/client/plugins";
+import { formatAdminURL, getLoginOptions } from "payload/shared";
+const baseClass = 'login__form';
+const LoginForm = ({ hasUsernamePlugin, prefillEmail, prefillPassword, prefillUsername, searchParams, loginWithUsername })=>{
+    const { config } = useConfig();
+    const { t } = useTranslation();
+    const { canLoginWithEmail, canLoginWithUsername } = getLoginOptions(loginWithUsername);
+    const searchParamError = searchParams?.error;
+    const redirectUrl = getSafeRedirect(searchParams?.redirect, config.routes.admin);
+    const forgotPasswordUrl = formatAdminURL({
+        adminRoute: config.routes.admin,
+        path: adminRoutes?.forgotPassword
+    });
+    const authClient = useMemo(()=>createAuthClient({
+            plugins: [
+                usernameClient()
+            ]
+        }), []);
+    const loginType = useMemo(()=>{
+        if (canLoginWithEmail && canLoginWithUsername && hasUsernamePlugin) return 'emailOrUsername';
+        if (canLoginWithUsername && hasUsernamePlugin) return 'username';
+        return 'email';
+    }, [
+        canLoginWithEmail,
+        canLoginWithUsername,
+        hasUsernamePlugin
+    ]);
+    const [requireEmailVerification, setRequireEmailVerification] = useState(false);
+    if (requireEmailVerification) {
+        return /*#__PURE__*/ _jsx(FormHeader, {
+            heading: "Please verify your email",
+            description: t('authentication:emailSent'),
+            style: {
+                textAlign: 'center'
+            }
+        });
+    }
+    const loginSchema = createLoginSchema({
+        t,
+        loginType,
+        canLoginWithUsername
+    });
+    const form = useAppForm({
+        defaultValues: {
+            login: prefillEmail ?? prefillUsername ?? '',
+            password: prefillPassword ?? ''
+        },
+        onSubmit: async ({ value })=>{
+            const { login, password } = value;
+            const isEmail = isValidEmail(login);
+            try {
+                const { data, error } = await (loginType === 'email' || loginType === 'emailOrUsername' && isEmail ? authClient.signIn.email({
+                    email: login,
+                    password,
+                    callbackURL: redirectUrl
+                }) : authClient.signIn.username({
+                    username: login,
+                    password
+                }));
+                if (error) {
+                    if (error.code === 'EMAIL_NOT_VERIFIED') {
+                        setRequireEmailVerification(true);
+                    }
+                    if (error.message) {
+                        toast.error(error.message.charAt(0).toUpperCase() + error.message.slice(1));
+                    }
+                }
+                if (data?.token) {
+                    toast.success(t('general:success'));
+                    window.location.href = redirectUrl;
+                }
+            } catch (err) {
+                toast.error(t('error:unknown') || 'An unexpected error occurred');
+            }
+        },
+        validators: {
+            onSubmit: loginSchema
+        }
+    });
+    const getLoginTypeLabel = ()=>{
+        const labels = {
+            email: t('general:email') || 'Email',
+            username: t('authentication:username') || 'Username',
+            emailOrUsername: t('authentication:emailOrUsername') || 'Email or Username'
+        };
+        return labels[loginType];
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: `${baseClass}__wrapper`,
+        children: [
+            searchParamError && searchParamError === 'signup_disabled' && /*#__PURE__*/ _jsx(FormError, {
+                errors: [
+                    'Sign up is disabled.'
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Form, {
+                className: baseClass,
+                onSubmit: (e)=>{
+                    e.preventDefault();
+                    void form.handleSubmit();
+                },
+                children: [
+                    /*#__PURE__*/ _jsxs(FormInputWrap, {
+                        className: baseClass,
+                        children: [
+                            /*#__PURE__*/ _jsx(form.AppField, {
+                                name: "login",
+                                children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                        type: "text",
+                                        className: "email",
+                                        autoComplete: "email",
+                                        label: getLoginTypeLabel()
+                                    })
+                            }),
+                            /*#__PURE__*/ _jsx(form.AppField, {
+                                name: "password",
+                                children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                        type: "password",
+                                        className: "password",
+                                        autoComplete: "password",
+                                        label: t('general:password')
+                                    })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(Link, {
+                        href: forgotPasswordUrl,
+                        prefetch: false,
+                        children: t('authentication:forgotPasswordQuestion')
+                    }),
+                    /*#__PURE__*/ _jsx(form.AppForm, {
+                        children: /*#__PURE__*/ _jsx(form.Submit, {
+                            label: t('authentication:login'),
+                            loadingLabel: t('general:loading')
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+export const AdminLoginClient = ({ loginMethods, hasUsernamePlugin, prefillEmail, prefillPassword, prefillUsername, searchParams, loginWithUsername })=>{
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            loginMethods.includes('emailPassword') && /*#__PURE__*/ _jsx(LoginForm, {
+                hasUsernamePlugin: hasUsernamePlugin,
+                prefillEmail: prefillEmail,
+                prefillPassword: prefillPassword,
+                prefillUsername: prefillUsername,
+                searchParams: searchParams,
+                loginWithUsername: loginWithUsername
+            }),
+            /*#__PURE__*/ _jsx(AdminSocialProviderButtons, {
+                isSignup: false,
+                loginMethods: loginMethods,
+                setLoading: ()=>{},
+                redirectUrl: getSafeRedirect(searchParams?.redirect, useConfig().config.routes.admin)
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/views/admin-login/client.tsx"],"sourcesContent":["'use client'\n\nimport { AdminSocialProviderButtons } from '@/better-auth/plugin/payload/components/social-provider-buttons'\nimport { getSafeRedirect } from '@/better-auth/plugin/payload/utils/get-safe-redirect'\nimport { useConfig, Link, toast, useTranslation } from '@payloadcms/ui'\nimport React, { useMemo, useState } from 'react'\nimport type { LoginMethod } from '@/better-auth/plugin/types'\nimport type { LoginWithUsernameOptions } from 'payload'\nimport { adminRoutes } from '@/better-auth/plugin/constants'\nimport { useAppForm } from '@/shared/form'\nimport { Form, FormError, FormInputWrap } from '@/shared/form/ui'\nimport { FormHeader } from '@/shared/form/ui/header'\nimport { createLoginSchema, isValidEmail } from '@/shared/form/validation'\nimport { createAuthClient } from 'better-auth/client'\nimport { usernameClient } from 'better-auth/client/plugins'\nimport { formatAdminURL, getLoginOptions } from 'payload/shared'\n\ntype AdminLoginClientProps = {\n  loginMethods: LoginMethod[]\n  hasUsernamePlugin: boolean\n  prefillEmail?: string\n  prefillPassword?: string\n  prefillUsername?: string\n  searchParams: { [key: string]: string | string[] | undefined }\n  loginWithUsername: false | LoginWithUsernameOptions\n}\n\nconst baseClass = 'login__form'\n\nconst LoginForm: React.FC<{\n  hasUsernamePlugin: boolean\n  prefillEmail?: string\n  prefillPassword?: string\n  prefillUsername?: string\n  searchParams: { [key: string]: string | string[] | undefined }\n  loginWithUsername: false | LoginWithUsernameOptions\n}> = ({\n  hasUsernamePlugin,\n  prefillEmail,\n  prefillPassword,\n  prefillUsername,\n  searchParams,\n  loginWithUsername\n}) => {\n  const { config } = useConfig()\n  const { t } = useTranslation()\n  const { canLoginWithEmail, canLoginWithUsername } = getLoginOptions(loginWithUsername)\n  const searchParamError = searchParams?.error\n  const redirectUrl = getSafeRedirect(searchParams?.redirect as string, config.routes.admin)\n  const forgotPasswordUrl = formatAdminURL({\n    adminRoute: config.routes.admin,\n    path: adminRoutes?.forgotPassword as `/${string}`\n  })\n  const authClient = useMemo(() => createAuthClient({ plugins: [usernameClient()] }), [])\n  const loginType = useMemo(() => {\n    if (canLoginWithEmail && canLoginWithUsername && hasUsernamePlugin) return 'emailOrUsername'\n    if (canLoginWithUsername && hasUsernamePlugin) return 'username'\n    return 'email'\n  }, [canLoginWithEmail, canLoginWithUsername, hasUsernamePlugin])\n  const [requireEmailVerification, setRequireEmailVerification] = useState<boolean>(false)\n\n  if (requireEmailVerification) {\n    return <FormHeader heading=\"Please verify your email\" description={t('authentication:emailSent')} style={{ textAlign: 'center' }} />\n  }\n\n  const loginSchema = createLoginSchema({ t, loginType, canLoginWithUsername })\n\n  const form = useAppForm({\n    defaultValues: {\n      login: prefillEmail ?? prefillUsername ?? '',\n      password: prefillPassword ?? ''\n    },\n    onSubmit: async ({ value }) => {\n      const { login, password } = value\n      const isEmail = isValidEmail(login)\n      try {\n        const { data, error } = await (loginType === 'email' || (loginType === 'emailOrUsername' && isEmail)\n          ? authClient.signIn.email({ email: login, password, callbackURL: redirectUrl })\n          : authClient.signIn.username({ username: login, password }))\n        if (error) {\n          if (error.code === 'EMAIL_NOT_VERIFIED') {\n            setRequireEmailVerification(true)\n          }\n          if (error.message) {\n            toast.error(error.message.charAt(0).toUpperCase() + error.message.slice(1))\n          }\n        }\n        if (data?.token) {\n          toast.success(t('general:success'))\n          window.location.href = redirectUrl\n        }\n      } catch (err) {\n        toast.error(t('error:unknown') || 'An unexpected error occurred')\n      }\n    },\n    validators: {\n      onSubmit: loginSchema\n    }\n  })\n\n  const getLoginTypeLabel = () => {\n    const labels = {\n      email: t('general:email') || 'Email',\n      username: t('authentication:username') || 'Username',\n      emailOrUsername: t('authentication:emailOrUsername') || 'Email or Username'\n    }\n    return labels[loginType]\n  }\n\n  return (\n    <div className={`${baseClass}__wrapper`}>\n      {searchParamError && searchParamError === 'signup_disabled' && <FormError errors={['Sign up is disabled.']} />}\n      <Form\n        className={baseClass}\n        onSubmit={e => {\n          e.preventDefault()\n          void form.handleSubmit()\n        }}\n      >\n        <FormInputWrap className={baseClass}>\n          <form.AppField\n            name=\"login\"\n            children={field => <field.TextField type=\"text\" className=\"email\" autoComplete=\"email\" label={getLoginTypeLabel()} />}\n          />\n          <form.AppField\n            name=\"password\"\n            children={field => (\n              <field.TextField type=\"password\" className=\"password\" autoComplete=\"password\" label={t('general:password')} />\n            )}\n          />\n        </FormInputWrap>\n        <Link href={forgotPasswordUrl} prefetch={false}>\n          {t('authentication:forgotPasswordQuestion')}\n        </Link>\n        <form.AppForm children={<form.Submit label={t('authentication:login')} loadingLabel={t('general:loading')} />} />\n      </Form>\n    </div>\n  )\n}\n\nexport const AdminLoginClient: React.FC<AdminLoginClientProps> = ({\n  loginMethods,\n  hasUsernamePlugin,\n  prefillEmail,\n  prefillPassword,\n  prefillUsername,\n  searchParams,\n  loginWithUsername\n}) => {\n  return (\n    <>\n      {loginMethods.includes('emailPassword') && (\n        <LoginForm\n          hasUsernamePlugin={hasUsernamePlugin}\n          prefillEmail={prefillEmail}\n          prefillPassword={prefillPassword}\n          prefillUsername={prefillUsername}\n          searchParams={searchParams}\n          loginWithUsername={loginWithUsername}\n        />\n      )}\n      <AdminSocialProviderButtons\n        isSignup={false}\n        loginMethods={loginMethods}\n        setLoading={() => {}}\n        redirectUrl={getSafeRedirect(searchParams?.redirect as string, useConfig().config.routes.admin)}\n      />\n    </>\n  )\n}\n"],"names":["AdminSocialProviderButtons","getSafeRedirect","useConfig","Link","toast","useTranslation","React","useMemo","useState","adminRoutes","useAppForm","Form","FormError","FormInputWrap","FormHeader","createLoginSchema","isValidEmail","createAuthClient","usernameClient","formatAdminURL","getLoginOptions","baseClass","LoginForm","hasUsernamePlugin","prefillEmail","prefillPassword","prefillUsername","searchParams","loginWithUsername","config","t","canLoginWithEmail","canLoginWithUsername","searchParamError","error","redirectUrl","redirect","routes","admin","forgotPasswordUrl","adminRoute","path","forgotPassword","authClient","plugins","loginType","requireEmailVerification","setRequireEmailVerification","heading","description","style","textAlign","loginSchema","form","defaultValues","login","password","onSubmit","value","isEmail","data","signIn","email","callbackURL","username","code","message","charAt","toUpperCase","slice","token","success","window","location","href","err","validators","getLoginTypeLabel","labels","emailOrUsername","div","className","errors","e","preventDefault","handleSubmit","AppField","name","children","field","TextField","type","autoComplete","label","prefetch","AppForm","Submit","loadingLabel","AdminLoginClient","loginMethods","includes","isSignup","setLoading"],"mappings":"AAAA;;AAEA,SAASA,0BAA0B,QAAQ,2CAAiE;AAC5G,SAASC,eAAe,QAAQ,gCAAsD;AACtF,SAASC,SAAS,EAAEC,IAAI,EAAEC,KAAK,EAAEC,cAAc,QAAQ,iBAAgB;AACvE,OAAOC,SAASC,OAAO,EAAEC,QAAQ,QAAQ,QAAO;AAGhD,SAASC,WAAW,QAAQ,qBAAgC;AAC5D,SAASC,UAAU,QAAQ,6BAAe;AAC1C,SAASC,IAAI,EAAEC,SAAS,EAAEC,aAAa,QAAQ,gCAAkB;AACjE,SAASC,UAAU,QAAQ,uCAAyB;AACpD,SAASC,iBAAiB,EAAEC,YAAY,QAAQ,wCAA0B;AAC1E,SAASC,gBAAgB,QAAQ,qBAAoB;AACrD,SAASC,cAAc,QAAQ,6BAA4B;AAC3D,SAASC,cAAc,EAAEC,eAAe,QAAQ,iBAAgB;AAYhE,MAAMC,YAAY;AAElB,MAAMC,YAOD,CAAC,EACJC,iBAAiB,EACjBC,YAAY,EACZC,eAAe,EACfC,eAAe,EACfC,YAAY,EACZC,iBAAiB,EAClB;IACC,MAAM,EAAEC,MAAM,EAAE,GAAG3B;IACnB,MAAM,EAAE4B,CAAC,EAAE,GAAGzB;IACd,MAAM,EAAE0B,iBAAiB,EAAEC,oBAAoB,EAAE,GAAGZ,gBAAgBQ;IACpE,MAAMK,mBAAmBN,cAAcO;IACvC,MAAMC,cAAclC,gBAAgB0B,cAAcS,UAAoBP,OAAOQ,MAAM,CAACC,KAAK;IACzF,MAAMC,oBAAoBpB,eAAe;QACvCqB,YAAYX,OAAOQ,MAAM,CAACC,KAAK;QAC/BG,MAAMhC,aAAaiC;IACrB;IACA,MAAMC,aAAapC,QAAQ,IAAMU,iBAAiB;YAAE2B,SAAS;gBAAC1B;aAAiB;QAAC,IAAI,EAAE;IACtF,MAAM2B,YAAYtC,QAAQ;QACxB,IAAIwB,qBAAqBC,wBAAwBT,mBAAmB,OAAO;QAC3E,IAAIS,wBAAwBT,mBAAmB,OAAO;QACtD,OAAO;IACT,GAAG;QAACQ;QAAmBC;QAAsBT;KAAkB;IAC/D,MAAM,CAACuB,0BAA0BC,4BAA4B,GAAGvC,SAAkB;IAElF,IAAIsC,0BAA0B;QAC5B,qBAAO,KAAChC;YAAWkC,SAAQ;YAA2BC,aAAanB,EAAE;YAA6BoB,OAAO;gBAAEC,WAAW;YAAS;;IACjI;IAEA,MAAMC,cAAcrC,kBAAkB;QAAEe;QAAGe;QAAWb;IAAqB;IAE3E,MAAMqB,OAAO3C,WAAW;QACtB4C,eAAe;YACbC,OAAO/B,gBAAgBE,mBAAmB;YAC1C8B,UAAU/B,mBAAmB;QAC/B;QACAgC,UAAU,OAAO,EAAEC,KAAK,EAAE;YACxB,MAAM,EAAEH,KAAK,EAAEC,QAAQ,EAAE,GAAGE;YAC5B,MAAMC,UAAU3C,aAAauC;YAC7B,IAAI;gBACF,MAAM,EAAEK,IAAI,EAAE1B,KAAK,EAAE,GAAG,MAAOW,CAAAA,cAAc,WAAYA,cAAc,qBAAqBc,UACxFhB,WAAWkB,MAAM,CAACC,KAAK,CAAC;oBAAEA,OAAOP;oBAAOC;oBAAUO,aAAa5B;gBAAY,KAC3EQ,WAAWkB,MAAM,CAACG,QAAQ,CAAC;oBAAEA,UAAUT;oBAAOC;gBAAS,EAAC;gBAC5D,IAAItB,OAAO;oBACT,IAAIA,MAAM+B,IAAI,KAAK,sBAAsB;wBACvClB,4BAA4B;oBAC9B;oBACA,IAAIb,MAAMgC,OAAO,EAAE;wBACjB9D,MAAM8B,KAAK,CAACA,MAAMgC,OAAO,CAACC,MAAM,CAAC,GAAGC,WAAW,KAAKlC,MAAMgC,OAAO,CAACG,KAAK,CAAC;oBAC1E;gBACF;gBACA,IAAIT,MAAMU,OAAO;oBACflE,MAAMmE,OAAO,CAACzC,EAAE;oBAChB0C,OAAOC,QAAQ,CAACC,IAAI,GAAGvC;gBACzB;YACF,EAAE,OAAOwC,KAAK;gBACZvE,MAAM8B,KAAK,CAACJ,EAAE,oBAAoB;YACpC;QACF;QACA8C,YAAY;YACVnB,UAAUL;QACZ;IACF;IAEA,MAAMyB,oBAAoB;QACxB,MAAMC,SAAS;YACbhB,OAAOhC,EAAE,oBAAoB;YAC7BkC,UAAUlC,EAAE,8BAA8B;YAC1CiD,iBAAiBjD,EAAE,qCAAqC;QAC1D;QACA,OAAOgD,MAAM,CAACjC,UAAU;IAC1B;IAEA,qBACE,MAACmC;QAAIC,WAAW,GAAG5D,UAAU,SAAS,CAAC;;YACpCY,oBAAoBA,qBAAqB,mCAAqB,KAACrB;gBAAUsE,QAAQ;oBAAC;iBAAuB;;0BAC1G,MAACvE;gBACCsE,WAAW5D;gBACXoC,UAAU0B,CAAAA;oBACRA,EAAEC,cAAc;oBAChB,KAAK/B,KAAKgC,YAAY;gBACxB;;kCAEA,MAACxE;wBAAcoE,WAAW5D;;0CACxB,KAACgC,KAAKiC,QAAQ;gCACZC,MAAK;gCACLC,UAAUC,CAAAA,sBAAS,KAACA,MAAMC,SAAS;wCAACC,MAAK;wCAAOV,WAAU;wCAAQW,cAAa;wCAAQC,OAAOhB;;;0CAEhG,KAACxB,KAAKiC,QAAQ;gCACZC,MAAK;gCACLC,UAAUC,CAAAA,sBACR,KAACA,MAAMC,SAAS;wCAACC,MAAK;wCAAWV,WAAU;wCAAWW,cAAa;wCAAWC,OAAO/D,EAAE;;;;;kCAI7F,KAAC3B;wBAAKuE,MAAMnC;wBAAmBuD,UAAU;kCACtChE,EAAE;;kCAEL,KAACuB,KAAK0C,OAAO;wBAACP,wBAAU,KAACnC,KAAK2C,MAAM;4BAACH,OAAO/D,EAAE;4BAAyBmE,cAAcnE,EAAE;;;;;;;AAI/F;AAEA,OAAO,MAAMoE,mBAAoD,CAAC,EAChEC,YAAY,EACZ5E,iBAAiB,EACjBC,YAAY,EACZC,eAAe,EACfC,eAAe,EACfC,YAAY,EACZC,iBAAiB,EAClB;IACC,qBACE;;YACGuE,aAAaC,QAAQ,CAAC,kCACrB,KAAC9E;gBACCC,mBAAmBA;gBACnBC,cAAcA;gBACdC,iBAAiBA;gBACjBC,iBAAiBA;gBACjBC,cAAcA;gBACdC,mBAAmBA;;0BAGvB,KAAC5B;gBACCqG,UAAU;gBACVF,cAAcA;gBACdG,YAAY,KAAO;gBACnBnE,aAAalC,gBAAgB0B,cAAcS,UAAoBlC,YAAY2B,MAAM,CAACQ,MAAM,CAACC,KAAK;;;;AAItG,EAAC"}

package/dist/better-auth/plugin/payload/views/admin-login/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type AdminViewServerProps } from 'payload';
+import type { BetterAuthPluginOptions, SanitizedBetterAuthOptions } from '@/better-auth/plugin/types';
+export declare const loginBaseClass = "login";
+type AdminLoginProps = AdminViewServerProps & {
+    pluginOptions: BetterAuthPluginOptions;
+    betterAuthOptions: SanitizedBetterAuthOptions;
+};
+declare const AdminLogin: React.FC<AdminLoginProps>;
+export default AdminLogin;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/views/admin-login/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/admin-login/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAWzB,OAAO,EAAE,KAAK,oBAAoB,EAAoB,MAAM,SAAS,CAAA;AACrE,OAAO,KAAK,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AAErG,eAAO,MAAM,cAAc,UAAU,CAAA;AAErC,KAAK,eAAe,GAAG,oBAAoB,GAAG;IAC5C,aAAa,EAAE,uBAAuB,CAAA;IACtC,iBAAiB,EAAE,0BAA0B,CAAA;CAC9C,CAAA;AAED,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAmIzC,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/better-auth/plugin/payload/views/admin-login/index.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { AdminLoginClient } from "./client";
+import { redirect } from "next/navigation";
+import { Logo } from "../../../../../shared/components/logo";
+import { getSafeRedirect } from "../../utils/get-safe-redirect";
+import { MinimalTemplate } from "@payloadcms/next/templates";
+import { checkPasskeyPlugin } from "../../../helpers/check-passkey-plugin";
+import { checkUsernamePlugin } from "../../../helpers/check-username-plugin";
+import { RenderServerComponent } from "@payloadcms/ui/elements/RenderServerComponent";
+import { adminRoutes, baseCollectionSlugs, defaults } from "../../../constants";
+export const loginBaseClass = 'login';
+const AdminLogin = async ({ initPageResult, params, searchParams, pluginOptions, betterAuthOptions })=>{
+    const { locale, permissions, req } = initPageResult;
+    const { i18n, payload: { config, collections }, payload, user } = req;
+    const { admin: { components: { afterLogin, beforeLogin } = {}, user: userSlug }, routes: { admin: adminRoute } } = config;
+    const invitationsCollection = pluginOptions.adminInvitations?.slug ?? baseCollectionSlugs.adminInvitations;
+    const adminRole = pluginOptions.users?.defaultAdminRole ?? defaults.adminRole;
+    const redirectUrl = getSafeRedirect(searchParams?.redirect ?? '', adminRoute);
+    if (user) {
+        redirect(redirectUrl);
+    }
+    const adminCount = await req.payload.count({
+        collection: userSlug,
+        where: {
+            role: {
+                equals: adminRole
+            }
+        }
+    });
+    if (adminCount.totalDocs === 0) {
+        // Check if we already have an admin invitation
+        const existingInvitations = await req.payload.find({
+            collection: invitationsCollection,
+            where: {
+                role: {
+                    equals: adminRole
+                }
+            }
+        });
+        let token;
+        if (existingInvitations.totalDocs > 0) {
+            // Use existing token
+            token = existingInvitations.docs[0].token;
+        } else {
+            // Generate a new secure invite token
+            token = crypto.randomUUID();
+            await req.payload.create({
+                collection: invitationsCollection,
+                data: {
+                    role: adminRole,
+                    token
+                }
+            });
+        }
+        redirect(`${adminRoute}${adminRoutes.adminSignup}?token=${token}`);
+    }
+    // Filter out the first component from afterLogin array or set to undefined if not more than 1
+    // This is because of the custom login redirect component, we don't want an infinite loop
+    const filteredAfterLogin = Array.isArray(afterLogin) && afterLogin.length > 1 ? afterLogin.slice(1) : undefined;
+    const prefillAutoLogin = typeof config.admin?.autoLogin === 'object' && config.admin?.autoLogin.prefillOnly;
+    const prefillUsername = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.username : undefined;
+    const prefillEmail = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.email : undefined;
+    const prefillPassword = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.password : undefined;
+    const hasUsernamePlugin = checkUsernamePlugin(betterAuthOptions);
+    const hasPasskeyPlugin = checkPasskeyPlugin(betterAuthOptions);
+    const loginMethods = pluginOptions.admin?.loginMethods ?? [];
+    const loginWithUsername = collections?.[userSlug]?.config.auth.loginWithUsername;
+    const canLoginWithUsername = (hasUsernamePlugin && loginWithUsername) ?? false;
+    return /*#__PURE__*/ _jsxs(MinimalTemplate, {
+        className: loginBaseClass,
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: `${loginBaseClass}__brand`,
+                children: /*#__PURE__*/ _jsx(Logo, {
+                    i18n: i18n,
+                    locale: locale,
+                    params: params,
+                    payload: payload,
+                    permissions: permissions,
+                    searchParams: searchParams,
+                    user: user ?? undefined
+                })
+            }),
+            RenderServerComponent({
+                Component: beforeLogin,
+                importMap: payload.importMap,
+                serverProps: {
+                    i18n,
+                    locale,
+                    params,
+                    payload,
+                    permissions,
+                    searchParams,
+                    user: user ?? undefined
+                }
+            }),
+            /*#__PURE__*/ _jsx(AdminLoginClient, {
+                loginWithUsername: canLoginWithUsername,
+                hasUsernamePlugin: hasUsernamePlugin,
+                loginMethods: loginMethods,
+                prefillEmail: prefillEmail,
+                prefillPassword: prefillPassword,
+                prefillUsername: prefillUsername,
+                searchParams: searchParams ?? {}
+            }),
+            RenderServerComponent({
+                Component: filteredAfterLogin,
+                importMap: payload.importMap,
+                serverProps: {
+                    i18n,
+                    locale,
+                    params,
+                    payload,
+                    permissions,
+                    searchParams,
+                    user: user ?? undefined
+                }
+            })
+        ]
+    });
+};
+export default AdminLogin;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/views/admin-login/index.tsx"],"sourcesContent":["import React from 'react'\nimport { AdminLoginClient } from './client'\nimport { redirect } from 'next/navigation'\nimport { Logo } from '@/shared/components/logo'\nimport { getSafeRedirect } from '@/better-auth/plugin/payload/utils/get-safe-redirect'\nimport { MinimalTemplate } from '@payloadcms/next/templates'\nimport { checkPasskeyPlugin } from '@/better-auth/plugin/helpers/check-passkey-plugin'\nimport { checkUsernamePlugin } from '@/better-auth/plugin/helpers/check-username-plugin'\nimport { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent'\nimport { adminRoutes, baseCollectionSlugs, defaults } from '@/better-auth/plugin/constants'\n\nimport { type AdminViewServerProps, type ServerProps } from 'payload'\nimport type { BetterAuthPluginOptions, SanitizedBetterAuthOptions } from '@/better-auth/plugin/types'\n\nexport const loginBaseClass = 'login'\n\ntype AdminLoginProps = AdminViewServerProps & {\n  pluginOptions: BetterAuthPluginOptions\n  betterAuthOptions: SanitizedBetterAuthOptions\n}\n\nconst AdminLogin: React.FC<AdminLoginProps> = async ({\n  initPageResult,\n  params,\n  searchParams,\n  pluginOptions,\n  betterAuthOptions\n}: AdminLoginProps) => {\n  const { locale, permissions, req } = initPageResult\n  const {\n    i18n,\n    payload: { config, collections },\n    payload,\n    user\n  } = req\n\n  const {\n    admin: { components: { afterLogin, beforeLogin } = {}, user: userSlug },\n    routes: { admin: adminRoute }\n  } = config\n\n  const invitationsCollection = pluginOptions.adminInvitations?.slug ?? baseCollectionSlugs.adminInvitations\n  const adminRole = pluginOptions.users?.defaultAdminRole ?? defaults.adminRole\n  const redirectUrl = getSafeRedirect(searchParams?.redirect ?? '', adminRoute)\n\n  if (user) {\n    redirect(redirectUrl)\n  }\n\n  const adminCount = await req.payload.count({\n    collection: userSlug,\n    where: {\n      role: {\n        equals: adminRole\n      }\n    }\n  })\n\n  if (adminCount.totalDocs === 0) {\n    // Check if we already have an admin invitation\n    const existingInvitations = await req.payload.find({\n      collection: invitationsCollection,\n      where: {\n        role: {\n          equals: adminRole\n        }\n      }\n    })\n\n    let token\n\n    if (existingInvitations.totalDocs > 0) {\n      // Use existing token\n      token = existingInvitations.docs[0].token\n    } else {\n      // Generate a new secure invite token\n      token = crypto.randomUUID()\n      await req.payload.create({\n        collection: invitationsCollection,\n        data: {\n          role: adminRole,\n          token\n        }\n      })\n    }\n\n    redirect(`${adminRoute}${adminRoutes.adminSignup}?token=${token}`)\n  }\n\n  // Filter out the first component from afterLogin array or set to undefined if not more than 1\n  // This is because of the custom login redirect component, we don't want an infinite loop\n  const filteredAfterLogin = Array.isArray(afterLogin) && afterLogin.length > 1 ? afterLogin.slice(1) : undefined\n  const prefillAutoLogin = typeof config.admin?.autoLogin === 'object' && config.admin?.autoLogin.prefillOnly\n  const prefillUsername = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.username : undefined\n  const prefillEmail = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.email : undefined\n  const prefillPassword = prefillAutoLogin && typeof config.admin?.autoLogin === 'object' ? config.admin?.autoLogin.password : undefined\n  const hasUsernamePlugin = checkUsernamePlugin(betterAuthOptions)\n  const hasPasskeyPlugin = checkPasskeyPlugin(betterAuthOptions)\n  const loginMethods = pluginOptions.admin?.loginMethods ?? []\n  const loginWithUsername = collections?.[userSlug]?.config.auth.loginWithUsername\n  const canLoginWithUsername = (hasUsernamePlugin && loginWithUsername) ?? false\n\n  return (\n    <MinimalTemplate className={loginBaseClass}>\n      <div className={`${loginBaseClass}__brand`}>\n        <Logo\n          i18n={i18n}\n          locale={locale}\n          params={params}\n          payload={payload}\n          permissions={permissions}\n          searchParams={searchParams}\n          user={user ?? undefined}\n        />\n      </div>\n      {RenderServerComponent({\n        Component: beforeLogin,\n        importMap: payload.importMap,\n        serverProps: {\n          i18n,\n          locale,\n          params,\n          payload,\n          permissions,\n          searchParams,\n          user: user ?? undefined\n        } satisfies ServerProps\n      })}\n      <AdminLoginClient\n        loginWithUsername={canLoginWithUsername}\n        hasUsernamePlugin={hasUsernamePlugin}\n        loginMethods={loginMethods}\n        prefillEmail={prefillEmail}\n        prefillPassword={prefillPassword}\n        prefillUsername={prefillUsername}\n        searchParams={searchParams ?? {}}\n      />\n      {RenderServerComponent({\n        Component: filteredAfterLogin,\n        importMap: payload.importMap,\n        serverProps: {\n          i18n,\n          locale,\n          params,\n          payload,\n          permissions,\n          searchParams,\n          user: user ?? undefined\n        } satisfies ServerProps\n      })}\n    </MinimalTemplate>\n  )\n}\n\nexport default AdminLogin\n"],"names":["React","AdminLoginClient","redirect","Logo","getSafeRedirect","MinimalTemplate","checkPasskeyPlugin","checkUsernamePlugin","RenderServerComponent","adminRoutes","baseCollectionSlugs","defaults","loginBaseClass","AdminLogin","initPageResult","params","searchParams","pluginOptions","betterAuthOptions","locale","permissions","req","i18n","payload","config","collections","user","admin","components","afterLogin","beforeLogin","userSlug","routes","adminRoute","invitationsCollection","adminInvitations","slug","adminRole","users","defaultAdminRole","redirectUrl","adminCount","count","collection","where","role","equals","totalDocs","existingInvitations","find","token","docs","crypto","randomUUID","create","data","adminSignup","filteredAfterLogin","Array","isArray","length","slice","undefined","prefillAutoLogin","autoLogin","prefillOnly","prefillUsername","username","prefillEmail","email","prefillPassword","password","hasUsernamePlugin","hasPasskeyPlugin","loginMethods","loginWithUsername","auth","canLoginWithUsername","className","div","Component","importMap","serverProps"],"mappings":"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"}

package/dist/better-auth/plugin/payload/views/admin-signup/client.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { LoginMethod } from '../../../types';
+import type { LoginWithUsernameOptions } from 'payload';
+type AdminSignupClientProps = {
+    adminInviteToken: string;
+    userSlug: string;
+    loginMethods: LoginMethod[];
+    searchParams: {
+        [key: string]: string | string[] | undefined;
+    };
+    loginWithUsername: false | LoginWithUsernameOptions;
+};
+export declare const AdminSignupClient: React.FC<AdminSignupClientProps>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/better-auth/plugin/payload/views/admin-signup/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/admin-signup/client.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAmB,MAAM,OAAO,CAAA;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AASvD,KAAK,sBAAsB,GAAG;IAC5B,gBAAgB,EAAE,MAAM,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;KAAE,CAAA;IAC9D,iBAAiB,EAAE,KAAK,GAAG,wBAAwB,CAAA;CACpD,CAAA;AAwHD,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAwC9D,CAAA"}

package/dist/better-auth/plugin/payload/views/admin-signup/client.js

@@ -0,0 +1,156 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useConfig, toast, useTranslation } from "@payloadcms/ui";
+import React, { useState } from "react";
+import { AdminSocialProviderButtons } from "../../components/social-provider-buttons";
+import { getSafeRedirect } from "../../utils/get-safe-redirect";
+import { adminEndpoints } from "../../../constants";
+import { useAppForm } from "../../../../../shared/form";
+import { Form, FormInputWrap } from "../../../../../shared/form/ui";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+import { createSignupSchema } from "../../../../../shared/form/validation";
+import { tryCatch } from "../../../../../shared/utils/try-catch";
+const baseClass = 'admin-signup';
+const SignupForm = ({ searchParams, loginWithUsername, requireEmailVerification, setRequireEmailVerification, adminInviteToken })=>{
+    const { config: { admin: { user: userSlug }, routes: { admin: adminRoute, api: apiRoute }, serverURL } } = useConfig();
+    const { t } = useTranslation();
+    const redirectUrl = getSafeRedirect(searchParams?.redirect, adminRoute);
+    const requireUsername = Boolean(loginWithUsername && typeof loginWithUsername === 'object' && loginWithUsername.requireUsername);
+    const signupSchema = createSignupSchema({
+        t,
+        requireUsername
+    });
+    const form = useAppForm({
+        defaultValues: {
+            email: '',
+            password: '',
+            confirmPassword: '',
+            ...loginWithUsername ? {
+                username: ''
+            } : {}
+        },
+        onSubmit: async ({ value })=>{
+            const { email, username, password } = value;
+            const { data, error } = await tryCatch(fetch(`${serverURL}${apiRoute}/${userSlug}${adminEndpoints.signup}?token=${adminInviteToken}&redirect=${redirectUrl}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    email,
+                    username,
+                    password,
+                    adminInviteToken
+                })
+            }).then((res)=>res.json()));
+            if (error) {
+                toast.error(error.message);
+                return;
+            }
+            if (data.requireEmailVerification) {
+                setRequireEmailVerification(true);
+                toast.success(data.message);
+                return;
+            }
+            toast.success(data.message);
+            window.location.href = redirectUrl;
+        },
+        validators: {
+            onSubmit: signupSchema
+        }
+    });
+    if (requireEmailVerification) {
+        return /*#__PURE__*/ _jsx(FormHeader, {
+            heading: "Please verify your email",
+            description: 'Check your email for a verification link.',
+            style: {
+                textAlign: 'center'
+            }
+        });
+    }
+    return /*#__PURE__*/ _jsxs(Form, {
+        className: baseClass,
+        onSubmit: (e)=>{
+            e.preventDefault();
+            void form.handleSubmit();
+        },
+        children: [
+            /*#__PURE__*/ _jsxs(FormInputWrap, {
+                className: "login__form",
+                children: [
+                    /*#__PURE__*/ _jsx(form.AppField, {
+                        name: "email",
+                        children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                type: "email",
+                                className: "email",
+                                autoComplete: "email",
+                                label: t('general:email'),
+                                required: true
+                            })
+                    }),
+                    loginWithUsername && /*#__PURE__*/ _jsx(form.AppField, {
+                        name: "username",
+                        children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                type: "name",
+                                className: "text",
+                                autoComplete: "username",
+                                label: t('authentication:username'),
+                                required: requireUsername
+                            })
+                    }),
+                    /*#__PURE__*/ _jsx(form.AppField, {
+                        name: "password",
+                        children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                type: "password",
+                                className: "password",
+                                label: t('authentication:newPassword'),
+                                required: true
+                            })
+                    }),
+                    /*#__PURE__*/ _jsx(form.AppField, {
+                        name: "confirmPassword",
+                        children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                type: "password",
+                                className: "password",
+                                label: t('authentication:confirmPassword'),
+                                required: true
+                            })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(form.AppForm, {
+                children: /*#__PURE__*/ _jsx(form.Submit, {
+                    label: t('general:create'),
+                    loadingLabel: t('general:loading')
+                })
+            })
+        ]
+    });
+};
+export const AdminSignupClient = ({ adminInviteToken, userSlug, searchParams, loginMethods, loginWithUsername })=>{
+    const { config: { routes: { admin: adminRoute, api: apiRoute }, serverURL } } = useConfig();
+    const [requireEmailVerification, setRequireEmailVerification] = useState(false);
+    const redirectUrl = getSafeRedirect(searchParams?.redirect, adminRoute);
+    const setAdminRoleCallbackURL = `${serverURL}${apiRoute}/${userSlug}${adminEndpoints.setAdminRole}?token=${adminInviteToken}&redirect=${redirectUrl}`;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            loginMethods.includes('emailPassword') && /*#__PURE__*/ _jsx(SignupForm, {
+                adminInviteToken: adminInviteToken,
+                searchParams: searchParams,
+                loginWithUsername: loginWithUsername,
+                requireEmailVerification: requireEmailVerification,
+                setRequireEmailVerification: setRequireEmailVerification
+            }),
+            !requireEmailVerification && /*#__PURE__*/ _jsx(AdminSocialProviderButtons, {
+                isSignup: true,
+                loginMethods: loginMethods,
+                adminInviteToken: adminInviteToken,
+                setLoading: ()=>{},
+                redirectUrl: redirectUrl,
+                newUserCallbackURL: setAdminRoleCallbackURL
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/views/admin-signup/client.tsx"],"sourcesContent":["'use client'\n\nimport { useConfig, toast, useTranslation } from '@payloadcms/ui'\nimport React, { useState } from 'react'\nimport type { LoginMethod } from '../../../types'\nimport { AdminSocialProviderButtons } from '../../components/social-provider-buttons'\nimport { getSafeRedirect } from '../../utils/get-safe-redirect'\nimport { adminEndpoints } from '@/better-auth/plugin/constants'\nimport type { LoginWithUsernameOptions } from 'payload'\nimport { useAppForm } from '@/shared/form'\nimport { Form, FormInputWrap } from '@/shared/form/ui'\nimport { FormHeader } from '@/shared/form/ui/header'\nimport { createSignupSchema } from '@/shared/form/validation'\nimport { usernameClient } from 'better-auth/client/plugins'\nimport { createAuthClient } from 'better-auth/react'\nimport { tryCatch } from '@/shared/utils/try-catch'\n\ntype AdminSignupClientProps = {\n  adminInviteToken: string\n  userSlug: string\n  loginMethods: LoginMethod[]\n  searchParams: { [key: string]: string | string[] | undefined }\n  loginWithUsername: false | LoginWithUsernameOptions\n}\n\nconst baseClass = 'admin-signup'\n\ntype SignupFormProps = {\n  adminInviteToken: string\n  searchParams: { [key: string]: string | string[] | undefined }\n  loginWithUsername: false | LoginWithUsernameOptions\n  requireEmailVerification: boolean\n  setRequireEmailVerification: React.Dispatch<React.SetStateAction<boolean>>\n}\n\nconst SignupForm: React.FC<SignupFormProps> = ({\n  searchParams,\n  loginWithUsername,\n  requireEmailVerification,\n  setRequireEmailVerification,\n  adminInviteToken\n}) => {\n  const {\n    config: {\n      admin: { user: userSlug },\n      routes: { admin: adminRoute, api: apiRoute },\n      serverURL\n    }\n  } = useConfig()\n  const { t } = useTranslation()\n  const redirectUrl = getSafeRedirect(searchParams?.redirect as string, adminRoute)\n\n  const requireUsername = Boolean(loginWithUsername && typeof loginWithUsername === 'object' && loginWithUsername.requireUsername)\n\n  const signupSchema = createSignupSchema({ t, requireUsername })\n\n  const form = useAppForm({\n    defaultValues: {\n      email: '',\n      password: '',\n      confirmPassword: '',\n      ...(loginWithUsername ? { username: '' } : {})\n    },\n    onSubmit: async ({ value }) => {\n      const { email, username, password } = value\n      const { data, error } = await tryCatch(\n        fetch(`${serverURL}${apiRoute}/${userSlug}${adminEndpoints.signup}?token=${adminInviteToken}&redirect=${redirectUrl}`, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ email, username, password, adminInviteToken })\n        }).then((res) => res.json())\n      )\n\n      if (error) {\n        toast.error(error.message)\n        return;\n      }\n\n      if (data.requireEmailVerification) {\n        setRequireEmailVerification(true)\n        toast.success(data.message)\n        return;\n      }\n      toast.success(data.message)\n      window.location.href = redirectUrl\n    },\n    validators: {\n      onSubmit: signupSchema\n    }\n  })\n\n  if (requireEmailVerification) {\n    return (\n      <FormHeader\n        heading=\"Please verify your email\"\n        description={'Check your email for a verification link.'}\n        style={{ textAlign: 'center' }}\n      />\n    )\n  }\n\n  return (\n    <Form\n      className={baseClass}\n      onSubmit={(e) => {\n        e.preventDefault()\n        void form.handleSubmit()\n      }}>\n      <FormInputWrap className=\"login__form\">\n        <form.AppField\n          name=\"email\"\n          children={(field) => <field.TextField type=\"email\" className=\"email\" autoComplete=\"email\" label={t('general:email')} required />}\n        />\n        {loginWithUsername && (\n          <form.AppField\n            name=\"username\"\n            children={(field) => (\n              <field.TextField\n                type=\"name\"\n                className=\"text\"\n                autoComplete=\"username\"\n                label={t('authentication:username')}\n                required={requireUsername}\n              />\n            )}\n          />\n        )}\n        <form.AppField\n          name=\"password\"\n          children={(field) => <field.TextField type=\"password\" className=\"password\" label={t('authentication:newPassword')} required />}\n        />\n        <form.AppField\n          name=\"confirmPassword\"\n          children={(field) => (\n            <field.TextField type=\"password\" className=\"password\" label={t('authentication:confirmPassword')} required />\n          )}\n        />\n      </FormInputWrap>\n      <form.AppForm children={<form.Submit label={t('general:create')} loadingLabel={t('general:loading')} />} />\n    </Form>\n  )\n}\n\nexport const AdminSignupClient: React.FC<AdminSignupClientProps> = ({\n  adminInviteToken,\n  userSlug,\n  searchParams,\n  loginMethods,\n  loginWithUsername\n}) => {\n  const {\n    config: {\n      routes: { admin: adminRoute, api: apiRoute },\n      serverURL\n    }\n  } = useConfig()\n  const [requireEmailVerification, setRequireEmailVerification] = useState<boolean>(false)\n  const redirectUrl = getSafeRedirect(searchParams?.redirect as string, adminRoute)\n  const setAdminRoleCallbackURL = `${serverURL}${apiRoute}/${userSlug}${adminEndpoints.setAdminRole}?token=${adminInviteToken}&redirect=${redirectUrl}`\n\n  return (\n    <>\n      {loginMethods.includes('emailPassword') && (\n        <SignupForm\n          adminInviteToken={adminInviteToken}\n          searchParams={searchParams}\n          loginWithUsername={loginWithUsername}\n          requireEmailVerification={requireEmailVerification}\n          setRequireEmailVerification={setRequireEmailVerification}\n        />\n      )}\n      {!requireEmailVerification && (\n        <AdminSocialProviderButtons\n          isSignup={true}\n          loginMethods={loginMethods}\n          adminInviteToken={adminInviteToken}\n          setLoading={() => {}}\n          redirectUrl={redirectUrl}\n          newUserCallbackURL={setAdminRoleCallbackURL}\n        />\n      )}\n    </>\n  )\n}\n"],"names":["useConfig","toast","useTranslation","React","useState","AdminSocialProviderButtons","getSafeRedirect","adminEndpoints","useAppForm","Form","FormInputWrap","FormHeader","createSignupSchema","tryCatch","baseClass","SignupForm","searchParams","loginWithUsername","requireEmailVerification","setRequireEmailVerification","adminInviteToken","config","admin","user","userSlug","routes","adminRoute","api","apiRoute","serverURL","t","redirectUrl","redirect","requireUsername","Boolean","signupSchema","form","defaultValues","email","password","confirmPassword","username","onSubmit","value","data","error","fetch","signup","method","headers","body","JSON","stringify","then","res","json","message","success","window","location","href","validators","heading","description","style","textAlign","className","e","preventDefault","handleSubmit","AppField","name","children","field","TextField","type","autoComplete","label","required","AppForm","Submit","loadingLabel","AdminSignupClient","loginMethods","setAdminRoleCallbackURL","setAdminRole","includes","isSignup","setLoading","newUserCallbackURL"],"mappings":"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"}

package/dist/better-auth/plugin/payload/views/admin-signup/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { AdminViewServerProps } from 'payload';
+import type { BetterAuthPluginOptions, SanitizedBetterAuthOptions } from '../../../types';
+type AdminSignupProps = AdminViewServerProps & {
+    defaultAdminRole: string;
+    pluginOptions: BetterAuthPluginOptions;
+    betterAuthOptions: SanitizedBetterAuthOptions;
+};
+declare const AdminSignup: React.FC<AdminSignupProps>;
+export default AdminSignup;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/views/admin-signup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/admin-signup/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAUzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,KAAK,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AASzF,KAAK,gBAAgB,GAAG,oBAAoB,GAAG;IAC7C,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,uBAAuB,CAAA;IACtC,iBAAiB,EAAE,0BAA0B,CAAA;CAC9C,CAAA;AAED,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA2E3C,CAAA;AAED,eAAe,WAAW,CAAA"}