@calcom/atoms 2.7.2 → 2.8.1

package/src/event-types/components/team-assignment/hosts.tsx

@@ -1,125 +0,0 @@
-// @ts-nocheck — loose FormValues/Host/TeamMember contracts
-"use client";
-
-import { useEffect, useRef } from "react";
-import { Controller, useFormContext, useWatch } from "react-hook-form";
-import type { FormValues, Host, SchedulingType, TeamMember } from "../../../contracts";
-import { FixedHosts, type FixedHostsCustomClassNames } from "./fixed-hosts";
-import { RoundRobinHosts, type RoundRobinHostsCustomClassNames } from "./round-robin-hosts";
-
-export type HostsCustomClassNames = {
-  fixedHosts?: FixedHostsCustomClassNames;
-  roundRobinHosts?: RoundRobinHostsCustomClassNames;
-};
-
-export const Hosts = ({
-  orgId,
-  teamId,
-  teamMembers,
-  assignAllTeamMembers,
-  setAssignAllTeamMembers,
-  customClassNames,
-  isSegmentApplicable,
-  hideFixedHostsForCollective = false,
-  weightsEditorSlot,
-}: {
-  orgId: number | null;
-  teamId: number;
-  teamMembers: TeamMember[];
-  assignAllTeamMembers: boolean;
-  setAssignAllTeamMembers: (value: boolean) => void;
-  customClassNames?: HostsCustomClassNames;
-  isSegmentApplicable: boolean;
-  hideFixedHostsForCollective?: boolean;
-  weightsEditorSlot?: React.ReactNode;
-}) => {
-  const {
-    control,
-    setValue,
-    getValues,
-    formState: { submitCount },
-  } = useFormContext<FormValues>();
-  const schedulingType = useWatch({ control, name: "schedulingType" });
-  const initialValue = useRef<{
-    hosts: FormValues["hosts"];
-    schedulingType: SchedulingType | null;
-    submitCount: number;
-  } | null>(null);
-
-  useEffect(() => {
-    if (!initialValue.current || initialValue.current?.submitCount !== submitCount) {
-      initialValue.current = { hosts: getValues("hosts"), schedulingType, submitCount };
-      return;
-    }
-    setValue(
-      "hosts",
-      initialValue.current.schedulingType === schedulingType ? initialValue.current.hosts : [],
-      { shouldDirty: true }
-    );
-  }, [schedulingType, setValue, getValues, submitCount]);
-
-  const updatedHosts = (changedHosts: Host[]) => {
-    const existingHosts = getValues("hosts");
-    return changedHosts.map((newValue) => {
-      const existingHost = existingHosts.find((host: Host) => host.userId === newValue.userId);
-      return existingHost
-        ? { ...newValue, scheduleId: existingHost.scheduleId, groupId: existingHost.groupId }
-        : newValue;
-    });
-  };
-
-  return (
-    <Controller<FormValues>
-      name="hosts"
-      render={({ field: { onChange, value } }) => {
-        const schedulingTypeRender = {
-          COLLECTIVE: hideFixedHostsForCollective ? null : (
-            <FixedHosts
-              teamId={teamId}
-              teamMembers={teamMembers}
-              value={value}
-              onChange={(changeValue) => onChange([...updatedHosts(changeValue)])}
-              assignAllTeamMembers={assignAllTeamMembers}
-              setAssignAllTeamMembers={setAssignAllTeamMembers}
-              customClassNames={customClassNames?.fixedHosts}
-            />
-          ),
-          ROUND_ROBIN: (
-            <>
-              <FixedHosts
-                teamId={teamId}
-                teamMembers={teamMembers}
-                value={value}
-                onChange={(changeValue) =>
-                  onChange([...value.filter((host: Host) => !host.isFixed), ...updatedHosts(changeValue)])
-                }
-                assignAllTeamMembers={assignAllTeamMembers}
-                setAssignAllTeamMembers={setAssignAllTeamMembers}
-                isRoundRobinEvent={true}
-                customClassNames={customClassNames?.fixedHosts}
-              />
-              <RoundRobinHosts
-                orgId={orgId}
-                teamId={teamId}
-                teamMembers={teamMembers}
-                value={value}
-                onChange={(changeValue) =>
-                  onChange([...value.filter((host: Host) => host.isFixed), ...updatedHosts(changeValue)])
-                }
-                assignAllTeamMembers={assignAllTeamMembers}
-                setAssignAllTeamMembers={setAssignAllTeamMembers}
-                customClassNames={customClassNames?.roundRobinHosts}
-                isSegmentApplicable={isSegmentApplicable}
-                weightsEditorSlot={weightsEditorSlot}
-              />
-            </>
-          ),
-          MANAGED: null,
-        };
-        return schedulingType
-          ? (schedulingTypeRender as Record<string, React.ReactNode>)[schedulingType]
-          : null;
-      }}
-    />
-  );
-};

package/src/event-types/components/team-assignment/round-robin-hosts.tsx

@@ -1,266 +0,0 @@
-// @ts-nocheck — loose FormValues/Host/TeamMember + Radix prop-pick
-"use client";
-
-import { useCallback } from "react";
-import { Controller, useFormContext, useWatch } from "react-hook-form";
-import { v4 as uuidv4 } from "uuid";
-import type { AddMembersWithSwitchCustomClassNames } from "../../../add-members-switch/add-members-with-switch";
-import AddMembersWithSwitch from "../../../add-members-switch/add-members-with-switch";
-import { Button } from "../../../components/ui/button";
-import { XIcon } from "../../../components/ui/icons";
-import { Label } from "../../../components/ui/label";
-import { SettingsToggle } from "../../../components/ui/settings-toggle";
-import type { FormValues, Host, TeamMember } from "../../../contracts";
-import { useAtomsLocale as useLocale } from "../../../hooks/use-atoms-locale";
-import { cn } from "../../../lib/utils";
-import { sortHosts } from "../../../vendor/host-group-utils";
-import { LearnMoreLink } from "../learn-more-link";
-import WeightDescription from "../weight-description";
-
-export type RoundRobinHostsCustomClassNames = {
-  container?: string;
-  label?: string;
-  description?: string;
-  enableWeights?: {
-    container?: string;
-    label?: string;
-    description?: string;
-  };
-  addMembers?: AddMembersWithSwitchCustomClassNames;
-};
-
-export const RoundRobinHosts = ({
-  orgId: _orgId,
-  teamMembers,
-  value,
-  onChange,
-  assignAllTeamMembers,
-  setAssignAllTeamMembers,
-  customClassNames,
-  teamId,
-  isSegmentApplicable,
-  /**
-   * atoms ships without the EditWeightsForAllTeamMembers sheet (346L,
-   * depends on @calcom/ui Sheet + RAQB AttributesQueryValue). Callers
-   * that need the full weights editor inject it here; atoms renders
-   * nothing in this slot by default.
-   */
-  weightsEditorSlot,
-}: {
-  orgId: number | null;
-  value: Host[];
-  onChange: (hosts: Host[]) => void;
-  teamMembers: TeamMember[];
-  assignAllTeamMembers: boolean;
-  setAssignAllTeamMembers: (value: boolean) => void;
-  customClassNames?: RoundRobinHostsCustomClassNames;
-  teamId: number;
-  isSegmentApplicable: boolean;
-  weightsEditorSlot?: React.ReactNode;
-}) => {
-  const { t } = useLocale();
-
-  const { setValue, getValues, control } = useFormContext<FormValues>();
-  const isRRWeightsEnabled = useWatch({ control, name: "isRRWeightsEnabled" });
-  const hostGroups = useWatch({ control, name: "hostGroups" }) ?? [];
-
-  const handleWeightsEnabledChange = (active: boolean, onFieldChange: (value: boolean) => void) => {
-    onFieldChange(active);
-    const allHosts = getValues("hosts");
-    const fixedHosts = allHosts.filter((host: Host) => host.isFixed);
-    const rrHosts = allHosts.filter((host: Host) => !host.isFixed);
-    const sortedRRHosts = rrHosts.sort((a: Host, b: Host) => sortHosts(a, b, active));
-    setValue("hosts", [...fixedHosts, ...sortedRRHosts]);
-  };
-
-  const handleAddGroup = useCallback(() => {
-    const allHosts = getValues("hosts");
-    const currentRRHosts = allHosts.filter((host: Host) => !host.isFixed);
-    const fixedHosts = allHosts.filter((host: Host) => host.isFixed);
-
-    if (hostGroups.length === 0 && currentRRHosts.length > 0) {
-      const firstGroup = { id: uuidv4(), name: "" };
-      const secondGroup = { id: uuidv4(), name: "" };
-      const updatedHostGroups = [firstGroup, secondGroup];
-      setValue("hostGroups", updatedHostGroups, { shouldDirty: true });
-      const updatedRRHosts = currentRRHosts.map((host: Host) =>
-        !host.groupId && !host.isFixed ? { ...host, groupId: firstGroup.id } : host
-      );
-      setValue("hosts", [...fixedHosts, ...updatedRRHosts], { shouldDirty: true });
-    } else {
-      const newGroup = { id: uuidv4(), name: "" };
-      const updatedHostGroups = [...hostGroups, newGroup];
-      setValue("hostGroups", updatedHostGroups, { shouldDirty: true });
-    }
-
-    if (assignAllTeamMembers) {
-      setValue("assignAllTeamMembers", false, { shouldDirty: true });
-      setAssignAllTeamMembers(false);
-    }
-  }, [hostGroups, getValues, setValue, assignAllTeamMembers, setAssignAllTeamMembers]);
-
-  const handleGroupNameChange = useCallback(
-    (groupId: string, newName: string) => {
-      const updatedHostGroups = hostGroups.map((g: { id: string; name: string }) =>
-        g.id === groupId ? { ...g, name: newName } : g
-      );
-      setValue("hostGroups", updatedHostGroups, { shouldDirty: true });
-    },
-    [hostGroups, setValue]
-  );
-
-  const handleRemoveGroup = useCallback(
-    (groupId: string) => {
-      const updatedHostGroups = hostGroups.filter((g: { id: string }) => g.id !== groupId);
-      setValue("hostGroups", updatedHostGroups, { shouldDirty: true });
-      const updatedHosts = value.filter((host) => host.groupId !== groupId);
-      onChange(updatedHosts);
-      setValue("hosts", updatedHosts, { shouldDirty: true });
-    },
-    [hostGroups, setValue, value, onChange]
-  );
-
-  const handleMembersActivation = useCallback(
-    (groupId: string | null) => {
-      const currentHosts = getValues("hosts");
-      setValue(
-        "hosts",
-        teamMembers.map((teamMember: TeamMember) => {
-          const host = currentHosts.find((h: Host) => h.userId === parseInt(teamMember.value, 10));
-          return {
-            isFixed: false,
-            userId: parseInt(teamMember.value, 10),
-            priority: host?.priority ?? 2,
-            weight: host?.weight ?? 100,
-            avatar: host?.avatar ?? teamMember.avatar,
-            name: host?.name ?? teamMember.label,
-            scheduleId: host?.scheduleId || teamMember.defaultScheduleId,
-            groupId: host?.groupId || groupId,
-          };
-        }),
-        { shouldDirty: true }
-      );
-    },
-    [getValues, setValue, teamMembers]
-  );
-
-  const AddMembersWithSwitchComponent = ({
-    groupId,
-    containerClassName,
-  }: {
-    groupId: string | null;
-    containerClassName?: string;
-  }) => (
-    <AddMembersWithSwitch
-      placeholder={t("add_a_member")}
-      teamId={teamId}
-      teamMembers={teamMembers}
-      value={value}
-      onChange={onChange}
-      assignAllTeamMembers={assignAllTeamMembers}
-      setAssignAllTeamMembers={setAssignAllTeamMembers}
-      isSegmentApplicable={isSegmentApplicable}
-      automaticAddAllEnabled={true}
-      isRRWeightsEnabled={isRRWeightsEnabled}
-      isFixed={false}
-      groupId={groupId}
-      onActive={() => handleMembersActivation(groupId)}
-      customClassNames={customClassNames?.addMembers}
-    />
-  );
-
-  const UnassignedHostsGroup = () => {
-    const unassignedHosts = value.filter((host) => !host.isFixed && !host.groupId);
-    if (unassignedHosts.length === 0) return null;
-    return (
-      <div className="border-subtle my-4 rounded-md border p-4 pb-0">
-        <div className="-mb-4 flex items-center justify-between">
-          <div className="flex items-center gap-1">
-            <span className="text-default text-sm font-medium">{`Group ${hostGroups.length + 1}`}</span>
-          </div>
-        </div>
-        <AddMembersWithSwitchComponent groupId={null} />
-      </div>
-    );
-  };
-
-  return (
-    <div className={cn("rounded-lg")}>
-      <div className={cn("border-subtle mt-5 rounded-t-md border p-6 pb-5", customClassNames?.container)}>
-        <div className="flex items-center justify-between">
-          <div>
-            <Label className={cn("mb-1 text-sm font-semibold", customClassNames?.label)}>
-              {t("round_robin_hosts")}
-            </Label>
-            <p
-              className={cn(
-                "text-subtle wrap-break-word max-w-full text-sm leading-tight",
-                customClassNames?.description
-              )}
-            >
-              <LearnMoreLink
-                t={t}
-                i18nKey={hostGroups.length > 0 ? "round_robin_groups_helper" : "round_robin_helper"}
-                href="https://cal.com/help/event-types/round-robin"
-              />
-            </p>
-          </div>
-          <Button color="secondary" size="sm" StartIcon="plus" onClick={handleAddGroup}>
-            {t("add_group")}
-          </Button>
-        </div>
-      </div>
-      <div className="border-subtle rounded-b-md border border-t-0 px-6 pt-4">
-        <Controller<FormValues>
-          name="isRRWeightsEnabled"
-          render={({ field: { value: enabled, onChange: onFieldChange } }) => (
-            <SettingsToggle
-              title={t("enable_weights")}
-              description={<WeightDescription t={t} />}
-              checked={enabled}
-              switchContainerClassName={customClassNames?.enableWeights?.container}
-              labelClassName={customClassNames?.enableWeights?.label}
-              descriptionClassName={customClassNames?.enableWeights?.description}
-              onCheckedChange={(active) => handleWeightsEnabledChange(active, onFieldChange)}
-            >
-              {weightsEditorSlot ?? null}
-            </SettingsToggle>
-          )}
-        />
-        {!hostGroups.length ? (
-          <AddMembersWithSwitchComponent groupId={hostGroups[0]?.id ?? null} />
-        ) : (
-          <>
-            <UnassignedHostsGroup />
-            {hostGroups.map((group: { id: string; name: string }, index: number) => {
-              const groupNumber = index + 1;
-              return (
-                <div key={group.id} className="border-subtle my-4 rounded-md border p-4 pb-0">
-                  <div className="-mb-4 flex items-center justify-between">
-                    <div className="flex items-center gap-2">
-                      <input
-                        type="text"
-                        value={group.name ?? ""}
-                        onChange={(e) => handleGroupNameChange(group.id, e.target.value)}
-                        className="border-none bg-transparent p-0 text-sm font-medium focus:outline-none focus:ring-0"
-                        placeholder={`Group ${groupNumber}`}
-                      />
-                    </div>
-                    <button
-                      type="button"
-                      onClick={() => handleRemoveGroup(group.id)}
-                      className="text-subtle hover:text-default rounded p-1"
-                    >
-                      <XIcon className="h-4 w-4" />
-                    </button>
-                  </div>
-                  <AddMembersWithSwitchComponent groupId={group.id} />
-                </div>
-              );
-            })}
-          </>
-        )}
-      </div>
-    </div>
-  );
-};

package/src/event-types/components/team-event-type-form.tsx

@@ -1,183 +0,0 @@
-// @ts-nocheck — loose event-type form contract + Radix prop-pick
-"use client";
-
-import type { ReactNode } from "react";
-import type { UseFormReturn } from "react-hook-form";
-import { Alert } from "../../components/ui/alert";
-import { Form } from "../../components/ui/form";
-import { RadioAreaGroup, RadioArea as RadioAreaItem } from "../../components/ui/radio-area-group";
-import { TextField } from "../../components/ui/text-field";
-import { Tooltip } from "../../components/ui/tooltip";
-import { SchedulingType } from "../../contracts";
-import { useAtomsLocale as useLocale } from "../../hooks/use-atoms-locale";
-import { cn } from "../../lib/utils";
-import { slugify } from "../../vendor/slugify";
-
-type CreateEventTypeFormValues = {
-  title?: string;
-  slug?: string;
-  schedulingType?: SchedulingType | string | null;
-  teamId?: number;
-  [key: string]: unknown;
-};
-
-type Props = {
-  permissions: {
-    canCreateEventType: boolean;
-  };
-  teamSlug?: string | null;
-  teamId: number;
-  isPending: boolean;
-  urlPrefix?: string;
-  form: UseFormReturn<CreateEventTypeFormValues>;
-  handleSubmit: (values: CreateEventTypeFormValues) => void;
-  isManagedEventType: boolean;
-  SubmitButton: (isPending: boolean) => ReactNode;
-  isPlatform?: boolean;
-};
-
-export const TeamEventTypeForm = ({
-  permissions,
-  teamSlug,
-  teamId,
-  form,
-  urlPrefix,
-  isPending,
-  handleSubmit,
-  isManagedEventType,
-  SubmitButton,
-  isPlatform = false,
-}: Props) => {
-  const { t } = useLocale();
-
-  const { register, setValue, formState } = form;
-  const { canCreateEventType } = permissions;
-
-  return (
-    <Form form={form} handleSubmit={handleSubmit}>
-      <div className="mb-6 mt-1 stack-y-6">
-        <TextField
-          type="hidden"
-          labelProps={{ style: { display: "none" } }}
-          {...register("teamId", { valueAsNumber: true })}
-          value={teamId}
-        />
-        <TextField
-          label={t("title")}
-          placeholder={t("quick_chat")}
-          data-testid="event-type-quick-chat"
-          {...register("title")}
-          onChange={(e) => {
-            form.setValue("title", e?.target.value);
-            if (formState.touchedFields["slug"] === undefined) {
-              form.setValue("slug", slugify(e?.target.value));
-            }
-          }}
-        />
-        {urlPrefix && urlPrefix.length >= 21 ? (
-          <div>
-            <TextField
-              label={isPlatform ? "Slug" : `${t("url")}: ${urlPrefix}`}
-              required
-              addOnLeading={
-                !isPlatform ? (
-                  <Tooltip content={!isManagedEventType ? `team/${teamSlug}` : t("username_placeholder")}>
-                    <span className="max-w-24 md:max-w-56">
-                      /{!isManagedEventType ? `team/${teamSlug}` : t("username_placeholder")}/
-                    </span>
-                  </Tooltip>
-                ) : undefined
-              }
-              {...register("slug")}
-              onChange={(e) => {
-                form.setValue("slug", slugify(e?.target.value), { shouldTouch: true });
-              }}
-            />
-            {isManagedEventType && !isPlatform && (
-              <p className="mt-2 text-sm text-gray-600">{t("managed_event_url_clarification")}</p>
-            )}
-          </div>
-        ) : (
-          <div>
-            <TextField
-              label={isPlatform ? "Slug" : t("url")}
-              required
-              addOnLeading={
-                !isPlatform ? (
-                  <Tooltip
-                    content={`${urlPrefix}/${
-                      !isManagedEventType ? `team/${teamSlug}` : t("username_placeholder")
-                    }/`}
-                  >
-                    <span className="max-w-24 md:max-w-56">
-                      {urlPrefix}/{!isManagedEventType ? `team/${teamSlug}` : t("username_placeholder")}/
-                    </span>
-                  </Tooltip>
-                ) : undefined
-              }
-              {...register("slug")}
-              onChange={(e) => {
-                form.setValue("slug", slugify(e?.target.value), { shouldTouch: true });
-              }}
-            />
-            {isManagedEventType && !isPlatform && (
-              <p className="mt-2 text-sm text-gray-600">{t("managed_event_url_clarification")}</p>
-            )}
-          </div>
-        )}
-        <div className="mb-4">
-          <label htmlFor="schedulingType" className="text-default block text-sm font-bold">
-            {t("assignment")}
-          </label>
-          {formState.errors.schedulingType && (
-            <Alert
-              className="mt-1"
-              severity="error"
-              message={formState.errors.schedulingType.message as string}
-            />
-          )}
-          <RadioAreaGroup
-            onValueChange={(val: SchedulingType) => {
-              setValue("schedulingType", val);
-            }}
-            className={cn("mt-1 flex gap-4", canCreateEventType && "flex-col")}
-          >
-            <RadioAreaItem
-              {...register("schedulingType")}
-              value={SchedulingType.COLLECTIVE}
-              className={cn("w-full text-sm", !canCreateEventType && "w-1/2")}
-              classNames={{ container: cn(canCreateEventType && "w-full") }}
-            >
-              <strong className="mb-1 block">{t("collective")}</strong>
-              <p>{t("collective_description")}</p>
-            </RadioAreaItem>
-            <RadioAreaItem
-              {...register("schedulingType")}
-              value={SchedulingType.ROUND_ROBIN}
-              className={cn("text-sm", !canCreateEventType && "w-1/2")}
-              classNames={{ container: cn(canCreateEventType && "w-full") }}
-            >
-              <strong className="mb-1 block">{t("round_robin")}</strong>
-              <p>{t("round_robin_description")}</p>
-            </RadioAreaItem>
-            {canCreateEventType && (
-              <RadioAreaItem
-                {...register("schedulingType")}
-                value={SchedulingType.MANAGED}
-                className={cn("text-sm", !canCreateEventType && "w-1/2")}
-                classNames={{ container: cn(canCreateEventType && "w-full") }}
-                data-testid="managed-event-type"
-              >
-                <strong className="mb-1 block">{t("managed_event")}</strong>
-                <p>{t("managed_event_description")}</p>
-              </RadioAreaItem>
-            )}
-          </RadioAreaGroup>
-        </div>
-      </div>
-      {SubmitButton(isPending)}
-    </Form>
-  );
-};
-
-export default TeamEventTypeForm;

package/src/event-types/components/weight-description.tsx

@@ -1,24 +0,0 @@
-import Link from "next/link";
-
-import ServerTrans from "../../vendor/server-trans";
-
-type TranslationFunction = (key: string, options?: Record<string, unknown>) => string;
-
-export default function WeightDescription({ t }: { t: TranslationFunction }) {
-  return (
-    <ServerTrans
-      t={t}
-      i18nKey="weights_description"
-      components={[
-        <Link
-          key="weights_description"
-          className="underline underline-offset-2"
-          target="_blank"
-          href="https://cal.com/docs/enterprise-features/teams/round-robin-scheduling#weights"
-        >
-          Learn more
-        </Link>,
-      ]}
-    />
-  );
-}

package/src/event-types/hooks/__tests__/use-assign-all-managed-warning.test.ts

@@ -1,78 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { describe, expect, it } from "vitest";
-import { SchedulingType } from "../../../contracts";
-import { useAssignAllManagedWarning } from "../use-assign-all-managed-warning";
-
-describe("useAssignAllManagedWarning", () => {
-  it("is closed by default", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    expect(result.current.isOpen).toBe(false);
-  });
-
-  it("shouldShowWarning returns true when toggling on a MANAGED event type", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    expect(
-      result.current.shouldShowWarning({
-        schedulingType: SchedulingType.MANAGED,
-        oldAssignAllTeamMembers: false,
-        newAssignAllTeamMembers: true,
-      })
-    ).toBe(true);
-  });
-
-  it("shouldShowWarning returns false for non-managed scheduling types", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    expect(
-      result.current.shouldShowWarning({
-        schedulingType: SchedulingType.ROUND_ROBIN,
-        oldAssignAllTeamMembers: false,
-        newAssignAllTeamMembers: true,
-      })
-    ).toBe(false);
-    expect(
-      result.current.shouldShowWarning({
-        schedulingType: null,
-        oldAssignAllTeamMembers: false,
-        newAssignAllTeamMembers: true,
-      })
-    ).toBe(false);
-  });
-
-  it("shouldShowWarning returns false when toggling off", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    expect(
-      result.current.shouldShowWarning({
-        schedulingType: SchedulingType.MANAGED,
-        oldAssignAllTeamMembers: true,
-        newAssignAllTeamMembers: false,
-      })
-    ).toBe(false);
-  });
-
-  it("shouldShowWarning returns false once the user has confirmed", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    act(() => result.current.confirm());
-    expect(
-      result.current.shouldShowWarning({
-        schedulingType: SchedulingType.MANAGED,
-        oldAssignAllTeamMembers: false,
-        newAssignAllTeamMembers: true,
-      })
-    ).toBe(false);
-  });
-
-  it("show opens the dialog and cancel closes it", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    act(() => result.current.show());
-    expect(result.current.isOpen).toBe(true);
-    act(() => result.current.cancel());
-    expect(result.current.isOpen).toBe(false);
-  });
-
-  it("confirm closes the dialog and persists confirmation", () => {
-    const { result } = renderHook(() => useAssignAllManagedWarning());
-    act(() => result.current.show());
-    act(() => result.current.confirm());
-    expect(result.current.isOpen).toBe(false);
-  });
-});