@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/plugin/payload/views/forgot-password/client.js

@@ -0,0 +1,104 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { toast, useConfig, useTranslation } from "@payloadcms/ui";
+import { createAuthClient } from "better-auth/react";
+import { useMemo, useState } from "react";
+import { z } from "zod";
+import { adminRoutes } from "../../../constants";
+import { useAppForm } from "../../../../../shared/form";
+import { Form, FormInputWrap } from "../../../../../shared/form/ui";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+import { emailRegex } from "../../../../../shared/utils/regex";
+export function ForgotPasswordForm({ baseURL, basePath }) {
+    const { t } = useTranslation();
+    const { config } = useConfig();
+    const adminRoute = config.routes.admin;
+    const [hasSubmitted, setHasSubmitted] = useState(false);
+    const authClient = useMemo(()=>createAuthClient({
+            baseURL,
+            basePath
+        }), []);
+    const forgotSchema = z.object({
+        email: z.string().superRefine((val, ctx)=>{
+            if (!val) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: t("validation:required") || "Required"
+                });
+                return;
+            }
+            if (!emailRegex.test(val)) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: t("authentication:emailNotValid") || "Invalid email"
+                });
+            }
+        })
+    });
+    const form = useAppForm({
+        defaultValues: {
+            email: ""
+        },
+        onSubmit: async ({ value })=>{
+            const { email } = value;
+            try {
+                const { data, error } = await authClient.requestPasswordReset({
+                    email,
+                    redirectTo: `${adminRoute}${adminRoutes.resetPassword}`
+                });
+                if (error) {
+                    toast.error(error.message || t("authentication:emailNotValid") || "Error");
+                    return;
+                }
+                if (data?.status) {
+                    setHasSubmitted(true);
+                    toast.success("Successfully sent reset email.");
+                } else {
+                    toast.error(t("general:error") || "Server Error");
+                }
+            } catch (e) {
+                toast.error(t("general:error") || "An unexpected error occurred");
+            }
+        },
+        validators: {
+            onSubmit: forgotSchema
+        }
+    });
+    if (hasSubmitted) {
+        return /*#__PURE__*/ _jsx(FormHeader, {
+            description: t("authentication:checkYourEmailForPasswordReset"),
+            heading: t("authentication:emailSent")
+        });
+    }
+    return /*#__PURE__*/ _jsxs(Form, {
+        onSubmit: (e)=>{
+            e.preventDefault();
+            void form.handleSubmit();
+        },
+        children: [
+            /*#__PURE__*/ _jsx(FormHeader, {
+                heading: t("authentication:forgotPassword"),
+                description: t("authentication:forgotPasswordEmailInstructions")
+            }),
+            /*#__PURE__*/ _jsx(FormInputWrap, {
+                children: /*#__PURE__*/ _jsx(form.AppField, {
+                    name: "email",
+                    children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                            type: "text",
+                            className: "email",
+                            autoComplete: "email",
+                            label: t("general:email")
+                        })
+                })
+            }),
+            /*#__PURE__*/ _jsx(form.AppForm, {
+                children: /*#__PURE__*/ _jsx(form.Submit, {
+                    label: t("general:submit"),
+                    loadingLabel: t("general:loading")
+                })
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/views/forgot-password/client.tsx"],"sourcesContent":["\"use client\";\n\nimport { toast, useConfig, useTranslation } from \"@payloadcms/ui\";\nimport { createAuthClient } from \"better-auth/react\";\nimport { useMemo, useState } from \"react\";\nimport { z } from \"zod\";\nimport { adminRoutes } from \"@/better-auth/plugin/constants\";\nimport { useAppForm } from \"@/shared/form\";\nimport { Form, FormInputWrap } from \"@/shared/form/ui\";\nimport { FormHeader } from \"@/shared/form/ui/header\";\nimport { emailRegex } from \"@/shared/utils/regex\";\n\ninterface ForgotPasswordFormProps {\n  baseURL?: string;\n  basePath?: string;\n}\n\nexport function ForgotPasswordForm({\n  baseURL,\n  basePath\n}: ForgotPasswordFormProps) {\n  const { t } = useTranslation();\n  const { config } = useConfig();\n  const adminRoute = config.routes.admin;\n  const [hasSubmitted, setHasSubmitted] = useState<boolean>(false);\n  const authClient = useMemo(() => createAuthClient({ baseURL, basePath }), []);\n\n  const forgotSchema = z.object({\n    email: z.string().superRefine((val, ctx) => {\n      if (!val) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: t(\"validation:required\") || \"Required\"\n        });\n        return;\n      }\n\n      if (!emailRegex.test(val)) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: t(\"authentication:emailNotValid\") || \"Invalid email\"\n        });\n      }\n    })\n  });\n\n  const form = useAppForm({\n    defaultValues: {\n      email: \"\"\n    },\n    onSubmit: async ({ value }) => {\n      const { email } = value;\n      try {\n        const { data, error } = await authClient.requestPasswordReset({\n          email,\n          redirectTo: `${adminRoute}${adminRoutes.resetPassword}`\n        });\n        if (error) {\n          toast.error(\n            error.message || t(\"authentication:emailNotValid\") || \"Error\"\n          );\n          return;\n        }\n        if (data?.status) {\n          setHasSubmitted(true);\n          toast.success(\"Successfully sent reset email.\");\n        } else {\n          toast.error(t(\"general:error\") || \"Server Error\");\n        }\n      } catch (e) {\n        toast.error(t(\"general:error\") || \"An unexpected error occurred\");\n      }\n    },\n    validators: {\n      onSubmit: forgotSchema\n    }\n  });\n\n  if (hasSubmitted) {\n    return (\n      <FormHeader\n        description={t(\"authentication:checkYourEmailForPasswordReset\")}\n        heading={t(\"authentication:emailSent\")}\n      />\n    );\n  }\n\n  return (\n    <Form\n      onSubmit={(e) => {\n        e.preventDefault();\n        void form.handleSubmit();\n      }}\n    >\n      <FormHeader\n        heading={t(\"authentication:forgotPassword\")}\n        description={t(\"authentication:forgotPasswordEmailInstructions\")}\n      />\n      <FormInputWrap>\n        <form.AppField\n          name=\"email\"\n          children={(field) => (\n            <field.TextField\n              type=\"text\"\n              className=\"email\"\n              autoComplete=\"email\"\n              label={t(\"general:email\")}\n            />\n          )}\n        />\n      </FormInputWrap>\n      <form.AppForm\n        children={\n          <form.Submit\n            label={t(\"general:submit\")}\n            loadingLabel={t(\"general:loading\")}\n          />\n        }\n      />\n    </Form>\n  );\n}\n"],"names":["toast","useConfig","useTranslation","createAuthClient","useMemo","useState","z","adminRoutes","useAppForm","Form","FormInputWrap","FormHeader","emailRegex","ForgotPasswordForm","baseURL","basePath","t","config","adminRoute","routes","admin","hasSubmitted","setHasSubmitted","authClient","forgotSchema","object","email","string","superRefine","val","ctx","addIssue","code","message","test","form","defaultValues","onSubmit","value","data","error","requestPasswordReset","redirectTo","resetPassword","status","success","e","validators","description","heading","preventDefault","handleSubmit","AppField","name","children","field","TextField","type","className","autoComplete","label","AppForm","Submit","loadingLabel"],"mappings":"AAAA;;AAEA,SAASA,KAAK,EAAEC,SAAS,EAAEC,cAAc,QAAQ,iBAAiB;AAClE,SAASC,gBAAgB,QAAQ,oBAAoB;AACrD,SAASC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AAC1C,SAASC,CAAC,QAAQ,MAAM;AACxB,SAASC,WAAW,QAAQ,qBAAiC;AAC7D,SAASC,UAAU,QAAQ,6BAAgB;AAC3C,SAASC,IAAI,EAAEC,aAAa,QAAQ,gCAAmB;AACvD,SAASC,UAAU,QAAQ,uCAA0B;AACrD,SAASC,UAAU,QAAQ,oCAAuB;AAOlD,OAAO,SAASC,mBAAmB,EACjCC,OAAO,EACPC,QAAQ,EACgB;IACxB,MAAM,EAAEC,CAAC,EAAE,GAAGd;IACd,MAAM,EAAEe,MAAM,EAAE,GAAGhB;IACnB,MAAMiB,aAAaD,OAAOE,MAAM,CAACC,KAAK;IACtC,MAAM,CAACC,cAAcC,gBAAgB,GAAGjB,SAAkB;IAC1D,MAAMkB,aAAanB,QAAQ,IAAMD,iBAAiB;YAAEW;YAASC;QAAS,IAAI,EAAE;IAE5E,MAAMS,eAAelB,EAAEmB,MAAM,CAAC;QAC5BC,OAAOpB,EAAEqB,MAAM,GAAGC,WAAW,CAAC,CAACC,KAAKC;YAClC,IAAI,CAACD,KAAK;gBACRC,IAAIC,QAAQ,CAAC;oBACXC,MAAM;oBACNC,SAASjB,EAAE,0BAA0B;gBACvC;gBACA;YACF;YAEA,IAAI,CAACJ,WAAWsB,IAAI,CAACL,MAAM;gBACzBC,IAAIC,QAAQ,CAAC;oBACXC,MAAM;oBACNC,SAASjB,EAAE,mCAAmC;gBAChD;YACF;QACF;IACF;IAEA,MAAMmB,OAAO3B,WAAW;QACtB4B,eAAe;YACbV,OAAO;QACT;QACAW,UAAU,OAAO,EAAEC,KAAK,EAAE;YACxB,MAAM,EAAEZ,KAAK,EAAE,GAAGY;YAClB,IAAI;gBACF,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAMjB,WAAWkB,oBAAoB,CAAC;oBAC5Df;oBACAgB,YAAY,GAAGxB,aAAaX,YAAYoC,aAAa,EAAE;gBACzD;gBACA,IAAIH,OAAO;oBACTxC,MAAMwC,KAAK,CACTA,MAAMP,OAAO,IAAIjB,EAAE,mCAAmC;oBAExD;gBACF;gBACA,IAAIuB,MAAMK,QAAQ;oBAChBtB,gBAAgB;oBAChBtB,MAAM6C,OAAO,CAAC;gBAChB,OAAO;oBACL7C,MAAMwC,KAAK,CAACxB,EAAE,oBAAoB;gBACpC;YACF,EAAE,OAAO8B,GAAG;gBACV9C,MAAMwC,KAAK,CAACxB,EAAE,oBAAoB;YACpC;QACF;QACA+B,YAAY;YACVV,UAAUb;QACZ;IACF;IAEA,IAAIH,cAAc;QAChB,qBACE,KAACV;YACCqC,aAAahC,EAAE;YACfiC,SAASjC,EAAE;;IAGjB;IAEA,qBACE,MAACP;QACC4B,UAAU,CAACS;YACTA,EAAEI,cAAc;YAChB,KAAKf,KAAKgB,YAAY;QACxB;;0BAEA,KAACxC;gBACCsC,SAASjC,EAAE;gBACXgC,aAAahC,EAAE;;0BAEjB,KAACN;0BACC,cAAA,KAACyB,KAAKiB,QAAQ;oBACZC,MAAK;oBACLC,UAAU,CAACC,sBACT,KAACA,MAAMC,SAAS;4BACdC,MAAK;4BACLC,WAAU;4BACVC,cAAa;4BACbC,OAAO5C,EAAE;;;;0BAKjB,KAACmB,KAAK0B,OAAO;gBACXP,wBACE,KAACnB,KAAK2B,MAAM;oBACVF,OAAO5C,EAAE;oBACT+C,cAAc/C,EAAE;;;;;AAM5B"}

package/dist/better-auth/plugin/payload/views/forgot-password/index.d.ts

@@ -0,0 +1,9 @@
+import type { AdminViewServerProps } from "payload";
+import React from "react";
+import type { PayloadAuthOptions } from "@/better-auth/plugin/types";
+interface ForgotPasswordProps extends AdminViewServerProps {
+    pluginOptions: PayloadAuthOptions;
+}
+declare function ForgotPassword({ pluginOptions, initPageResult }: ForgotPasswordProps): React.JSX.Element;
+export default ForgotPassword;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/views/forgot-password/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/forgot-password/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAIrE,UAAU,mBAAoB,SAAQ,oBAAoB;IACxD,aAAa,EAAE,kBAAkB,CAAC;CACnC;AAED,iBAAS,cAAc,CAAC,EACtB,aAAa,EACb,cAAc,EACf,EAAE,mBAAmB,qBAiErB;AAED,eAAe,cAAc,CAAC"}

package/dist/better-auth/plugin/payload/views/forgot-password/index.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MinimalTemplate } from "@payloadcms/next/templates";
+import { Button, Translation } from "@payloadcms/ui";
+import Link from "next/link";
+import { formatAdminURL } from "payload/shared";
+import React, { Fragment } from "react";
+import { adminRoutes } from "../../../constants";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+import { ForgotPasswordForm } from "./client";
+function ForgotPassword({ pluginOptions, initPageResult }) {
+    const { req: { payload: { config: { admin: { routes: { account: accountRoute } }, routes: { admin: adminRoute } } }, user, i18n } } = initPageResult;
+    if (user) {
+        return /*#__PURE__*/ _jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ _jsx(FormHeader, {
+                    description: /*#__PURE__*/ _jsx(Translation, {
+                        elements: {
+                            "0": ({ children })=>/*#__PURE__*/ _jsx(Link, {
+                                    href: formatAdminURL({
+                                        adminRoute,
+                                        path: accountRoute
+                                    }),
+                                    prefetch: false,
+                                    children: children
+                                })
+                        },
+                        i18nKey: "authentication:loggedInChangePassword",
+                        t: i18n.t
+                    }),
+                    heading: i18n.t("authentication:alreadyLoggedIn")
+                }),
+                /*#__PURE__*/ _jsx(Button, {
+                    buttonStyle: "secondary",
+                    el: "link",
+                    size: "large",
+                    to: adminRoute,
+                    children: i18n.t("general:backToDashboard")
+                })
+            ]
+        });
+    }
+    return /*#__PURE__*/ _jsxs(MinimalTemplate, {
+        children: [
+            /*#__PURE__*/ _jsx(ForgotPasswordForm, {
+                baseURL: pluginOptions.betterAuthOptions?.baseURL,
+                basePath: pluginOptions.betterAuthOptions?.basePath
+            }),
+            /*#__PURE__*/ _jsx(Link, {
+                href: formatAdminURL({
+                    adminRoute,
+                    path: adminRoutes.adminLogin
+                }),
+                prefetch: false,
+                children: i18n.t("authentication:backToLogin")
+            })
+        ]
+    });
+}
+export default ForgotPassword;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/payload/views/reset-password/client.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+interface PasswordResetFormProps {
+    readonly token: string;
+    readonly minPasswordLength?: number;
+    readonly maxPasswordLength?: number;
+    readonly baseURL?: string;
+    readonly basePath?: string;
+}
+export declare function PasswordResetForm({ token, baseURL, basePath }: PasswordResetFormProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/better-auth/plugin/payload/views/reset-password/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/reset-password/client.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAKvC,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,OAAO,EACP,QAAQ,EACT,EAAE,sBAAsB,qBAsHxB"}

package/dist/better-auth/plugin/payload/views/reset-password/client.js

@@ -0,0 +1,111 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { toast, useAuth, useConfig, useTranslation } from "@payloadcms/ui";
+import { createAuthClient } from "better-auth/react";
+import { useRouter } from "next/navigation.js";
+import { formatAdminURL } from "payload/shared";
+import React, { useMemo } from "react";
+import { z } from "zod";
+import { useAppForm } from "../../../../../shared/form";
+import { Form, FormInputWrap } from "../../../../../shared/form/ui";
+export function PasswordResetForm({ token, baseURL, basePath }) {
+    const { t } = useTranslation();
+    const history = useRouter();
+    const { fetchFullUser } = useAuth();
+    const authClient = useMemo(()=>createAuthClient({
+            baseURL,
+            basePath
+        }), []);
+    const { config: { admin: { routes: { login: loginRoute } }, routes: { admin: adminRoute } } } = useConfig();
+    const resetPasswordSchema = z.object({
+        password: z.string().min(1, t("validation:required") || "Password is required"),
+        confirmPassword: z.string().min(1, t("validation:required") || "Confirm password is required")
+    }).refine((data)=>{
+        // Only validate matching passwords if both fields have values
+        if (data.password && data.confirmPassword) {
+            return data.password === data.confirmPassword;
+        }
+        // If one or both fields are empty, validation will be handled by the min(1) validators
+        return true;
+    }, {
+        message: t("fields:passwordsDoNotMatch") || "Passwords do not match",
+        path: [
+            "confirmPassword"
+        ]
+    });
+    const form = useAppForm({
+        defaultValues: {
+            password: "",
+            confirmPassword: ""
+        },
+        onSubmit: async ({ value })=>{
+            const { password } = value;
+            try {
+                const { data, error } = await authClient.resetPassword({
+                    newPassword: password,
+                    token
+                });
+                if (error) {
+                    toast.error(error.message || "Error resetting password");
+                    return;
+                }
+                if (data?.status) {
+                    const user = await fetchFullUser();
+                    if (user) {
+                        history.push(adminRoute);
+                    } else {
+                        history.push(formatAdminURL({
+                            adminRoute,
+                            path: loginRoute
+                        }));
+                    }
+                    toast.success(t("authentication:passwordResetSuccessfully"));
+                }
+            } catch (e) {
+                toast.error("An unexpected error occurred");
+            }
+        },
+        validators: {
+            onSubmit: resetPasswordSchema
+        }
+    });
+    return /*#__PURE__*/ _jsxs(Form, {
+        onSubmit: (e)=>{
+            e.preventDefault();
+            void form.handleSubmit();
+        },
+        children: [
+            /*#__PURE__*/ _jsxs(FormInputWrap, {
+                className: "login__form",
+                children: [
+                    /*#__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("authentication:resetPassword"),
+                    loadingLabel: t("general:loading")
+                })
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/payload/views/reset-password/client.tsx"],"sourcesContent":["\"use client\";\n\nimport { toast, useAuth, useConfig, useTranslation } from \"@payloadcms/ui\";\nimport { createAuthClient } from \"better-auth/react\";\nimport { useRouter } from \"next/navigation.js\";\nimport { formatAdminURL } from \"payload/shared\";\nimport React, { useMemo } from \"react\";\nimport { z } from \"zod\";\nimport { useAppForm } from \"@/shared/form\";\nimport { Form, FormInputWrap } from \"@/shared/form/ui\";\n\ninterface PasswordResetFormProps {\n  readonly token: string;\n  readonly minPasswordLength?: number;\n  readonly maxPasswordLength?: number;\n  readonly baseURL?: string;\n  readonly basePath?: string;\n}\n\nexport function PasswordResetForm({\n  token,\n  baseURL,\n  basePath\n}: PasswordResetFormProps) {\n  const { t } = useTranslation();\n  const history = useRouter();\n  const { fetchFullUser } = useAuth();\n  const authClient = useMemo(() => createAuthClient({ baseURL, basePath }), []);\n  const {\n    config: {\n      admin: {\n        routes: { login: loginRoute }\n      },\n      routes: { admin: adminRoute }\n    }\n  } = useConfig();\n\n  const resetPasswordSchema = z\n    .object({\n      password: z\n        .string()\n        .min(1, t(\"validation:required\") || \"Password is required\"),\n      confirmPassword: z\n        .string()\n        .min(1, t(\"validation:required\") || \"Confirm password is required\")\n    })\n    .refine(\n      (data) => {\n        // Only validate matching passwords if both fields have values\n        if (data.password && data.confirmPassword) {\n          return data.password === data.confirmPassword;\n        }\n        // If one or both fields are empty, validation will be handled by the min(1) validators\n        return true;\n      },\n      {\n        message: t(\"fields:passwordsDoNotMatch\") || \"Passwords do not match\",\n        path: [\"confirmPassword\"]\n      }\n    );\n\n  const form = useAppForm({\n    defaultValues: {\n      password: \"\",\n      confirmPassword: \"\"\n    },\n    onSubmit: async ({ value }) => {\n      const { password } = value;\n      try {\n        const { data, error } = await authClient.resetPassword({\n          newPassword: password,\n          token\n        });\n        if (error) {\n          toast.error(error.message || \"Error resetting password\");\n          return;\n        }\n        if (data?.status) {\n          const user = await fetchFullUser();\n          if (user) {\n            history.push(adminRoute);\n          } else {\n            history.push(\n              formatAdminURL({\n                adminRoute,\n                path: loginRoute\n              })\n            );\n          }\n          toast.success(t(\"authentication:passwordResetSuccessfully\"));\n        }\n      } catch (e) {\n        toast.error(\"An unexpected error occurred\");\n      }\n    },\n    validators: {\n      onSubmit: resetPasswordSchema\n    }\n  });\n\n  return (\n    <Form\n      onSubmit={(e) => {\n        e.preventDefault();\n        void form.handleSubmit();\n      }}\n    >\n      <FormInputWrap className=\"login__form\">\n        <form.AppField\n          name=\"password\"\n          children={(field) => (\n            <field.TextField\n              type=\"password\"\n              className=\"password\"\n              label={t(\"authentication:newPassword\")}\n              required\n            />\n          )}\n        />\n        <form.AppField\n          name=\"confirmPassword\"\n          children={(field) => (\n            <field.TextField\n              type=\"password\"\n              className=\"password\"\n              label={t(\"authentication:confirmPassword\")}\n              required\n            />\n          )}\n        />\n      </FormInputWrap>\n      <form.AppForm\n        children={\n          <form.Submit\n            label={t(\"authentication:resetPassword\")}\n            loadingLabel={t(\"general:loading\")}\n          />\n        }\n      />\n    </Form>\n  );\n}\n"],"names":["toast","useAuth","useConfig","useTranslation","createAuthClient","useRouter","formatAdminURL","React","useMemo","z","useAppForm","Form","FormInputWrap","PasswordResetForm","token","baseURL","basePath","t","history","fetchFullUser","authClient","config","admin","routes","login","loginRoute","adminRoute","resetPasswordSchema","object","password","string","min","confirmPassword","refine","data","message","path","form","defaultValues","onSubmit","value","error","resetPassword","newPassword","status","user","push","success","e","validators","preventDefault","handleSubmit","className","AppField","name","children","field","TextField","type","label","required","AppForm","Submit","loadingLabel"],"mappings":"AAAA;;AAEA,SAASA,KAAK,EAAEC,OAAO,EAAEC,SAAS,EAAEC,cAAc,QAAQ,iBAAiB;AAC3E,SAASC,gBAAgB,QAAQ,oBAAoB;AACrD,SAASC,SAAS,QAAQ,qBAAqB;AAC/C,SAASC,cAAc,QAAQ,iBAAiB;AAChD,OAAOC,SAASC,OAAO,QAAQ,QAAQ;AACvC,SAASC,CAAC,QAAQ,MAAM;AACxB,SAASC,UAAU,QAAQ,6BAAgB;AAC3C,SAASC,IAAI,EAAEC,aAAa,QAAQ,gCAAmB;AAUvD,OAAO,SAASC,kBAAkB,EAChCC,KAAK,EACLC,OAAO,EACPC,QAAQ,EACe;IACvB,MAAM,EAAEC,CAAC,EAAE,GAAGd;IACd,MAAMe,UAAUb;IAChB,MAAM,EAAEc,aAAa,EAAE,GAAGlB;IAC1B,MAAMmB,aAAaZ,QAAQ,IAAMJ,iBAAiB;YAAEW;YAASC;QAAS,IAAI,EAAE;IAC5E,MAAM,EACJK,QAAQ,EACNC,OAAO,EACLC,QAAQ,EAAEC,OAAOC,UAAU,EAAE,EAC9B,EACDF,QAAQ,EAAED,OAAOI,UAAU,EAAE,EAC9B,EACF,GAAGxB;IAEJ,MAAMyB,sBAAsBlB,EACzBmB,MAAM,CAAC;QACNC,UAAUpB,EACPqB,MAAM,GACNC,GAAG,CAAC,GAAGd,EAAE,0BAA0B;QACtCe,iBAAiBvB,EACdqB,MAAM,GACNC,GAAG,CAAC,GAAGd,EAAE,0BAA0B;IACxC,GACCgB,MAAM,CACL,CAACC;QACC,8DAA8D;QAC9D,IAAIA,KAAKL,QAAQ,IAAIK,KAAKF,eAAe,EAAE;YACzC,OAAOE,KAAKL,QAAQ,KAAKK,KAAKF,eAAe;QAC/C;QACA,uFAAuF;QACvF,OAAO;IACT,GACA;QACEG,SAASlB,EAAE,iCAAiC;QAC5CmB,MAAM;YAAC;SAAkB;IAC3B;IAGJ,MAAMC,OAAO3B,WAAW;QACtB4B,eAAe;YACbT,UAAU;YACVG,iBAAiB;QACnB;QACAO,UAAU,OAAO,EAAEC,KAAK,EAAE;YACxB,MAAM,EAAEX,QAAQ,EAAE,GAAGW;YACrB,IAAI;gBACF,MAAM,EAAEN,IAAI,EAAEO,KAAK,EAAE,GAAG,MAAMrB,WAAWsB,aAAa,CAAC;oBACrDC,aAAad;oBACbf;gBACF;gBACA,IAAI2B,OAAO;oBACTzC,MAAMyC,KAAK,CAACA,MAAMN,OAAO,IAAI;oBAC7B;gBACF;gBACA,IAAID,MAAMU,QAAQ;oBAChB,MAAMC,OAAO,MAAM1B;oBACnB,IAAI0B,MAAM;wBACR3B,QAAQ4B,IAAI,CAACpB;oBACf,OAAO;wBACLR,QAAQ4B,IAAI,CACVxC,eAAe;4BACboB;4BACAU,MAAMX;wBACR;oBAEJ;oBACAzB,MAAM+C,OAAO,CAAC9B,EAAE;gBAClB;YACF,EAAE,OAAO+B,GAAG;gBACVhD,MAAMyC,KAAK,CAAC;YACd;QACF;QACAQ,YAAY;YACVV,UAAUZ;QACZ;IACF;IAEA,qBACE,MAAChB;QACC4B,UAAU,CAACS;YACTA,EAAEE,cAAc;YAChB,KAAKb,KAAKc,YAAY;QACxB;;0BAEA,MAACvC;gBAAcwC,WAAU;;kCACvB,KAACf,KAAKgB,QAAQ;wBACZC,MAAK;wBACLC,UAAU,CAACC,sBACT,KAACA,MAAMC,SAAS;gCACdC,MAAK;gCACLN,WAAU;gCACVO,OAAO1C,EAAE;gCACT2C,QAAQ;;;kCAId,KAACvB,KAAKgB,QAAQ;wBACZC,MAAK;wBACLC,UAAU,CAACC,sBACT,KAACA,MAAMC,SAAS;gCACdC,MAAK;gCACLN,WAAU;gCACVO,OAAO1C,EAAE;gCACT2C,QAAQ;;;;;0BAKhB,KAACvB,KAAKwB,OAAO;gBACXN,wBACE,KAAClB,KAAKyB,MAAM;oBACVH,OAAO1C,EAAE;oBACT8C,cAAc9C,EAAE;;;;;AAM5B"}

package/dist/better-auth/plugin/payload/views/reset-password/index.d.ts

@@ -0,0 +1,9 @@
+import type { AdminViewServerProps } from "payload";
+import React from "react";
+import type { PayloadAuthOptions } from "@/better-auth/plugin/types";
+interface ResetPasswordProps extends AdminViewServerProps {
+    pluginOptions: PayloadAuthOptions;
+}
+declare function ResetPassword({ pluginOptions, initPageResult, searchParams }: ResetPasswordProps): React.JSX.Element;
+export default ResetPassword;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/views/reset-password/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/reset-password/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAUrE,UAAU,kBAAmB,SAAQ,oBAAoB;IACvD,aAAa,EAAE,kBAAkB,CAAC;CACnC;AAED,iBAAS,aAAa,CAAC,EACrB,aAAa,EACb,cAAc,EACd,YAAY,EACb,EAAE,kBAAkB,qBAyEpB;AAED,eAAe,aAAa,CAAC"}

package/dist/better-auth/plugin/payload/views/reset-password/index.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MinimalTemplate } from "@payloadcms/next/templates";
+import { Button, Link, Translation } from "@payloadcms/ui";
+import { formatAdminURL } from "payload/shared";
+import React from "react";
+import { z } from "zod";
+import { adminRoutes } from "../../../constants";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+import { PasswordResetForm } from "./client";
+const resetPasswordParamsSchema = z.object({
+    token: z.string()
+});
+const resetPasswordBaseClass = "reset-password";
+function ResetPassword({ pluginOptions, initPageResult, searchParams }) {
+    const { req: { user, t, payload: { config: { routes: { admin: adminRoute }, admin: { routes: { account: accountRoute } } } } } } = initPageResult;
+    if (user) {
+        return /*#__PURE__*/ _jsxs(MinimalTemplate, {
+            className: `${resetPasswordBaseClass}`,
+            children: [
+                /*#__PURE__*/ _jsx(FormHeader, {
+                    description: /*#__PURE__*/ _jsx(Translation, {
+                        elements: {
+                            "0": ({ children })=>/*#__PURE__*/ _jsx(Link, {
+                                    href: formatAdminURL({
+                                        adminRoute,
+                                        path: accountRoute
+                                    }),
+                                    prefetch: false,
+                                    children: children
+                                })
+                        },
+                        i18nKey: "authentication:loggedInChangePassword",
+                        t: t
+                    }),
+                    heading: t("authentication:alreadyLoggedIn")
+                }),
+                /*#__PURE__*/ _jsx(Button, {
+                    buttonStyle: "secondary",
+                    el: "link",
+                    size: "large",
+                    to: adminRoute,
+                    children: t("general:backToDashboard")
+                })
+            ]
+        });
+    }
+    const resetPasswordParams = resetPasswordParamsSchema.safeParse(searchParams);
+    if (!resetPasswordParams.success) {
+        return /*#__PURE__*/ _jsx("div", {
+            children: "Invalid reset password params"
+        });
+    }
+    const { token } = resetPasswordParams.data;
+    return /*#__PURE__*/ _jsxs(MinimalTemplate, {
+        className: `${resetPasswordBaseClass}`,
+        children: [
+            /*#__PURE__*/ _jsx(FormHeader, {
+                heading: t("authentication:resetPassword")
+            }),
+            /*#__PURE__*/ _jsx(PasswordResetForm, {
+                token: token,
+                baseURL: pluginOptions.betterAuthOptions?.baseURL,
+                basePath: pluginOptions.betterAuthOptions?.basePath
+            }),
+            /*#__PURE__*/ _jsx(Link, {
+                href: formatAdminURL({
+                    adminRoute,
+                    path: adminRoutes.adminLogin
+                }),
+                prefetch: false,
+                children: t("authentication:backToLogin")
+            })
+        ]
+    });
+}
+export default ResetPassword;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/payload/views/two-factor-verify/client.d.ts

@@ -0,0 +1,9 @@
+interface TwoFactorVerifyFormProps {
+    redirect: string;
+    twoFactorDigits?: number;
+    baseURL?: string;
+    basePath?: string;
+}
+export declare function TwoFactorVerifyForm({ redirect, twoFactorDigits, baseURL, basePath }: TwoFactorVerifyFormProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/better-auth/plugin/payload/views/two-factor-verify/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/two-factor-verify/client.tsx"],"names":[],"mappings":"AAYA,UAAU,wBAAwB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,eAAmB,EACnB,OAAO,EACP,QAAQ,EACT,EAAE,wBAAwB,+BAiE1B"}

package/dist/better-auth/plugin/payload/views/two-factor-verify/client.js

@@ -0,0 +1,79 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { toast, useTranslation } from "@payloadcms/ui";
+import { twoFactorClient } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+import { useRouter } from "next/navigation";
+import { useMemo } from "react";
+import { z } from "zod";
+import { useAppForm } from "../../../../../shared/form";
+import { Form, FormInputWrap } from "../../../../../shared/form/ui";
+import { FormHeader } from "../../../../../shared/form/ui/header";
+export function TwoFactorVerifyForm({ redirect, twoFactorDigits = 6, baseURL, basePath }) {
+    const { t } = useTranslation();
+    const router = useRouter();
+    const authClient = useMemo(()=>createAuthClient({
+            baseURL,
+            basePath,
+            plugins: [
+                twoFactorClient()
+            ]
+        }), []);
+    const otpSchema = z.object({
+        code: z.string().length(twoFactorDigits, `Code must be ${twoFactorDigits} digits`).refine((val)=>/^\d{6}$/.test(val), "Code must be numeric")
+    });
+    const form = useAppForm({
+        defaultValues: {
+            code: ""
+        },
+        onSubmit: async ({ value })=>{
+            const { code } = value;
+            const { error } = await authClient.twoFactor.verifyTotp({
+                code
+            });
+            if (error) {
+                toast.error(error.message);
+                return;
+            }
+            router.push(redirect);
+            toast.success("Two-factor verified!");
+        },
+        validators: {
+            onSubmit: otpSchema
+        }
+    });
+    return /*#__PURE__*/ _jsxs(Form, {
+        onSubmit: (e)=>{
+            e.preventDefault();
+            void form.handleSubmit();
+        },
+        children: [
+            /*#__PURE__*/ _jsx(FormHeader, {
+                style: {
+                    textAlign: "center"
+                },
+                heading: "Verify Two-Factor"
+            }),
+            /*#__PURE__*/ _jsx(FormInputWrap, {
+                children: /*#__PURE__*/ _jsx(form.AppField, {
+                    name: "code",
+                    children: (field)=>/*#__PURE__*/ _jsx(field.TextField, {
+                            type: "text",
+                            className: "text otp",
+                            label: "6-digit Code",
+                            required: true,
+                            autoComplete: "one-time-password"
+                        })
+                })
+            }),
+            /*#__PURE__*/ _jsx(form.AppForm, {
+                children: /*#__PURE__*/ _jsx(form.Submit, {
+                    label: t("authentication:verify") || "Verify",
+                    loadingLabel: t("general:loading") || "Loading"
+                })
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/payload/views/two-factor-verify/index.d.ts

@@ -0,0 +1,10 @@
+import type { AdminViewServerProps } from "payload";
+import React from "react";
+import { PayloadAuthOptions } from "@/better-auth/plugin/types";
+interface TwoFactorVerifyProps extends AdminViewServerProps {
+    pluginOptions: PayloadAuthOptions;
+    verificationsSlug: string;
+}
+declare function TwoFactorVerify({ searchParams, initPageResult, pluginOptions, verificationsSlug }: TwoFactorVerifyProps): Promise<React.JSX.Element>;
+export default TwoFactorVerify;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/views/two-factor-verify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/views/two-factor-verify/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAKhE,UAAU,oBAAqB,SAAQ,oBAAoB;IACzD,aAAa,EAAE,kBAAkB,CAAC;IAClC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,iBAAe,eAAe,CAAC,EAC7B,YAAY,EACZ,cAAc,EACd,aAAa,EACb,iBAAiB,EAClB,EAAE,oBAAoB,8BAyDtB;AAED,eAAe,eAAe,CAAC"}