@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/plugin/payload/components/admin-invite-button/index.js

@@ -0,0 +1,213 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Modal, Select, TextInput, toast, useConfig, useModal } from "@payloadcms/ui";
+import { Copy, Loader2, XIcon } from "lucide-react";
+import { usePathname } from "next/navigation";
+import React, { useState } from "react";
+import { adminEndpoints } from "../../../constants";
+import "./index.scss";
+const baseClass = "admin-invite-modal";
+export function AdminInviteButton({ roles }) {
+    const [role, setRole] = useState(undefined);
+    const [email, setEmail] = useState("");
+    const [inviteLink, setInviteLink] = useState("");
+    const [isLoading, setIsLoading] = useState(false);
+    const [isCopyLoading, setIsCopyLoading] = useState(false);
+    const { toggleModal } = useModal();
+    const { config: { serverURL, routes: { api: apiRoute, admin: adminRoute }, admin: { user: userSlug } } } = useConfig();
+    // Only render invite button in list view.
+    const pathname = usePathname();
+    if (pathname !== `${adminRoute}/collections/${userSlug}`) return null;
+    const handleGenerateInvite = async ()=>{
+        if (!role) {
+            toast.error("Please select a role first");
+            return null;
+        }
+        try {
+            const url = `${serverURL}${apiRoute}/${userSlug}${adminEndpoints.generateInviteUrl}`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    role
+                }),
+                credentials: "include"
+            });
+            if (!response.ok) throw new Error("Failed to generate invite");
+            const data = await response.json();
+            setInviteLink(data.inviteLink);
+            return data.inviteLink;
+        } catch (error) {
+            toast.error("Failed to generate invite link");
+            return null;
+        }
+    };
+    const handleSendEmail = async ()=>{
+        if (!role) {
+            toast.error("Please select a role first");
+            return;
+        }
+        if (!email) {
+            toast.error("Please enter an email address");
+            return;
+        }
+        try {
+            setIsLoading(true);
+            let linkToCopy = inviteLink;
+            if (!linkToCopy) {
+                linkToCopy = await handleGenerateInvite();
+            }
+            if (linkToCopy) {
+                const response = await fetch(`${serverURL}${apiRoute}/${userSlug}${adminEndpoints.sendInvite}`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({
+                        email,
+                        link: linkToCopy
+                    }),
+                    credentials: "include"
+                });
+                if (!response.ok) throw new Error("Failed to send invite");
+                toast.success("Invite sent successfully");
+                handleToggleModal();
+            }
+        } catch (error) {
+            toast.error("Failed to send invite email");
+        } finally{
+            setIsLoading(false);
+        }
+    };
+    const handleCopyLink = async ()=>{
+        if (!role) {
+            toast.error("Please select a role first");
+            return;
+        }
+        try {
+            setIsCopyLoading(true);
+            let linkToCopy = inviteLink;
+            if (!linkToCopy) {
+                linkToCopy = await handleGenerateInvite();
+            }
+            if (linkToCopy) {
+                await navigator.clipboard.writeText(linkToCopy);
+                toast.success("Invite link copied to clipboard");
+                toggleModal("admin-invite-modal");
+            }
+        } catch (error) {
+            toast.error("Failed to copy invite link");
+        } finally{
+            setIsCopyLoading(false);
+        }
+    };
+    const handleToggleModal = ()=>{
+        toggleModal("admin-invite-modal");
+    };
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Button, {
+                onClick: handleToggleModal,
+                type: "button",
+                size: "small",
+                buttonStyle: "pill",
+                className: "admin-invite-button",
+                children: "Invite User"
+            }),
+            /*#__PURE__*/ _jsx(Modal, {
+                slug: "admin-invite-modal",
+                className: `${baseClass}`,
+                closeOnBlur: true,
+                children: /*#__PURE__*/ _jsxs("div", {
+                    className: `${baseClass}__wrapper`,
+                    children: [
+                        /*#__PURE__*/ _jsx(Button, {
+                            onClick: handleToggleModal,
+                            buttonStyle: "icon-label",
+                            size: "small",
+                            className: `${baseClass}__close-button`,
+                            children: /*#__PURE__*/ _jsx(XIcon, {
+                                size: 24
+                            })
+                        }),
+                        /*#__PURE__*/ _jsxs("div", {
+                            className: `${baseClass}__content`,
+                            style: {
+                                maxWidth: "38rem"
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx("h2", {
+                                    children: "Invite User"
+                                }),
+                                /*#__PURE__*/ _jsx("p", {
+                                    children: "Invite a user to your application. Select the role of the user and send the invite via email or copy the invite link."
+                                }),
+                                /*#__PURE__*/ _jsx(Select, {
+                                    options: roles,
+                                    value: role,
+                                    placeholder: "Select Role",
+                                    onChange: (option)=>setRole(option)
+                                }),
+                                /*#__PURE__*/ _jsxs("div", {
+                                    className: `${baseClass}__invite-controls`,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("div", {
+                                            className: `${baseClass}__email-field`,
+                                            children: /*#__PURE__*/ _jsx(TextInput, {
+                                                label: "Email Address",
+                                                path: "email",
+                                                value: email,
+                                                onChange: (e)=>setEmail(e.target.value),
+                                                placeholder: "user@example.com"
+                                            })
+                                        }),
+                                        /*#__PURE__*/ _jsxs("div", {
+                                            className: `${baseClass}__buttons`,
+                                            children: [
+                                                /*#__PURE__*/ _jsxs(Button, {
+                                                    type: "button",
+                                                    onClick: handleSendEmail,
+                                                    disabled: isLoading || !role || !email,
+                                                    children: [
+                                                        isLoading ? /*#__PURE__*/ _jsx(Loader2, {
+                                                            size: 24,
+                                                            className: "mr-2 animate-spin"
+                                                        }) : null,
+                                                        "Send Email"
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsxs(Button, {
+                                                    size: "medium",
+                                                    buttonStyle: "transparent",
+                                                    className: `${baseClass}__copy-button`,
+                                                    type: "button",
+                                                    onClick: handleCopyLink,
+                                                    disabled: isCopyLoading || !role,
+                                                    children: [
+                                                        isCopyLoading ? /*#__PURE__*/ _jsx(Loader2, {
+                                                            size: 20,
+                                                            strokeWidth: 1.5,
+                                                            className: "animate-spin"
+                                                        }) : /*#__PURE__*/ _jsx(Copy, {
+                                                            size: 20,
+                                                            strokeWidth: 1.5
+                                                        }),
+                                                        "Generate Link"
+                                                    ]
+                                                })
+                                            ]
+                                        })
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/components/admin-invite-button/index.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  Button,\n  Modal,\n  Select,\n  TextInput,\n  toast,\n  useConfig,\n  useModal\n} from \"@payloadcms/ui\";\nimport type { Option } from \"@payloadcms/ui/elements/ReactSelect\";\nimport { Copy, Loader2, XIcon } from \"lucide-react\";\nimport { usePathname } from \"next/navigation\";\nimport React, { useState } from \"react\";\nimport { adminEndpoints } from \"@/better-auth/plugin/constants\";\n\nimport \"./index.scss\";\n\nconst baseClass = \"admin-invite-modal\";\n\ninterface AdminInviteButtonProps {\n  roles: { label: string; value: string }[];\n}\n\nexport function AdminInviteButton({ roles }: AdminInviteButtonProps) {\n  const [role, setRole] = useState<Option | undefined>(undefined);\n  const [email, setEmail] = useState(\"\");\n  const [inviteLink, setInviteLink] = useState(\"\");\n  const [isLoading, setIsLoading] = useState(false);\n  const [isCopyLoading, setIsCopyLoading] = useState(false);\n  const { toggleModal } = useModal();\n\n  const {\n    config: {\n      serverURL,\n      routes: { api: apiRoute, admin: adminRoute },\n      admin: { user: userSlug }\n    }\n  } = useConfig();\n\n  // Only render invite button in list view.\n  const pathname = usePathname();\n  if (pathname !== `${adminRoute}/collections/${userSlug}`) return null;\n\n  const handleGenerateInvite = async () => {\n    if (!role) {\n      toast.error(\"Please select a role first\");\n      return null;\n    }\n\n    try {\n      const url = `${serverURL}${apiRoute}/${userSlug}${adminEndpoints.generateInviteUrl}`;\n      const response = await fetch(url, {\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify({ role }),\n        credentials: \"include\"\n      });\n      if (!response.ok) throw new Error(\"Failed to generate invite\");\n      const data = await response.json();\n      setInviteLink(data.inviteLink);\n      return data.inviteLink;\n    } catch (error) {\n      toast.error(\"Failed to generate invite link\");\n      return null;\n    }\n  };\n\n  const handleSendEmail = async () => {\n    if (!role) {\n      toast.error(\"Please select a role first\");\n      return;\n    }\n\n    if (!email) {\n      toast.error(\"Please enter an email address\");\n      return;\n    }\n\n    try {\n      setIsLoading(true);\n      let linkToCopy = inviteLink;\n      if (!linkToCopy) {\n        linkToCopy = await handleGenerateInvite();\n      }\n      if (linkToCopy) {\n        const response = await fetch(\n          `${serverURL}${apiRoute}/${userSlug}${adminEndpoints.sendInvite}`,\n          {\n            method: \"POST\",\n            headers: {\n              \"Content-Type\": \"application/json\"\n            },\n            body: JSON.stringify({ email, link: linkToCopy }),\n            credentials: \"include\"\n          }\n        );\n        if (!response.ok) throw new Error(\"Failed to send invite\");\n        toast.success(\"Invite sent successfully\");\n        handleToggleModal();\n      }\n    } catch (error) {\n      toast.error(\"Failed to send invite email\");\n    } finally {\n      setIsLoading(false);\n    }\n  };\n\n  const handleCopyLink = async () => {\n    if (!role) {\n      toast.error(\"Please select a role first\");\n      return;\n    }\n\n    try {\n      setIsCopyLoading(true);\n      let linkToCopy = inviteLink;\n\n      if (!linkToCopy) {\n        linkToCopy = await handleGenerateInvite();\n      }\n\n      if (linkToCopy) {\n        await navigator.clipboard.writeText(linkToCopy);\n        toast.success(\"Invite link copied to clipboard\");\n        toggleModal(\"admin-invite-modal\");\n      }\n    } catch (error) {\n      toast.error(\"Failed to copy invite link\");\n    } finally {\n      setIsCopyLoading(false);\n    }\n  };\n\n  const handleToggleModal = () => {\n    toggleModal(\"admin-invite-modal\");\n  };\n\n  return (\n    <>\n      <Button\n        onClick={handleToggleModal}\n        type=\"button\"\n        size=\"small\"\n        buttonStyle=\"pill\"\n        className=\"admin-invite-button\"\n      >\n        Invite User\n      </Button>\n      <Modal slug=\"admin-invite-modal\" className={`${baseClass}`} closeOnBlur>\n        <div className={`${baseClass}__wrapper`}>\n          <Button\n            onClick={handleToggleModal}\n            buttonStyle=\"icon-label\"\n            size=\"small\"\n            className={`${baseClass}__close-button`}\n          >\n            <XIcon size={24} />\n          </Button>\n          <div\n            className={`${baseClass}__content`}\n            style={{ maxWidth: \"38rem\" }}\n          >\n            <h2>Invite User</h2>\n            <p>\n              Invite a user to your application. Select the role of the user and\n              send the invite via email or copy the invite link.\n            </p>\n            <Select\n              options={roles}\n              value={role}\n              placeholder=\"Select Role\"\n              onChange={(option: any) => setRole(option)}\n            />\n\n            <div className={`${baseClass}__invite-controls`}>\n              <div className={`${baseClass}__email-field`}>\n                <TextInput\n                  label=\"Email Address\"\n                  path=\"email\"\n                  value={email}\n                  onChange={(e: any) => setEmail(e.target.value)}\n                  placeholder=\"user@example.com\"\n                />\n              </div>\n\n              <div className={`${baseClass}__buttons`}>\n                <Button\n                  type=\"button\"\n                  onClick={handleSendEmail}\n                  disabled={isLoading || !role || !email}\n                >\n                  {isLoading ? (\n                    <Loader2 size={24} className=\"mr-2 animate-spin\" />\n                  ) : null}\n                  Send Email\n                </Button>\n\n                <Button\n                  size=\"medium\"\n                  buttonStyle=\"transparent\"\n                  className={`${baseClass}__copy-button`}\n                  type=\"button\"\n                  onClick={handleCopyLink}\n                  disabled={isCopyLoading || !role}\n                >\n                  {isCopyLoading ? (\n                    <Loader2\n                      size={20}\n                      strokeWidth={1.5}\n                      className=\"animate-spin\"\n                    />\n                  ) : (\n                    <Copy size={20} strokeWidth={1.5} />\n                  )}\n                  Generate Link\n                </Button>\n              </div>\n            </div>\n          </div>\n        </div>\n      </Modal>\n    </>\n  );\n}\n"],"names":["Button","Modal","Select","TextInput","toast","useConfig","useModal","Copy","Loader2","XIcon","usePathname","React","useState","adminEndpoints","baseClass","AdminInviteButton","roles","role","setRole","undefined","email","setEmail","inviteLink","setInviteLink","isLoading","setIsLoading","isCopyLoading","setIsCopyLoading","toggleModal","config","serverURL","routes","api","apiRoute","admin","adminRoute","user","userSlug","pathname","handleGenerateInvite","error","url","generateInviteUrl","response","fetch","method","headers","body","JSON","stringify","credentials","ok","Error","data","json","handleSendEmail","linkToCopy","sendInvite","link","success","handleToggleModal","handleCopyLink","navigator","clipboard","writeText","onClick","type","size","buttonStyle","className","slug","closeOnBlur","div","style","maxWidth","h2","p","options","value","placeholder","onChange","option","label","path","e","target","disabled","strokeWidth"],"mappings":"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"}

package/dist/better-auth/plugin/payload/components/admin-invite-button/index.scss

@@ -0,0 +1,136 @@
+@mixin blur-bg($color: var(--theme-bg), $opacity: 0.75) {
+
+  &:before,
+  &:after {
+    content: ' ';
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+  }
+
+  &:before {
+    background: $color;
+    opacity: $opacity;
+  }
+
+  &:after {
+    backdrop-filter: blur(8px);
+  }
+}
+
+@layer payload-default {
+  .list-header:has(.collection-list__sub-header .admin-invite-button) {
+    display: flex;
+    align-items: center;
+  }
+
+  .list-header:has(.collection-list__sub-header .admin-invite-button) .list-selection {
+    order: 2;
+    margin-left: 0;
+  }
+
+  .list-header:has(.collection-list__sub-header .admin-invite-button) .collection-list__sub-header {
+    margin-left: auto;
+    display: flex;
+    justify-content: flex-start;
+    flex-basis: auto !important;
+  }
+
+  .list-header:has(.collection-list__sub-header .admin-invite-button) .btn {
+    flex-shrink: 0;
+    margin-bottom: 0;
+  }
+}
+
+@layer payload-default {
+  .admin-invite-modal {
+    @include blur-bg;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+
+    &__wrapper {
+      z-index: 1;
+      position: relative;
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+      border-radius: 3px;
+      border: 1px solid var(--theme-border-color);
+      background-color: var(--theme-elevation-50);
+    }
+
+    &__close-button {
+      position: absolute;
+      top: 0;
+      right: 0;
+      margin-block: 0 !important;
+      padding: 10px !important;
+
+      svg {
+        width: 24px;
+        height: 24px;
+      }
+    }
+
+    &__content {
+      display: flex;
+      flex-direction: column;
+      gap: 1.5rem;
+      padding: 1rem;
+
+      h1 {
+        font-size: 1.5rem;
+        font-weight: 600;
+        margin: 0;
+      }
+
+      p {
+        margin: 0;
+        color: var(--theme-elevation-500);
+      }
+    }
+
+    &__invite-controls {
+      display: flex;
+      flex-direction: column;
+      gap: 1rem;
+      margin-top: 0.5rem;
+    }
+
+    &__email-field {
+      width: 100%;
+    }
+
+    &__buttons {
+      display: flex;
+      gap: 1rem;
+      align-items: center;
+      justify-content: flex-end;
+
+      >.btn {
+        margin-block: 0.5rem !important;
+      }
+    }
+
+    &__copy-button {
+      &:hover {
+        background-color: var(--theme-elevation-200) !important;
+      }
+
+      .btn__label {
+        gap: 0.5rem;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+    }
+  }
+
+  .admin-invite-button {
+    display: block;
+  }
+}

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

@@ -0,0 +1,4 @@
+import React from "react";
+import "./index.scss";
+export declare function AlternativeMethods(): React.JSX.Element | null;
+//# sourceMappingURL=alternative-methods.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alternative-methods.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/login-form/alternative-methods.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAM3D,OAAO,cAAc,CAAC;AAsKtB,wBAAgB,kBAAkB,6BA2CjC"}

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 { Button, toast } from "@payloadcms/ui";
+import { Key, Mail } from "lucide-react";
+import { useRouter } from "next/navigation";
+import React, { useEffect, useRef, useState } from "react";
+import { socialProviders } from "../../../constants";
+import { Icons } from "../../../../../shared/components/icons";
+import { isValidEmail } from "../../../../../shared/form/validation";
+import { useLoginForm } from "./context";
+import "./index.scss";
+const baseClass = "login-form-methods";
+function 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
+        })
+    });
+}
+function 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"
+        })
+    });
+}
+function 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 function AlternativeMethods() {
+    const { alternativeMethods, hasMethod, isSignup, showIconOnly } = useLoginForm();
+    const [_, 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 { Button, toast } from \"@payloadcms/ui\";\nimport { Key, Mail } from \"lucide-react\";\nimport { useRouter } from \"next/navigation\";\nimport React, { useEffect, useRef, useState } from \"react\";\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 { useLoginForm } from \"./context\";\nimport \"./index.scss\";\n\nconst baseClass = \"login-form-methods\";\n\nfunction MagicLinkButton() {\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({\n        email,\n        callbackURL: redirectUrl\n      });\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    >\n      {!showIconOnly && <span>{loading ? \"Sending...\" : label}</span>}\n    </Button>\n  );\n}\n\ninterface PasskeyButtonProps {\n  setLoading: (loading: boolean) => void;\n}\n\nfunction PasskeyButton({ setLoading }: PasskeyButtonProps) {\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(\n              context.error.message || \"Failed to sign in with passkey\"\n            );\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    >\n      {!showIconOnly && <span>Passkey</span>}\n    </Button>\n  );\n}\n\ninterface SocialButtonProps {\n  provider: SocialProvider;\n  setLoading: (loading: boolean) => void;\n}\n\nfunction SocialButton({ provider, setLoading }: SocialButtonProps) {\n  const {\n    authClient,\n    redirectUrl,\n    isSignup,\n    showIconOnly,\n    adminInviteToken,\n    newUserCallbackURL\n  } = 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    >\n      {!showIconOnly && <span>{providerName}</span>}\n    </Button>\n  );\n}\n\nexport function AlternativeMethods() {\n  const { alternativeMethods, hasMethod, isSignup, showIconOnly } =\n    useLoginForm();\n  const [_, 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\n        className={`${baseClass} ${baseClass}--count-${showIconOnly ? \"many\" : alternativeMethods.length}`}\n      >\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 (\n              <SocialButton\n                key={method}\n                provider={method as SocialProvider}\n                setLoading={setLoading}\n              />\n            );\n          }\n\n          return null;\n        })}\n      </div>\n    </>\n  );\n}\n"],"names":["Button","toast","Key","Mail","useRouter","React","useEffect","useRef","useState","socialProviders","Icons","isValidEmail","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 React from "react";
+import type { LoginMethod } from "@/better-auth/plugin/types";
+interface 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 interface 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 function LoginFormProvider({ children, loginMethods, redirectUrl, baseURL, basePath, isSignup, loginIdentifiers, plugins, prefill, adminInviteToken, newUserCallbackURL }: LoginFormProviderProps): React.JSX.Element;
+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":"AAUA,OAAO,KAAuD,MAAM,OAAO,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,UAAU,qBAAqB;IAC7B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,GAAG,CAAC;IAChB,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,iBAAiB,CAAC;IACpD,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC;IAC5C,kBAAkB,EAAE,WAAW,EAAE,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAID,KAAK,OAAO,GAAG;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,KAAK,eAAe,GAAG,OAAO,GAAG,UAAU,CAAC;AAE5C,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,OAAO,EACP,QAAQ,EACR,QAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,OAAO,EACP,gBAAgB,EAChB,kBAAkB,EACnB,EAAE,sBAAsB,qBAyFxB;AAED,eAAO,MAAM,YAAY,6BAMxB,CAAC"}