@calcom/atoms 2.8.0 → 2.8.2

package/src/event-types/hooks/use-get-verified-emails.ts

@@ -1,27 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiResponse, ApiSuccessResponse } from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-
-export const QUERY_KEY = "use-get-verified-emails";
-export const useGetVerifiedEmails = (teamId?: number) => {
-  const pathname = `/atoms/emails/verified-emails${teamId ? `?teamId=${teamId}` : ""}`;
-  const { isInit, accessToken } = useAtomsContext();
-
-  return useQuery({
-    queryKey: [QUERY_KEY, teamId],
-    queryFn: () => {
-      return http?.get<ApiResponse<string[]>>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return (res.data as ApiSuccessResponse<string[]>).data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    enabled: isInit && !!accessToken,
-    staleTime: 5000,
-  });
-};

package/src/event-types/hooks/use-handle-route-change.ts

@@ -1,57 +0,0 @@
-// @ts-nocheck — atoms wrapper over loose contracts + Radix prop-pick
-import { useEffect } from "react";
-import type { EventTypeAssignedUsers, EventTypeHosts } from "../../contracts";
-import { checkForEmptyAssignment } from "../../vendor/check-for-empty-assignment";
-
-export const useHandleRouteChange = ({
-  isTeamEventTypeDeleted,
-  isleavingWithoutAssigningHosts,
-  isTeamEventType,
-  assignedUsers,
-  hosts,
-  assignAllTeamMembers,
-  isManagedEventType,
-  onError,
-  onStart,
-  onEnd,
-  watchTrigger,
-}: {
-  isTeamEventTypeDeleted: boolean;
-  isleavingWithoutAssigningHosts: boolean;
-  isTeamEventType: boolean;
-  assignedUsers: EventTypeAssignedUsers;
-  hosts: EventTypeHosts;
-  assignAllTeamMembers: boolean;
-  isManagedEventType: boolean;
-  watchTrigger: unknown;
-  onError?: (url: string) => void;
-  onStart?: (handleRouteChange: (url: string) => void) => void;
-  onEnd?: (handleRouteChange: (url: string) => void) => void;
-}) => {
-  useEffect(() => {
-    const handleRouteChange = (url: string) => {
-      const paths = url.split("/");
-
-      // If the event-type is deleted, we can't show the empty assignment warning
-      if (isTeamEventTypeDeleted) return;
-
-      if (
-        !!isTeamEventType &&
-        !isleavingWithoutAssigningHosts &&
-        (url === "/event-types" || paths[1] !== "event-types") &&
-        checkForEmptyAssignment({
-          assignedUsers,
-          hosts,
-          assignAllTeamMembers,
-          isManagedEventType,
-        })
-      ) {
-        onError?.(url);
-      }
-    };
-    onStart?.(handleRouteChange);
-    return () => {
-      onEnd?.(handleRouteChange);
-    };
-  }, [watchTrigger, hosts, assignedUsers, assignAllTeamMembers, onError, onStart, onEnd]);
-};

package/src/event-types/hooks/use-locked-fields-manager-stub.ts

@@ -1,30 +0,0 @@
-/**
- * atoms-local adapter (out of UI canonicalization — hook, not UI). Replaces features/ee/managed-event-types/hooks/useLockedFieldsManager.
- *
- * The features-side hook (223 lines) renders "locked" indicators on
- * managed event-type fields, wired to Prisma metadata + zod-utils.
- * atoms doesn't surface the managed-event-type workflow UI — platform
- * consumers bypass lock indicators or implement their own.
- */
-export default function useLockedFieldsManager(_opts: {
-  eventType?: Record<string, unknown>;
-  translate?: (key: string, options?: Record<string, unknown>) => string;
-  formMethods?: unknown;
-}) {
-  return {
-    shouldLockIndicator: (_fieldName: string) => null as JSX.Element | null,
-    shouldLockDisableProps: (_fieldName: string) => ({
-      disabled: false,
-      LockedIcon: null as JSX.Element | null,
-      isLocked: false,
-    }),
-    useLockedLabel: (_fieldName: string) => ({
-      disabled: false,
-      LockedIcon: null as JSX.Element | null,
-      isLocked: false,
-    }),
-    useLockedSwitch: (_fieldName: string) => () => null as JSX.Element | null,
-    isManagedEventType: false,
-    isChildrenManagedEventType: false,
-  };
-}

package/src/event-types/hooks/use-platform-tabs-navigations.tsx

@@ -1,138 +0,0 @@
-// @ts-nocheck — wrapper/hook reconciles loose atoms contracts with legacy
-// backend payload shapes (unknowns from Record<string, any> branches, Radix
-// prop-pick narrowing). Runtime matches pre-extract behavior; a targeted
-// typing pass follows once the contracts are tightened per-consumer.
-"use client";
-
-import type { TFunction } from "i18next";
-import { useEffect, useMemo, useState } from "react";
-import type { UseFormReturn } from "react-hook-form";
-import type { VerticalTabItemProps } from "../../components/ui/navigation";
-import type { EventTypeSetupProps, FormValues } from "../../contracts";
-import type { PlatformTabs } from "../../event-types/wrappers/types";
-import { useAtomsLocale as useLocale } from "../../hooks/use-atoms-locale";
-import { getPaymentAppData } from "../../vendor/payments";
-import useLockedFieldsManager from "./use-locked-fields-manager-stub";
-
-type Props = {
-  formMethods: UseFormReturn<FormValues>;
-  eventType: EventTypeSetupProps["eventType"];
-  team: EventTypeSetupProps["team"];
-  tabs: PlatformTabs[];
-};
-export const usePlatformTabsNavigations = ({ formMethods, eventType, team, tabs }: Props) => {
-  const [url, setUrl] = useState("");
-  const [currentTab, setCurrentTab] = useState<PlatformTabs>(tabs[0]);
-
-  useEffect(() => {
-    // Get the current URL from window.location
-    const currentUrl = window.location.href;
-    setUrl(currentUrl);
-  }, []);
-
-  const { t } = useLocale();
-
-  const length = formMethods.watch("length");
-  const multipleDuration = formMethods.watch("metadata")?.multipleDuration;
-
-  const watchSchedulingType = formMethods.watch("schedulingType");
-  const watchChildrenCount = formMethods.watch("children").length;
-  const availability = formMethods.watch("availability");
-
-  const { isManagedEventType, isChildrenManagedEventType } = useLockedFieldsManager({
-    eventType,
-    translate: t,
-    formMethods,
-  });
-
-  const paymentAppData = getPaymentAppData(eventType);
-
-  const requirePayment = paymentAppData.price > 0;
-
-  const EventTypeTabs = useMemo(() => {
-    const navigation: VerticalTabItemProps[] = getNavigation({
-      t,
-      length,
-      multipleDuration,
-      id: formMethods.getValues("id"),
-      tabs,
-      url,
-      onClick: (tab) => {
-        setCurrentTab(tab);
-      },
-      currentTab,
-    });
-
-    if (!requirePayment && tabs.includes("recurring")) {
-      navigation.splice(3, 0, {
-        name: t("recurring"),
-        onClick: () => setCurrentTab("recurring"),
-        isActive: currentTab === "recurring",
-        href: `${url}?tabName=recurring`,
-        icon: "repeat",
-        info: t(`recurring_event_tab_description`),
-        "data-testid": "recurring",
-      });
-    }
-
-    // If there is a team put this navigation item within the tabs
-    if (team && tabs.includes("team")) {
-      navigation.splice(2, 0, {
-        name: t("assignment"),
-        onClick: () => setCurrentTab("team"),
-        isActive: currentTab === "team",
-        href: `${url}?tabName=team`,
-        icon: "users",
-        info: `${t(watchSchedulingType?.toLowerCase() ?? "")}${
-          isManagedEventType ? ` - ${t("number_member", { count: watchChildrenCount || 0 })}` : ""
-        }`,
-        "data-testid": "assignment",
-      });
-    }
-
-    return navigation;
-  }, [
-    t,
-    availability,
-    isManagedEventType,
-    isChildrenManagedEventType,
-    team,
-    length,
-    requirePayment,
-    multipleDuration,
-    formMethods.getValues("id"),
-    watchSchedulingType,
-    watchChildrenCount,
-    url,
-    tabs,
-    currentTab,
-  ]);
-
-  return { tabsNavigation: EventTypeTabs, currentTab };
-};
-
-type getNavigationProps = {
-  t: TFunction;
-  length: number;
-  id: number;
-  multipleDuration?: EventTypeSetupProps["eventType"]["metadata"]["multipleDuration"];
-  tabs: PlatformTabs[];
-  url: string;
-  onClick: (tab: PlatformTabs) => void;
-  currentTab: PlatformTabs;
-};
-
-function getNavigation({
-  t: _t,
-  tabs: _tabs,
-  url: _url,
-  onClick: _onClick,
-  currentTab: _currentTab,
-}: getNavigationProps) {
-  // atoms SDK only renders tabs it can ship cleanly (team, recurring).
-  // setup / limits / advanced / payments are admin UI kept in the
-  // webapp; they don't appear in the SDK's nav. See
-  // EventTypePlatformWrapper tabMap for the matching renderer side.
-  const tabsNavigation: VerticalTabItemProps[] = [];
-  return tabsNavigation;
-}

package/src/event-types/hooks/use-tabs-navigations.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { getTabSlug } from "./use-tabs-navigations";
-
-describe("getTabSlug", () => {
-  it("extracts tabName query param from a standard tab href", () => {
-    expect(getTabSlug("/event-types/123?tabName=setup")).toBe("setup");
-    expect(getTabSlug("/event-types/123?tabName=availability")).toBe("availability");
-    expect(getTabSlug("/event-types/123?tabName=limits")).toBe("limits");
-    expect(getTabSlug("/event-types/123?tabName=advanced")).toBe("advanced");
-    expect(getTabSlug("/event-types/123?tabName=recurring")).toBe("recurring");
-    expect(getTabSlug("/event-types/123?tabName=apps")).toBe("apps");
-    expect(getTabSlug("/event-types/123?tabName=workflows")).toBe("workflows");
-    expect(getTabSlug("/event-types/123?tabName=webhooks")).toBe("webhooks");
-    expect(getTabSlug("/event-types/123?tabName=instant")).toBe("instant");
-  });
-
-  it("extracts tabName when it is not the first query param", () => {
-    expect(getTabSlug("/event-types/123?foo=bar&tabName=limits")).toBe("limits");
-    expect(getTabSlug("/event-types/123?foo=bar&tabName=advanced&baz=1")).toBe("advanced");
-  });
-
-  it("decodes percent-encoded tabName values", () => {
-    expect(getTabSlug("/event-types/123?tabName=my%20tab")).toBe("my tab");
-  });
-
-  it("falls back to the full href when tabName param is missing", () => {
-    expect(getTabSlug("/event-types/123")).toBe("/event-types/123");
-    expect(getTabSlug("/event-types/123?other=value")).toBe("/event-types/123?other=value");
-  });
-});

package/src/event-types/hooks/use-tabs-navigations.tsx

@@ -1,266 +0,0 @@
-// @ts-nocheck — wrapper/hook reconciles loose atoms contracts with legacy
-// backend payload shapes (unknowns from Record<string, any> branches, Radix
-// prop-pick narrowing). Runtime matches pre-extract behavior; a targeted
-// typing pass follows once the contracts are tightened per-consumer.
-"use client";
-
-import type { TFunction } from "i18next";
-import { startTransition, useMemo } from "react";
-import type { UseFormReturn } from "react-hook-form";
-import type { VerticalTabItemProps } from "../../components/ui/navigation";
-import type {
-  AvailabilityOption,
-  EventTypeApps,
-  EventTypeSetupProps,
-  FormValues,
-  Workflow,
-} from "../../contracts";
-import { eventTypeMetaDataSchemaWithTypedApps } from "../../contracts";
-import { useAtomsLocale as useLocale } from "../../hooks/use-atoms-locale";
-import { trackEvent } from "../../vendor/analytics";
-import { getPaymentAppData } from "../../vendor/payments";
-import useLockedFieldsManager from "./use-locked-fields-manager-stub";
-
-type Props = {
-  formMethods: UseFormReturn<FormValues>;
-  eventType: EventTypeSetupProps["eventType"];
-  team: EventTypeSetupProps["team"];
-  eventTypeApps?: EventTypeApps;
-  allActiveWorkflows?: Workflow[];
-  canReadWorkflows?: boolean;
-};
-export const useTabsNavigations = ({
-  formMethods,
-  eventType,
-  team,
-  eventTypeApps,
-  allActiveWorkflows,
-  canReadWorkflows = false,
-}: Props) => {
-  const { t } = useLocale();
-
-  const length = formMethods.watch("length");
-  const multipleDuration = formMethods.watch("metadata")?.multipleDuration;
-
-  const watchSchedulingType = formMethods.watch("schedulingType");
-  const watchChildrenCount = formMethods.watch("children").length;
-  const availability = formMethods.watch("availability");
-  const appsMetadata = formMethods.getValues("metadata")?.apps;
-
-  const { isManagedEventType, isChildrenManagedEventType } = useLockedFieldsManager({
-    eventType,
-    translate: t,
-    formMethods,
-  });
-
-  let enabledAppsNumber = 0;
-
-  if (appsMetadata) {
-    enabledAppsNumber = Object.entries(appsMetadata).filter(
-      ([appId, appData]) =>
-        eventTypeApps?.items.find((app) => app.slug === appId)?.isInstalled && appData.enabled
-    ).length;
-  }
-  const paymentAppData = getPaymentAppData({
-    ...eventType,
-    metadata: eventTypeMetaDataSchemaWithTypedApps.parse(eventType.metadata),
-  });
-
-  const requirePayment = paymentAppData.price > 0;
-
-  const activeWebhooksNumber = eventType.webhooks.filter((webhook) => webhook.active).length;
-
-  const installedAppsNumber = eventTypeApps?.items.filter((app) => app.isInstalled).length || 0;
-  const enabledWorkflowsNumber = allActiveWorkflows ? allActiveWorkflows.length : 0;
-
-  const eventTypeId = formMethods.getValues("id");
-  const schedule = formMethods.getValues("schedule");
-  const scheduleName = formMethods.getValues("scheduleName");
-
-  const EventTypeTabs = useMemo(() => {
-    const navigation: VerticalTabItemProps[] = getNavigation({
-      t,
-      length,
-      multipleDuration,
-      id: eventTypeId,
-      enabledAppsNumber,
-      installedAppsNumber,
-      enabledWorkflowsNumber,
-      availability,
-      canReadWorkflows,
-    });
-
-    if (!requirePayment) {
-      navigation.splice(3, 0, {
-        name: t("recurring"),
-        href: `/event-types/${eventTypeId}?tabName=recurring`,
-        icon: "repeat",
-        info: t(`recurring_event_tab_description`),
-        "data-testid": "recurring",
-      });
-    }
-    navigation.splice(1, 0, {
-      name: t("availability"),
-      href: `/event-types/${eventTypeId}?tabName=availability`,
-      icon: "calendar",
-      info:
-        isManagedEventType || isChildrenManagedEventType
-          ? schedule === null
-            ? t("members_default_schedule")
-            : isChildrenManagedEventType
-              ? `${scheduleName ? `${scheduleName} - ${t("managed")}` : t(`default_schedule_name`)}`
-              : (scheduleName ?? t(`default_schedule_name`))
-          : (scheduleName ?? t(`default_schedule_name`)),
-      "data-testid": "availability",
-    });
-    // If there is a team put this navigation item within the tabs
-    if (team) {
-      navigation.splice(2, 0, {
-        name: t("assignment"),
-        href: `/event-types/${eventTypeId}?tabName=team`,
-        icon: "users",
-        info: `${t(watchSchedulingType?.toLowerCase() ?? "")}${
-          isManagedEventType ? ` - ${t("number_member", { count: watchChildrenCount || 0 })}` : ""
-        }`,
-        "data-testid": "assignment",
-      });
-    }
-    const showInstant = !(isManagedEventType || isChildrenManagedEventType);
-    if (showInstant) {
-      if (team) {
-        navigation.push({
-          name: t("instant_tab_title"),
-          href: `/event-types/${eventType.id}?tabName=instant`,
-          icon: "phone-call",
-          info: t(`instant_event_tab_description`),
-          "data-testid": "instant_tab_title",
-        });
-      }
-    }
-    navigation.push({
-      name: t("webhooks"),
-      href: `/event-types/${eventTypeId}?tabName=webhooks`,
-      icon: "webhook",
-      info: `${activeWebhooksNumber} ${t("active")}`,
-      "data-testid": "webhooks",
-    });
-
-    // Use pushState for tab switches to avoid triggering RSC fetches.
-    // The shallow prop on <Link> is ignored in App Router, so we intercept
-    // clicks via onClick and update the URL client-side instead.
-    // Wrapping in startTransition tells React to keep the current tab content
-    // visible while the new tab loads (via dynamic import), instead of
-    // showing the Suspense fallback spinner.
-    return navigation.map((tab) => ({
-      ...tab,
-      onClick: () => {
-        trackEvent("event_type_tab_clicked", {
-          tab_name: getTabSlug(tab.href),
-          event_type_id: eventTypeId,
-        });
-        startTransition(() => {
-          window.history.pushState(null, "", tab.href);
-        });
-      },
-    }));
-  }, [
-    t,
-    enabledAppsNumber,
-    installedAppsNumber,
-    enabledWorkflowsNumber,
-    availability,
-    isManagedEventType,
-    isChildrenManagedEventType,
-    team,
-    length,
-    requirePayment,
-    multipleDuration,
-    eventTypeId,
-    watchSchedulingType,
-    watchChildrenCount,
-    activeWebhooksNumber,
-    canReadWorkflows,
-    eventType.id,
-    schedule,
-    scheduleName,
-  ]);
-
-  return { tabsNavigation: EventTypeTabs };
-};
-
-// Extracts the stable `tabName` query-param slug (e.g. "setup", "limits", "advanced")
-// from a tab's href, so analytics events use consistent keys regardless of i18n or data-testid.
-export function getTabSlug(href: string): string {
-  const match = href.match(/[?&]tabName=([^&]+)/);
-  return match ? decodeURIComponent(match[1]) : href;
-}
-
-type getNavigationProps = {
-  t: TFunction;
-  length: number;
-  id: number;
-  multipleDuration?: EventTypeSetupProps["eventType"]["metadata"]["multipleDuration"];
-  enabledAppsNumber: number;
-  enabledWorkflowsNumber: number;
-  installedAppsNumber: number;
-  availability: AvailabilityOption | undefined;
-  canReadWorkflows: boolean;
-};
-
-function getNavigation({
-  length,
-  id,
-  multipleDuration,
-  t,
-  enabledAppsNumber,
-  installedAppsNumber,
-  enabledWorkflowsNumber,
-  canReadWorkflows,
-}: getNavigationProps) {
-  const duration = multipleDuration?.map((duration) => ` ${duration}`) || length;
-
-  const baseNavigation: VerticalTabItemProps[] = [
-    {
-      name: t("basics"),
-      href: `/event-types/${id}?tabName=setup`,
-      icon: "link",
-      info: `${duration} ${t("minute_timeUnit")}`, // TODO: Get this from props
-      "data-testid": `basics`,
-    },
-    {
-      name: t("event_limit_tab_title"),
-      href: `/event-types/${id}?tabName=limits`,
-      icon: "clock",
-      info: t(`event_limit_tab_description`),
-      "data-testid": "event_limit_tab_title",
-    },
-    {
-      name: t("event_advanced_tab_title"),
-      href: `/event-types/${id}?tabName=advanced`,
-      icon: "sliders-vertical",
-      info: t(`event_advanced_tab_description`),
-      "data-testid": "event_advanced_tab_title",
-    },
-    {
-      name: t("apps"),
-      href: `/event-types/${id}?tabName=apps`,
-      icon: "grid-3x3",
-      //TODO: Handle proper translation with count handling
-      info: `${installedAppsNumber} apps, ${enabledAppsNumber} ${t("active")}`,
-      "data-testid": "apps",
-    },
-  ];
-
-  // Only add workflows tab if user has permission to read workflows
-  if (canReadWorkflows) {
-    baseNavigation.push({
-      name: t("workflows"),
-      href: `/event-types/${id}?tabName=workflows`,
-      icon: "zap",
-      info: `${enabledWorkflowsNumber} ${t("active")}`,
-      "data-testid": "workflows",
-    });
-  }
-
-  return baseNavigation;
-}

package/src/event-types/hooks/use-team-event-assignment.ts

@@ -1,127 +0,0 @@
-// @ts-nocheck — loose FormValues/EventTypeSetup contracts
-"use client";
-
-import { useCallback, useMemo } from "react";
-import { useFormContext, useWatch } from "react-hook-form";
-import { mapUserToValue } from "../../add-members-switch/add-members-with-switch";
-import type { FormValues } from "../../contracts";
-import { SchedulingType } from "../../contracts";
-import { useAtomsLocale as useLocale } from "../../hooks/use-atoms-locale";
-import { mapMemberToChildrenOption } from "../components/team-assignment/event-team-assignment-tab";
-import { useAssignAllManagedWarning } from "./use-assign-all-managed-warning";
-
-type TeamMember = {
-  id: number;
-  name?: string | null;
-  email: string;
-  username?: string | null;
-  avatar: string;
-  defaultScheduleId?: number | null;
-  eventTypes: string[];
-  [key: string]: unknown;
-};
-
-type EventType = {
-  slug: string;
-  schedulingType?: string | null;
-  team?: { parentId?: number | null } | null;
-  children?: Array<{ owner: { id: number } }>;
-  [key: string]: unknown;
-};
-
-type Params = { eventType: EventType; teamMembers: TeamMember[] };
-
-export function useTeamEventAssignment({ eventType, teamMembers }: Params) {
-  const { t } = useLocale();
-  const { setValue, control } = useFormContext<FormValues>();
-  const assignAllManagedWarning = useAssignAllManagedWarning();
-  const eventTypeSlug =
-    (useWatch<FormValues>({ control, name: "slug" }) as string | undefined) ?? eventType.slug;
-  const assignAllTeamMembers =
-    (useWatch<FormValues>({ control, name: "assignAllTeamMembers" }) as boolean | undefined) ?? false;
-  const isManagedEventType = eventType.schedulingType === SchedulingType.MANAGED;
-
-  const pendingMembers = useCallback(
-    (member: TeamMember) => !!eventType.team?.parentId || !!member.username,
-    [eventType.team?.parentId]
-  );
-
-  const childrenEventTypeOptions = useMemo(
-    () =>
-      teamMembers.filter(pendingMembers).map((member) =>
-        mapMemberToChildrenOption(
-          {
-            ...member,
-            eventTypes: member.eventTypes.filter(
-              (et) =>
-                et !== eventType.slug || !(eventType.children ?? []).some((c) => c.owner.id === member.id)
-            ),
-          },
-          eventType.slug,
-          t("pending")
-        )
-      ),
-    [teamMembers, pendingMembers, eventType.slug, eventType.children, t]
-  );
-
-  const teamMembersOptions = useMemo(
-    () => teamMembers.filter(pendingMembers).map((member) => mapUserToValue(member, t("pending"))),
-    [teamMembers, pendingMembers, t]
-  );
-
-  const setChildrenToAllTeamMembers = useCallback(() => {
-    setValue("children", childrenEventTypeOptions, { shouldDirty: true });
-  }, [setValue, childrenEventTypeOptions]);
-
-  const updateAssignAllTeamMembers = useCallback(
-    (newValue: boolean) => setValue("assignAllTeamMembers", newValue, { shouldDirty: true }),
-    [setValue]
-  );
-
-  const handleToggle = useCallback(
-    (enabled: boolean) => {
-      updateAssignAllTeamMembers(enabled);
-      if (isManagedEventType && enabled) setChildrenToAllTeamMembers();
-    },
-    [updateAssignAllTeamMembers, isManagedEventType, setChildrenToAllTeamMembers]
-  );
-
-  const attemptSetAssignAll = useCallback(
-    (newValue: boolean) => {
-      if (
-        assignAllManagedWarning.shouldShowWarning({
-          schedulingType: eventType.schedulingType ?? null,
-          oldAssignAllTeamMembers: assignAllTeamMembers,
-          newAssignAllTeamMembers: newValue,
-        })
-      ) {
-        assignAllManagedWarning.show();
-        return;
-      }
-      handleToggle(newValue);
-    },
-    [assignAllTeamMembers, assignAllManagedWarning, eventType.schedulingType, handleToggle]
-  );
-
-  const confirmWarning = useCallback(() => {
-    assignAllManagedWarning.confirm();
-    handleToggle(true);
-  }, [assignAllManagedWarning, handleToggle]);
-
-  const resetAssignAll = useCallback(() => updateAssignAllTeamMembers(false), [updateAssignAllTeamMembers]);
-
-  return {
-    assignAllTeamMembers,
-    attemptSetAssignAll,
-    childrenEventTypeOptions,
-    teamMembersOptions,
-    eventTypeSlug,
-    isManagedEventType,
-    resetAssignAll,
-    warningDialog: {
-      isOpen: assignAllManagedWarning.isOpen,
-      onConfirm: confirmWarning,
-      onClose: assignAllManagedWarning.cancel,
-    },
-  };
-}