hunk.code_window:     });
     }, [router.events]);
     embedStore.setTheme = setTheme;
     return theme === "auto" ? null : theme;
   };
   export const useEmbedUiConfig = () => {
     const [uiConfig, setUiConfig] = useState(embedStore.uiConfig || {});
  
hunk.labels: keep keep keep replace keep keep keep keep
hunk.after_edit:   return theme;
  
hunk.file_path: packages/embeds/embed-core/src/embed-iframe.ts
hunk.type: replace
file: import type { GetServerSidePropsContext } from "next";
  import { signIn } from "next-auth/react";
  import { useRouter } from "next/router";
  import type { CSSProperties } from "react";
  import type { SubmitHandler } from "react-hook-form";
  import { FormProvider, useForm } from "react-hook-form";
  import { z } from "zod";
  
  import LicenseRequired from "@calcom/features/ee/common/components/LicenseRequired";
  import { checkPremiumUsername } from "@calcom/features/ee/common/lib/checkPremiumUsername";
  import { isSAMLLoginEnabled } from "@calcom/features/ee/sso/lib/saml";
  import { IS_SELF_HOSTED, WEBAPP_URL } from "@calcom/lib/constants";
  import { useLocale } from "@calcom/lib/hooks/useLocale";
  import { collectPageParameters, telemetryEventTypes, useTelemetry } from "@calcom/lib/telemetry";
  import prisma from "@calcom/prisma";
  import type { inferSSRProps } from "@calcom/types/inferSSRProps";
  import { Alert, Button, EmailField, HeadSeo, PasswordField, TextField } from "@calcom/ui";
  
  import PageWrapper from "@components/PageWrapper";
  
  import { IS_GOOGLE_LOGIN_ENABLED } from "../server/lib/constants";
  import { ssrInit } from "../server/lib/ssr";
  
  type FormValues = {
    username: string;
    email: string;
    password: string;
    apiError: string;
  };
  
  export default function Signup({ prepopulateFormValues, token }: inferSSRProps<typeof getServerSideProps>) {
    const { t } = useLocale();
    const router = useRouter();
    const telemetry = useTelemetry();
  
    const methods = useForm<FormValues>({
      defaultValues: prepopulateFormValues,
    });
    const {
      register,
      formState: { errors, isSubmitting },
    } = methods;
  
    const handleErrors = async (resp: Response) => {
      if (!resp.ok) {
        const err = await resp.json();
        throw new Error(err.message);
      }
    };
  
    const signUp: SubmitHandler<FormValues> = async (data) => {
      await fetch("/api/auth/signup", {
        body: JSON.stringify({
          ...data,
        }),
        headers: {
          "Content-Type": "application/json",
        },
        method: "POST",
      })
        .then(handleErrors)
        .then(async () => {
          telemetry.event(telemetryEventTypes.signup, collectPageParameters());
          await signIn<"credentials">("credentials", {
            ...data,
            callbackUrl: router.query.callbackUrl
              ? `${WEBAPP_URL}/${router.query.callbackUrl}`
              : `${WEBAPP_URL}/getting-started`,
          });
        })
        .catch((err) => {
          methods.setError("apiError", { message: err.message });
        });
    };
  
    return (
      <LicenseRequired>
        <div
          className="bg-muted flex min-h-screen flex-col justify-center "
          style={
            {
              "--cal-brand": "#111827",
              "--cal-brand-emphasis": "#101010",
              "--cal-brand-text": "white",
              "--cal-brand-subtle": "#9CA3AF",
            } as CSSProperties
          }
          aria-labelledby="modal-title"
          role="dialog"
          aria-modal="true">
          <HeadSeo title={t("sign_up")} description={t("sign_up")} />
          <div className="sm:mx-auto sm:w-full sm:max-w-md">
            <h2 className="font-cal text-emphasis text-center text-3xl font-extrabold">
              {t("create_your_account")}
            </h2>
          </div>
          <div className="mt-8 sm:mx-auto sm:w-full sm:max-w-md">
            <div className="bg-default mx-2 p-6 shadow sm:rounded-lg lg:p-8">
              <FormProvider {...methods}>
                <form
                  onSubmit={(event) => {
                    event.preventDefault();
                    event.stopPropagation();
  
                    if (methods.formState?.errors?.apiError) {
                      methods.clearErrors("apiError");
                    }
                    methods.handleSubmit(signUp)(event);
                  }}
                  className="bg-default space-y-6">
                  {errors.apiError && <Alert severity="error" message={errors.apiError?.message} />}
                  <div className="space-y-4">
                    <TextField
                      addOnLeading={`${process.env.NEXT_PUBLIC_WEBSITE_URL}/`}
                      {...register("username")}
                      required
                    />
                    <EmailField
                      {...register("email")}
                      disabled={prepopulateFormValues?.email}
                      className="disabled:bg-emphasis disabled:hover:cursor-not-allowed"
                    />
                    <PasswordField
                      labelProps={{
                        className: "block text-sm font-medium text-default",
                      }}
                      {...register("password")}
                      hintErrors={["caplow", "min", "num"]}
                      className="border-default mt-1 block w-full rounded-md border px-3 py-2 shadow-sm focus:border-black focus:outline-none focus:ring-black sm:text-sm"
                    />
                  </div>
                  <div className="flex space-x-2 rtl:space-x-reverse">
                    <Button type="submit" loading={isSubmitting} className="w-full justify-center">
                      {t("create_account")}
                    </Button>
                    {!token && (
                      <Button
                        color="secondary"
                        className="w-full justify-center"
                        onClick={() =>
                          signIn("Cal.com", {
                            callbackUrl: router.query.callbackUrl
                              ? `${WEBAPP_URL}/${router.query.callbackUrl}`
                              : `${WEBAPP_URL}/getting-started`,
                          })
                        }>
                        {t("login_instead")}
                      </Button>
                    )}
                  </div>
                </form>
              </FormProvider>
            </div>
          </div>
        </div>
      </LicenseRequired>
    );
  }
  
  export const getServerSideProps = async (ctx: GetServerSidePropsContext) => {
    const ssr = await ssrInit(ctx);
    const token = z.string().optional().parse(ctx.query.token);
  
    const props = {
      isGoogleLoginEnabled: IS_GOOGLE_LOGIN_ENABLED,
      isSAMLLoginEnabled,
      trpcState: ssr.dehydrate(),
      prepopulateFormValues: undefined,
    };
  
    if (process.env.NEXT_PUBLIC_DISABLE_SIGNUP === "true") {
      return {
        notFound: true,
      };
    }
  
    // no token given, treat as a normal signup without verification token
    if (!token) {
      return {
        props: JSON.parse(JSON.stringify(props)),
      };
    }
  
    const verificationToken = await prisma.verificationToken.findUnique({
      where: {
        token,
      },
    });
  
    if (!verificationToken || verificationToken.expires < new Date()) {
      return {
        notFound: true,
      };
    }
  
    const existingUser = await prisma.user.findFirst({
      where: {
        AND: [
          {
            email: verificationToken?.identifier,
          },
          {
            emailVerified: {
              not: null,
            },
          },
        ],
      },
    });
  
    if (existingUser) {
      return {
        redirect: {
          permanent: false,
          destination: "/auth/login?callbackUrl=" + `${WEBAPP_URL}/${ctx.query.callbackUrl}`,
        },
      };
    }
  
    const guessUsernameFromEmail = (email: string) => {
      const [username] = email.split("@");
      return username;
    };
  
    let username = guessUsernameFromEmail(verificationToken.identifier);
  
    if (!IS_SELF_HOSTED) {
      // Im not sure we actually hit this because of next redirects signup to website repo - but just in case this is pretty cool :)
      const { available, suggestion } = await checkPremiumUsername(username);
  
      username = available ? username : suggestion || username;
    }
  
    return {
      props: {
        ...props,
        token,
        prepopulateFormValues: {
          email: verificationToken.identifier,
          username,
        },
      },
    };
  };
  
  Signup.isThemeSupported = false;
  Signup.PageWrapper = PageWrapper;
  