payload-auth 1.7.1 → 1.8.0-canary.2

package/dist/better-auth/plugin/payload/components/login-form/alternative-methods.js

@@ -0,0 +1,197 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { socialProviders } from "../../../constants";
+import { Icons } from "../../../../../shared/components/icons";
+import { isValidEmail } from "../../../../../shared/form/validation";
+import { Button, toast } from "@payloadcms/ui";
+import { Key, Mail } from "lucide-react";
+import { useRouter } from "next/navigation";
+import React, { useEffect, useRef, useState } from "react";
+import { useLoginForm } from "./context";
+import "./index.scss";
+const baseClass = 'login-form-methods';
+const MagicLinkButton = ()=>{
+    const { email, authClient, redirectUrl, showIconOnly } = useLoginForm();
+    const [loading, setLoading] = useState(false);
+    const [sent, setSent] = useState(false);
+    const sentEmailRef = useRef('');
+    useEffect(()=>{
+        if (sent && email !== sentEmailRef.current) {
+            setSent(false);
+        }
+    }, [
+        email,
+        sent
+    ]);
+    const handleClick = async ()=>{
+        if (!email) {
+            toast.error('Please enter your email address');
+            return;
+        }
+        if (!isValidEmail(email)) {
+            toast.error('Please enter a valid email address');
+            return;
+        }
+        setLoading(true);
+        try {
+            const { error } = await authClient.signIn.magicLink({
+                email,
+                callbackURL: redirectUrl
+            });
+            if (error) {
+                toast.error(error.message || 'Failed to send magic link');
+            } else {
+                sentEmailRef.current = email;
+                setSent(true);
+                toast.success('Magic link sent! Check your email.');
+            }
+        } catch (error) {
+            toast.error(error?.message || 'Failed to send magic link');
+        } finally{
+            setLoading(false);
+        }
+    };
+    const label = sent ? 'Resend Magic Link' : 'Magic Link';
+    return /*#__PURE__*/ _jsx(Button, {
+        type: "button",
+        size: "large",
+        className: `${baseClass}__button provider--magic-link`,
+        onClick: handleClick,
+        disabled: loading,
+        iconPosition: "left",
+        icon: /*#__PURE__*/ _jsx(Mail, {
+            className: `${baseClass}__icon`
+        }),
+        tooltip: showIconOnly ? 'Sign in with Magic Link' : undefined,
+        children: !showIconOnly && /*#__PURE__*/ _jsx("span", {
+            children: loading ? 'Sending...' : label
+        })
+    });
+};
+const PasskeyButton = ({ setLoading })=>{
+    const router = useRouter();
+    const { authClient, redirectUrl, showIconOnly } = useLoginForm();
+    const handleClick = async ()=>{
+        setLoading(true);
+        try {
+            await authClient.signIn.passkey({
+                fetchOptions: {
+                    onSuccess () {
+                        if (redirectUrl) router.push(redirectUrl);
+                    },
+                    onError (context) {
+                        toast.error(context.error.message || 'Failed to sign in with passkey');
+                    }
+                }
+            });
+        } catch (error) {
+            toast.error(error?.message || 'Failed to sign in with passkey');
+        } finally{
+            setLoading(false);
+        }
+    };
+    return /*#__PURE__*/ _jsx(Button, {
+        type: "button",
+        size: "large",
+        className: `${baseClass}__button provider--passkey`,
+        onClick: handleClick,
+        iconPosition: "left",
+        icon: /*#__PURE__*/ _jsx(Key, {
+            className: `${baseClass}__icon`
+        }),
+        tooltip: showIconOnly ? 'Sign in with Passkey' : undefined,
+        children: !showIconOnly && /*#__PURE__*/ _jsx("span", {
+            children: "Passkey"
+        })
+    });
+};
+const SocialButton = ({ provider, setLoading })=>{
+    const { authClient, redirectUrl, isSignup, showIconOnly, adminInviteToken, newUserCallbackURL } = useLoginForm();
+    const Icon = Icons[provider] ?? null;
+    const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
+    const handleClick = async ()=>{
+        setLoading(true);
+        try {
+            const { error } = await authClient.signIn.social({
+                provider,
+                fetchOptions: {
+                    query: {
+                        ...isSignup && {
+                            adminInviteToken
+                        }
+                    }
+                },
+                errorCallbackURL: window.location.href,
+                callbackURL: redirectUrl,
+                newUserCallbackURL,
+                ...isSignup && {
+                    requestSignUp: true
+                }
+            });
+            if (error) {
+                toast.error(error.message);
+            }
+        } catch  {
+            toast.error(`Failed to sign in with ${providerName}`);
+        } finally{
+            setLoading(false);
+        }
+    };
+    return /*#__PURE__*/ _jsx(Button, {
+        type: "button",
+        size: "large",
+        className: `${baseClass}__button provider--${provider}`,
+        onClick: handleClick,
+        iconPosition: "left",
+        icon: Icon ? /*#__PURE__*/ _jsx(Icon, {
+            className: `${baseClass}__icon`
+        }) : undefined,
+        tooltip: showIconOnly ? `Sign in with ${providerName}` : undefined,
+        children: !showIconOnly && /*#__PURE__*/ _jsx("span", {
+            children: providerName
+        })
+    });
+};
+export const AlternativeMethods = ()=>{
+    const { alternativeMethods, hasMethod, isSignup, showIconOnly } = useLoginForm();
+    const [loading, setLoading] = useState(false);
+    if (alternativeMethods.length === 0) return null;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            hasMethod('emailPassword') && /*#__PURE__*/ _jsx("div", {
+                className: `${baseClass}__divider`,
+                children: /*#__PURE__*/ _jsxs("span", {
+                    children: [
+                        "Or ",
+                        isSignup ? 'sign up' : 'login',
+                        " with"
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: `${baseClass} ${baseClass}--count-${showIconOnly ? 'many' : alternativeMethods.length}`,
+                children: alternativeMethods.map((method)=>{
+                    if (method === 'passkey') {
+                        if (isSignup) return null;
+                        return /*#__PURE__*/ _jsx(PasskeyButton, {
+                            setLoading: setLoading
+                        }, method);
+                    }
+                    if (method === 'magicLink') {
+                        if (isSignup) return null;
+                        return /*#__PURE__*/ _jsx(MagicLinkButton, {}, method);
+                    }
+                    if (socialProviders.includes(method)) {
+                        return /*#__PURE__*/ _jsx(SocialButton, {
+                            provider: method,
+                            setLoading: setLoading
+                        }, method);
+                    }
+                    return null;
+                })
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/alternative-methods.tsx"],"sourcesContent":["'use client'\n\nimport { socialProviders } from '@/better-auth/plugin/constants'\nimport type { SocialProvider } from '@/better-auth/plugin/types'\nimport { Icons } from '@/shared/components/icons'\nimport { isValidEmail } from '@/shared/form/validation'\nimport { Button, toast } from '@payloadcms/ui'\nimport { Key, Mail } from 'lucide-react'\nimport { useRouter } from 'next/navigation'\nimport React, { useEffect, useRef, useState } from 'react'\nimport { useLoginForm } from './context'\nimport './index.scss'\n\nconst baseClass = 'login-form-methods'\n\nconst MagicLinkButton: React.FC = () => {\n  const { email, authClient, redirectUrl, showIconOnly } = useLoginForm()\n  const [loading, setLoading] = useState(false)\n  const [sent, setSent] = useState(false)\n  const sentEmailRef = useRef('')\n\n  useEffect(() => {\n    if (sent && email !== sentEmailRef.current) {\n      setSent(false)\n    }\n  }, [email, sent])\n\n  const handleClick = async () => {\n    if (!email) {\n      toast.error('Please enter your email address')\n      return\n    }\n    if (!isValidEmail(email)) {\n      toast.error('Please enter a valid email address')\n      return\n    }\n\n    setLoading(true)\n    try {\n      const { error } = await authClient.signIn.magicLink({ email, callbackURL: redirectUrl })\n      if (error) {\n        toast.error(error.message || 'Failed to send magic link')\n      } else {\n        sentEmailRef.current = email\n        setSent(true)\n        toast.success('Magic link sent! Check your email.')\n      }\n    } catch (error: any) {\n      toast.error(error?.message || 'Failed to send magic link')\n    } finally {\n      setLoading(false)\n    }\n  }\n\n  const label = sent ? 'Resend Magic Link' : 'Magic Link'\n\n  return (\n    <Button\n      type=\"button\"\n      size=\"large\"\n      className={`${baseClass}__button provider--magic-link`}\n      onClick={handleClick}\n      disabled={loading}\n      iconPosition=\"left\"\n      icon={<Mail className={`${baseClass}__icon`} />}\n      tooltip={showIconOnly ? 'Sign in with Magic Link' : undefined}>\n      {!showIconOnly && <span>{loading ? 'Sending...' : label}</span>}\n    </Button>\n  )\n}\n\ntype PasskeyButtonProps = {\n  setLoading: (loading: boolean) => void\n}\n\nconst PasskeyButton: React.FC<PasskeyButtonProps> = ({ setLoading }) => {\n  const router = useRouter()\n  const { authClient, redirectUrl, showIconOnly } = useLoginForm()\n\n  const handleClick = async () => {\n    setLoading(true)\n    try {\n      await authClient.signIn.passkey({\n        fetchOptions: {\n          onSuccess() {\n            if (redirectUrl) router.push(redirectUrl)\n          },\n          onError(context: any) {\n            toast.error(context.error.message || 'Failed to sign in with passkey')\n          }\n        }\n      })\n    } catch (error: any) {\n      toast.error(error?.message || 'Failed to sign in with passkey')\n    } finally {\n      setLoading(false)\n    }\n  }\n\n  return (\n    <Button\n      type=\"button\"\n      size=\"large\"\n      className={`${baseClass}__button provider--passkey`}\n      onClick={handleClick}\n      iconPosition=\"left\"\n      icon={<Key className={`${baseClass}__icon`} />}\n      tooltip={showIconOnly ? 'Sign in with Passkey' : undefined}>\n      {!showIconOnly && <span>Passkey</span>}\n    </Button>\n  )\n}\n\ntype SocialButtonProps = {\n  provider: SocialProvider\n  setLoading: (loading: boolean) => void\n}\n\nconst SocialButton: React.FC<SocialButtonProps> = ({ provider, setLoading }) => {\n  const { authClient, redirectUrl, isSignup, showIconOnly, adminInviteToken, newUserCallbackURL } = useLoginForm()\n  const Icon = Icons[provider as keyof typeof Icons] ?? null\n  const providerName = provider.charAt(0).toUpperCase() + provider.slice(1)\n\n  const handleClick = async () => {\n    setLoading(true)\n    try {\n      const { error } = await authClient.signIn.social({\n        provider,\n        fetchOptions: {\n          query: {\n            ...(isSignup && { adminInviteToken })\n          }\n        },\n        errorCallbackURL: window.location.href,\n        callbackURL: redirectUrl,\n        newUserCallbackURL,\n        ...(isSignup && { requestSignUp: true })\n      })\n      if (error) {\n        toast.error(error.message)\n      }\n    } catch {\n      toast.error(`Failed to sign in with ${providerName}`)\n    } finally {\n      setLoading(false)\n    }\n  }\n\n  return (\n    <Button\n      type=\"button\"\n      size=\"large\"\n      className={`${baseClass}__button provider--${provider}`}\n      onClick={handleClick}\n      iconPosition=\"left\"\n      icon={Icon ? <Icon className={`${baseClass}__icon`} /> : undefined}\n      tooltip={showIconOnly ? `Sign in with ${providerName}` : undefined}>\n      {!showIconOnly && <span>{providerName}</span>}\n    </Button>\n  )\n}\n\nexport const AlternativeMethods: React.FC = () => {\n  const { alternativeMethods, hasMethod, isSignup, showIconOnly } = useLoginForm()\n  const [loading, setLoading] = useState(false)\n  \n  if (alternativeMethods.length === 0) return null\n\n  return (\n    <>\n      {hasMethod('emailPassword') && (\n        <div className={`${baseClass}__divider`}>\n          <span>Or {isSignup ? 'sign up' : 'login'} with</span>\n        </div>\n      )}\n      <div className={`${baseClass} ${baseClass}--count-${showIconOnly ? 'many' : alternativeMethods.length}`}>\n        {alternativeMethods.map((method) => {\n          if (method === 'passkey') {\n            if (isSignup) return null\n            return <PasskeyButton key={method} setLoading={setLoading} />\n          }\n\n          if (method === 'magicLink') {\n            if (isSignup) return null\n            return <MagicLinkButton key={method} />\n          }\n\n          if (socialProviders.includes(method as SocialProvider)) {\n            return <SocialButton key={method} provider={method as SocialProvider} setLoading={setLoading} />\n          }\n\n          return null\n        })}\n      </div>\n    </>\n  )\n}\n\n"],"names":["socialProviders","Icons","isValidEmail","Button","toast","Key","Mail","useRouter","React","useEffect","useRef","useState","useLoginForm","baseClass","MagicLinkButton","email","authClient","redirectUrl","showIconOnly","loading","setLoading","sent","setSent","sentEmailRef","current","handleClick","error","signIn","magicLink","callbackURL","message","success","label","type","size","className","onClick","disabled","iconPosition","icon","tooltip","undefined","span","PasskeyButton","router","passkey","fetchOptions","onSuccess","push","onError","context","SocialButton","provider","isSignup","adminInviteToken","newUserCallbackURL","Icon","providerName","charAt","toUpperCase","slice","social","query","errorCallbackURL","window","location","href","requestSignUp","AlternativeMethods","alternativeMethods","hasMethod","length","div","map","method","includes"],"mappings":"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"}

package/dist/better-auth/plugin/payload/components/login-form/context.d.ts

@@ -0,0 +1,49 @@
+import type { LoginMethod } from '@/better-auth/plugin/types';
+import React from 'react';
+type LoginFormContextValue = {
+    loginMethods: LoginMethod[];
+    email: string;
+    setEmail: (email: string) => void;
+    redirectUrl: string;
+    isSignup: boolean;
+    authClient: any;
+    loginType: 'email' | 'username' | 'emailOrUsername';
+    hasMethod: (method: LoginMethod) => boolean;
+    alternativeMethods: LoginMethod[];
+    showIconOnly: boolean;
+    adminInviteToken?: string;
+    newUserCallbackURL?: string;
+    prefill: {
+        email?: string;
+        password?: string;
+        username?: string;
+    };
+};
+type Prefill = {
+    email?: string;
+    password?: string;
+    username?: string;
+};
+type Plugins = {
+    username?: boolean;
+    passkey?: boolean;
+    magicLink?: boolean;
+};
+type LoginIdentifier = 'email' | 'username';
+export type LoginFormProviderProps = {
+    children: React.ReactNode;
+    loginMethods: LoginMethod[];
+    redirectUrl: string;
+    baseURL?: string;
+    basePath?: string;
+    isSignup?: boolean;
+    loginIdentifiers: LoginIdentifier[];
+    plugins?: Plugins;
+    prefill?: Prefill;
+    adminInviteToken?: string;
+    newUserCallbackURL?: string;
+};
+export declare const LoginFormProvider: React.FC<LoginFormProviderProps>;
+export declare const useLoginForm: () => LoginFormContextValue;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/better-auth/plugin/payload/components/login-form/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/context.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAuD,MAAM,OAAO,CAAA;AAO3E,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,GAAG,CAAA;IACf,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,iBAAiB,CAAA;IACnD,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAA;IAC3C,kBAAkB,EAAE,WAAW,EAAE,CAAA;IACjC,YAAY,EAAE,OAAO,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,OAAO,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;KAClB,CAAA;CACF,CAAA;AAID,KAAK,OAAO,GAAG;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,KAAK,eAAe,GAAG,OAAO,GAAG,UAAU,CAAA;AAE3C,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE,eAAe,EAAE,CAAA;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAgF9D,CAAA;AAED,eAAO,MAAM,YAAY,6BAMxB,CAAA"}

package/dist/better-auth/plugin/payload/components/login-form/context.js

@@ -0,0 +1,94 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useMemo, useState } from "react";
+import { createAuthClient } from "better-auth/react";
+import { usernameClient, twoFactorClient, magicLinkClient } from "better-auth/client/plugins";
+import { passkeyClient } from "@better-auth/passkey/client";
+import { useRouter } from "next/navigation";
+import { adminRoutes } from "../../../constants";
+const LoginFormContext = /*#__PURE__*/ createContext(null);
+export const LoginFormProvider = ({ children, loginMethods, redirectUrl, baseURL, basePath, isSignup = false, loginIdentifiers, plugins, prefill, adminInviteToken, newUserCallbackURL })=>{
+    const { username: hasUsernamePlugin = false, passkey: hasPasskeyPlugin = false, magicLink: hasMagicLinkPlugin = false } = plugins ?? {};
+    const resolvedPrefill = prefill ?? {};
+    const router = useRouter();
+    const [email, setEmail] = useState(resolvedPrefill.email ?? '');
+    const authClient = useMemo(()=>createAuthClient({
+            baseURL,
+            basePath,
+            plugins: [
+                usernameClient(),
+                twoFactorClient({
+                    onTwoFactorRedirect () {
+                        router.push(`${redirectUrl.split('?')[0]}${adminRoutes.twoFactorVerify}?redirect=${redirectUrl}`);
+                    }
+                }),
+                ...hasPasskeyPlugin ? [
+                    passkeyClient()
+                ] : [],
+                ...hasMagicLinkPlugin || loginMethods.includes('magicLink') ? [
+                    magicLinkClient()
+                ] : []
+            ]
+        }), [
+        baseURL,
+        basePath,
+        hasMagicLinkPlugin,
+        hasPasskeyPlugin,
+        loginMethods,
+        redirectUrl,
+        router
+    ]);
+    const canLoginWithEmail = loginIdentifiers.includes('email');
+    const canLoginWithUsername = loginIdentifiers.includes('username');
+    const loginType = useMemo(()=>{
+        if (canLoginWithEmail && canLoginWithUsername && hasUsernamePlugin) return 'emailOrUsername';
+        if (canLoginWithUsername && hasUsernamePlugin) return 'username';
+        return 'email';
+    }, [
+        canLoginWithEmail,
+        canLoginWithUsername,
+        hasUsernamePlugin
+    ]);
+    const hasMethod = (method)=>loginMethods.includes(method);
+    const alternativeMethods = useMemo(()=>loginMethods.filter((m)=>{
+            if (m === 'emailPassword') return false;
+            if (isSignup && (m === 'passkey' || m === 'magicLink')) return false;
+            return true;
+        }), [
+        loginMethods,
+        isSignup
+    ]);
+    const showIconOnly = alternativeMethods.length >= 3;
+    const value = {
+        loginMethods,
+        email,
+        setEmail,
+        redirectUrl,
+        isSignup,
+        authClient,
+        loginType,
+        hasMethod,
+        alternativeMethods,
+        showIconOnly,
+        adminInviteToken,
+        newUserCallbackURL,
+        prefill: {
+            email: resolvedPrefill.email,
+            password: resolvedPrefill.password,
+            username: resolvedPrefill.username
+        }
+    };
+    return /*#__PURE__*/ _jsx(LoginFormContext.Provider, {
+        value: value,
+        children: children
+    });
+};
+export const useLoginForm = ()=>{
+    const context = useContext(LoginFormContext);
+    if (!context) {
+        throw new Error('useLoginForm must be used within a LoginFormProvider');
+    }
+    return context;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/context.tsx"],"sourcesContent":["'use client'\n\nimport type { LoginMethod } from '@/better-auth/plugin/types'\nimport React, { createContext, useContext, useMemo, useState } from 'react'\nimport { createAuthClient } from 'better-auth/react'\nimport { usernameClient, twoFactorClient, magicLinkClient } from 'better-auth/client/plugins'\nimport { passkeyClient } from '@better-auth/passkey/client'\nimport { useRouter } from 'next/navigation'\nimport { adminRoutes } from '@/better-auth/plugin/constants'\n\ntype LoginFormContextValue = {\n  loginMethods: LoginMethod[]\n  email: string\n  setEmail: (email: string) => void\n  redirectUrl: string\n  isSignup: boolean\n  authClient: any\n  loginType: 'email' | 'username' | 'emailOrUsername'\n  hasMethod: (method: LoginMethod) => boolean\n  alternativeMethods: LoginMethod[]\n  showIconOnly: boolean\n  adminInviteToken?: string\n  newUserCallbackURL?: string\n  prefill: {\n    email?: string\n    password?: string\n    username?: string\n  }\n}\n\nconst LoginFormContext = createContext<LoginFormContextValue | null>(null)\n\ntype Prefill = {\n  email?: string\n  password?: string\n  username?: string\n}\n\ntype Plugins = {\n  username?: boolean\n  passkey?: boolean\n  magicLink?: boolean\n}\n\ntype LoginIdentifier = 'email' | 'username'\n\nexport type LoginFormProviderProps = {\n  children: React.ReactNode\n  loginMethods: LoginMethod[]\n  redirectUrl: string\n  baseURL?: string\n  basePath?: string\n  isSignup?: boolean\n  loginIdentifiers: LoginIdentifier[]\n  plugins?: Plugins\n  prefill?: Prefill\n  adminInviteToken?: string\n  newUserCallbackURL?: string\n}\n\nexport const LoginFormProvider: React.FC<LoginFormProviderProps> = ({\n  children,\n  loginMethods,\n  redirectUrl,\n  baseURL,\n  basePath,\n  isSignup = false,\n  loginIdentifiers,\n  plugins,\n  prefill,\n  adminInviteToken,\n  newUserCallbackURL\n}) => {\n  const { username: hasUsernamePlugin = false, passkey: hasPasskeyPlugin = false, magicLink: hasMagicLinkPlugin = false } = plugins ?? {}\n  const resolvedPrefill: Prefill = prefill ?? {}\n\n  const router = useRouter()\n  const [email, setEmail] = useState(resolvedPrefill.email ?? '')\n\n  const authClient = useMemo(\n    () =>\n      createAuthClient({\n        baseURL,\n        basePath,\n        plugins: [\n          usernameClient(),\n          twoFactorClient({\n            onTwoFactorRedirect() {\n              router.push(`${redirectUrl.split('?')[0]}${adminRoutes.twoFactorVerify}?redirect=${redirectUrl}`)\n            }\n          }),\n          ...(hasPasskeyPlugin ? [passkeyClient()] : []),\n          ...(hasMagicLinkPlugin || loginMethods.includes('magicLink') ? [magicLinkClient()] : [])\n        ]\n      }),\n    [baseURL, basePath, hasMagicLinkPlugin, hasPasskeyPlugin, loginMethods, redirectUrl, router]\n  )\n\n  const canLoginWithEmail = loginIdentifiers.includes('email')\n  const canLoginWithUsername = loginIdentifiers.includes('username')\n\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\n  const hasMethod = (method: LoginMethod) => loginMethods.includes(method)\n  const alternativeMethods = useMemo(\n    () =>\n      loginMethods.filter((m) => {\n        if (m === 'emailPassword') return false\n        if (isSignup && (m === 'passkey' || m === 'magicLink')) return false\n        return true\n      }),\n    [loginMethods, isSignup]\n  )\n  const showIconOnly = alternativeMethods.length >= 3\n\n  const value: LoginFormContextValue = {\n    loginMethods,\n    email,\n    setEmail,\n    redirectUrl,\n    isSignup,\n    authClient,\n    loginType,\n    hasMethod,\n    alternativeMethods,\n    showIconOnly,\n    adminInviteToken,\n    newUserCallbackURL,\n    prefill: {\n      email: resolvedPrefill.email,\n      password: resolvedPrefill.password,\n      username: resolvedPrefill.username\n    }\n  }\n\n  return <LoginFormContext.Provider value={value}>{children}</LoginFormContext.Provider>\n}\n\nexport const useLoginForm = () => {\n  const context = useContext(LoginFormContext)\n  if (!context) {\n    throw new Error('useLoginForm must be used within a LoginFormProvider')\n  }\n  return context\n}\n"],"names":["React","createContext","useContext","useMemo","useState","createAuthClient","usernameClient","twoFactorClient","magicLinkClient","passkeyClient","useRouter","adminRoutes","LoginFormContext","LoginFormProvider","children","loginMethods","redirectUrl","baseURL","basePath","isSignup","loginIdentifiers","plugins","prefill","adminInviteToken","newUserCallbackURL","username","hasUsernamePlugin","passkey","hasPasskeyPlugin","magicLink","hasMagicLinkPlugin","resolvedPrefill","router","email","setEmail","authClient","onTwoFactorRedirect","push","split","twoFactorVerify","includes","canLoginWithEmail","canLoginWithUsername","loginType","hasMethod","method","alternativeMethods","filter","m","showIconOnly","length","value","password","Provider","useLoginForm","context","Error"],"mappings":"AAAA;;AAGA,OAAOA,SAASC,aAAa,EAAEC,UAAU,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAO;AAC3E,SAASC,gBAAgB,QAAQ,oBAAmB;AACpD,SAASC,cAAc,EAAEC,eAAe,EAAEC,eAAe,QAAQ,6BAA4B;AAC7F,SAASC,aAAa,QAAQ,8BAA6B;AAC3D,SAASC,SAAS,QAAQ,kBAAiB;AAC3C,SAASC,WAAW,QAAQ,qBAAgC;AAsB5D,MAAMC,iCAAmBX,cAA4C;AA8BrE,OAAO,MAAMY,oBAAsD,CAAC,EAClEC,QAAQ,EACRC,YAAY,EACZC,WAAW,EACXC,OAAO,EACPC,QAAQ,EACRC,WAAW,KAAK,EAChBC,gBAAgB,EAChBC,OAAO,EACPC,OAAO,EACPC,gBAAgB,EAChBC,kBAAkB,EACnB;IACC,MAAM,EAAEC,UAAUC,oBAAoB,KAAK,EAAEC,SAASC,mBAAmB,KAAK,EAAEC,WAAWC,qBAAqB,KAAK,EAAE,GAAGT,WAAW,CAAC;IACtI,MAAMU,kBAA2BT,WAAW,CAAC;IAE7C,MAAMU,SAAStB;IACf,MAAM,CAACuB,OAAOC,SAAS,GAAG9B,SAAS2B,gBAAgBE,KAAK,IAAI;IAE5D,MAAME,aAAahC,QACjB,IACEE,iBAAiB;YACfY;YACAC;YACAG,SAAS;gBACPf;gBACAC,gBAAgB;oBACd6B;wBACEJ,OAAOK,IAAI,CAAC,GAAGrB,YAAYsB,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG3B,YAAY4B,eAAe,CAAC,UAAU,EAAEvB,aAAa;oBAClG;gBACF;mBACIY,mBAAmB;oBAACnB;iBAAgB,GAAG,EAAE;mBACzCqB,sBAAsBf,aAAayB,QAAQ,CAAC,eAAe;oBAAChC;iBAAkB,GAAG,EAAE;aACxF;QACH,IACF;QAACS;QAASC;QAAUY;QAAoBF;QAAkBb;QAAcC;QAAagB;KAAO;IAG9F,MAAMS,oBAAoBrB,iBAAiBoB,QAAQ,CAAC;IACpD,MAAME,uBAAuBtB,iBAAiBoB,QAAQ,CAAC;IAEvD,MAAMG,YAAYxC,QAAQ;QACxB,IAAIsC,qBAAqBC,wBAAwBhB,mBAAmB,OAAO;QAC3E,IAAIgB,wBAAwBhB,mBAAmB,OAAO;QACtD,OAAO;IACT,GAAG;QAACe;QAAmBC;QAAsBhB;KAAkB;IAE/D,MAAMkB,YAAY,CAACC,SAAwB9B,aAAayB,QAAQ,CAACK;IACjE,MAAMC,qBAAqB3C,QACzB,IACEY,aAAagC,MAAM,CAAC,CAACC;YACnB,IAAIA,MAAM,iBAAiB,OAAO;YAClC,IAAI7B,YAAa6B,CAAAA,MAAM,aAAaA,MAAM,WAAU,GAAI,OAAO;YAC/D,OAAO;QACT,IACF;QAACjC;QAAcI;KAAS;IAE1B,MAAM8B,eAAeH,mBAAmBI,MAAM,IAAI;IAElD,MAAMC,QAA+B;QACnCpC;QACAkB;QACAC;QACAlB;QACAG;QACAgB;QACAQ;QACAC;QACAE;QACAG;QACA1B;QACAC;QACAF,SAAS;YACPW,OAAOF,gBAAgBE,KAAK;YAC5BmB,UAAUrB,gBAAgBqB,QAAQ;YAClC3B,UAAUM,gBAAgBN,QAAQ;QACpC;IACF;IAEA,qBAAO,KAACb,iBAAiByC,QAAQ;QAACF,OAAOA;kBAAQrC;;AACnD,EAAC;AAED,OAAO,MAAMwC,eAAe;IAC1B,MAAMC,UAAUrD,WAAWU;IAC3B,IAAI,CAAC2C,SAAS;QACZ,MAAM,IAAIC,MAAM;IAClB;IACA,OAAOD;AACT,EAAC"}

package/dist/better-auth/plugin/payload/components/login-form/credentials-form.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import './index.scss';
+export declare const CredentialsForm: React.FC;
+//# sourceMappingURL=credentials-form.d.ts.map

package/dist/better-auth/plugin/payload/components/login-form/credentials-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials-form.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/credentials-form.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAEvC,OAAO,cAAc,CAAA;AAIrB,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAyHnC,CAAA"}

package/dist/better-auth/plugin/payload/components/login-form/credentials-form.js

@@ -0,0 +1,167 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+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 { valueOrDefaultString } from "../../../../../shared/utils/value-or-default";
+import { useConfig, Link, toast, useTranslation } from "@payloadcms/ui";
+import { formatAdminURL } from "payload/shared";
+import React, { useState } from "react";
+import { useLoginForm } from "./context";
+import "./index.scss";
+const baseClass = 'login__form';
+export const CredentialsForm = ()=>{
+    const { config } = useConfig();
+    const { t } = useTranslation();
+    const { authClient, loginType, hasMethod, setEmail, redirectUrl, prefill } = useLoginForm();
+    const adminRoute = valueOrDefaultString(config?.routes?.admin, '/admin');
+    const hasEmailPassword = hasMethod('emailPassword');
+    const hasMagicLink = hasMethod('magicLink');
+    const showEmailField = hasEmailPassword || hasMagicLink;
+    const showPasswordField = hasEmailPassword;
+    const [requireEmailVerification, setRequireEmailVerification] = useState(false);
+    const [searchParamError] = useState(()=>{
+        if (typeof window !== 'undefined') {
+            const params = new URLSearchParams(window.location.search);
+            return params.get('error');
+        }
+        return null;
+    });
+    const forgotPasswordUrl = formatAdminURL({
+        adminRoute,
+        path: adminRoutes?.forgotPassword
+    });
+    const loginSchema = createLoginSchema({
+        t,
+        loginType,
+        canLoginWithUsername: loginType !== 'email'
+    });
+    const form = useAppForm({
+        defaultValues: {
+            login: prefill.email ?? prefill.username ?? '',
+            password: prefill.password ?? ''
+        },
+        onSubmit: async ({ value })=>{
+            if (!showPasswordField) return;
+            const { login, password } = value;
+            const isEmail = isValidEmail(login);
+            console.log(value);
+            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  {
+                toast.error(t('error:unknown') || 'An unexpected error occurred');
+            }
+        },
+        validators: showPasswordField ? {
+            onSubmit: loginSchema
+        } : undefined
+    });
+    if (!showEmailField) return null;
+    if (requireEmailVerification) {
+        return /*#__PURE__*/ _jsx(FormHeader, {
+            heading: "Please verify your email",
+            description: t('authentication:emailSent'),
+            style: {
+                textAlign: 'center'
+            }
+        });
+    }
+    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 === 'signup_disabled' && /*#__PURE__*/ _jsx(FormError, {
+                errors: [
+                    'Sign up is disabled.'
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Form, {
+                className: baseClass,
+                onSubmit: (e)=>{
+                    e.preventDefault();
+                    if (showPasswordField) {
+                        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(),
+                                        onValueChange: setEmail
+                                    })
+                            }),
+                            showPasswordField && /*#__PURE__*/ _jsx(form.AppField, {
+                                name: "password",
+                                children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                                        type: "password",
+                                        className: "password",
+                                        autoComplete: "password",
+                                        label: t('general:password')
+                                    })
+                            })
+                        ]
+                    }),
+                    showPasswordField && /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Link, {
+                                href: forgotPasswordUrl,
+                                prefetch: false,
+                                children: t('authentication:forgotPasswordQuestion')
+                            }),
+                            /*#__PURE__*/ _jsx("button", {
+                                type: "submit",
+                                style: {
+                                    display: 'none'
+                                },
+                                tabIndex: -1
+                            }),
+                            /*#__PURE__*/ _jsx(form.AppForm, {
+                                children: /*#__PURE__*/ _jsx(form.Submit, {
+                                    label: t('authentication:login'),
+                                    loadingLabel: t('general:loading')
+                                })
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/credentials-form.tsx"],"sourcesContent":["'use client'\n\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 { valueOrDefaultString } from '@/shared/utils/value-or-default'\nimport { useConfig, Link, toast, useTranslation } from '@payloadcms/ui'\nimport { formatAdminURL } from 'payload/shared'\nimport React, { useState } from 'react'\nimport { useLoginForm } from './context'\nimport './index.scss'\n\nconst baseClass = 'login__form'\n\nexport const CredentialsForm: React.FC = () => {\n  const { config } = useConfig()\n  const { t } = useTranslation()\n  const { authClient, loginType, hasMethod, setEmail, redirectUrl, prefill } = useLoginForm()\n  const adminRoute = valueOrDefaultString(config?.routes?.admin, '/admin')\n\n  const hasEmailPassword = hasMethod('emailPassword')\n  const hasMagicLink = hasMethod('magicLink')\n  const showEmailField = hasEmailPassword || hasMagicLink\n  const showPasswordField = hasEmailPassword\n\n  const [requireEmailVerification, setRequireEmailVerification] = useState(false)\n  const [searchParamError] = useState(() => {\n    if (typeof window !== 'undefined') {\n      const params = new URLSearchParams(window.location.search)\n      return params.get('error')\n    }\n    return null\n  })\n\n  const forgotPasswordUrl = formatAdminURL({\n    adminRoute,\n    path: adminRoutes?.forgotPassword as `/${string}`\n  })\n\n  const loginSchema = createLoginSchema({ t, loginType, canLoginWithUsername: loginType !== 'email' })\n\n  const form = useAppForm({\n    defaultValues: {\n      login: prefill.email ?? prefill.username ?? '',\n      password: prefill.password ?? ''\n    },\n    onSubmit: async ({ value }) => {\n      if (!showPasswordField) return\n\n      const { login, password } = value\n      const isEmail = isValidEmail(login)\n      console.log(value)\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 {\n        toast.error(t('error:unknown') || 'An unexpected error occurred')\n      }\n    },\n    validators: showPasswordField ? { onSubmit: loginSchema } : undefined\n  })\n\n  if (!showEmailField) return null\n\n  if (requireEmailVerification) {\n    return <FormHeader heading=\"Please verify your email\" description={t('authentication:emailSent')} style={{ textAlign: 'center' }} />\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 === 'signup_disabled' && <FormError errors={['Sign up is disabled.']} />}\n      <Form\n        className={baseClass}\n        onSubmit={(e) => {\n          e.preventDefault()\n          if (showPasswordField) {\n            void form.handleSubmit()\n          }\n        }}>\n        <FormInputWrap className={baseClass}>\n          <form.AppField\n            name=\"login\"\n            children={(field) => (\n              <field.TextField\n                type=\"text\"\n                className=\"email\"\n                autoComplete=\"email\"\n                label={getLoginTypeLabel()}\n                onValueChange={setEmail}\n              />\n            )}\n          />\n          {showPasswordField && (\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          )}\n        </FormInputWrap>\n        {showPasswordField && (\n          <>\n            <Link href={forgotPasswordUrl} prefetch={false}>\n              {t('authentication:forgotPasswordQuestion')}\n            </Link>\n            <button type=\"submit\" style={{ display: 'none' }} tabIndex={-1} />\n            <form.AppForm children={<form.Submit label={t('authentication:login')} loadingLabel={t('general:loading')} />} />\n          </>\n        )}\n      </Form>\n    </div>\n  )\n}\n\n"],"names":["adminRoutes","useAppForm","Form","FormError","FormInputWrap","FormHeader","createLoginSchema","isValidEmail","valueOrDefaultString","useConfig","Link","toast","useTranslation","formatAdminURL","React","useState","useLoginForm","baseClass","CredentialsForm","config","t","authClient","loginType","hasMethod","setEmail","redirectUrl","prefill","adminRoute","routes","admin","hasEmailPassword","hasMagicLink","showEmailField","showPasswordField","requireEmailVerification","setRequireEmailVerification","searchParamError","window","params","URLSearchParams","location","search","get","forgotPasswordUrl","path","forgotPassword","loginSchema","canLoginWithUsername","form","defaultValues","login","email","username","password","onSubmit","value","isEmail","console","log","data","error","signIn","callbackURL","code","message","charAt","toUpperCase","slice","token","success","href","validators","undefined","heading","description","style","textAlign","getLoginTypeLabel","labels","emailOrUsername","div","className","errors","e","preventDefault","handleSubmit","AppField","name","children","field","TextField","type","autoComplete","label","onValueChange","prefetch","button","display","tabIndex","AppForm","Submit","loadingLabel"],"mappings":"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"}

package/dist/better-auth/plugin/payload/components/login-form/index.d.ts

@@ -0,0 +1,4 @@
+export { LoginFormProvider, useLoginForm, type LoginFormProviderProps } from './context';
+export { CredentialsForm } from './credentials-form';
+export { AlternativeMethods } from './alternative-methods';
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/components/login-form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACxF,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/better-auth/plugin/payload/components/login-form/index.js

@@ -0,0 +1,6 @@
+'use client';
+export { LoginFormProvider, useLoginForm } from "./context";
+export { CredentialsForm } from "./credentials-form";
+export { AlternativeMethods } from "./alternative-methods";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vcGF5bG9hZC9jb21wb25lbnRzL2xvZ2luLWZvcm0vaW5kZXgudHN4Il0sInNvdXJjZXNDb250ZW50IjpbIid1c2UgY2xpZW50J1xuXG5leHBvcnQgeyBMb2dpbkZvcm1Qcm92aWRlciwgdXNlTG9naW5Gb3JtLCB0eXBlIExvZ2luRm9ybVByb3ZpZGVyUHJvcHMgfSBmcm9tICcuL2NvbnRleHQnXG5leHBvcnQgeyBDcmVkZW50aWFsc0Zvcm0gfSBmcm9tICcuL2NyZWRlbnRpYWxzLWZvcm0nXG5leHBvcnQgeyBBbHRlcm5hdGl2ZU1ldGhvZHMgfSBmcm9tICcuL2FsdGVybmF0aXZlLW1ldGhvZHMnXG5cbiJdLCJuYW1lcyI6WyJMb2dpbkZvcm1Qcm92aWRlciIsInVzZUxvZ2luRm9ybSIsIkNyZWRlbnRpYWxzRm9ybSIsIkFsdGVybmF0aXZlTWV0aG9kcyJdLCJtYXBwaW5ncyI6IkFBQUE7QUFFQSxTQUFTQSxpQkFBaUIsRUFBRUMsWUFBWSxRQUFxQyxZQUFXO0FBQ3hGLFNBQVNDLGVBQWUsUUFBUSxxQkFBb0I7QUFDcEQsU0FBU0Msa0JBQWtCLFFBQVEsd0JBQXVCIn0=