@oxyhq/bloom 0.88.0 → 1.0.0

package/src/__tests__/AlertDialog.test.tsx

@@ -1,284 +0,0 @@
-import React, { useState } from 'react';
-import { act, fireEvent, render } from '@testing-library/react-native';
-
-import { AlertDialog, AlertDialogHost, confirm } from '../alert-dialog';
-import { createAlertDialog } from '../alert-dialog/AlertDialog';
-import { createAlertDialogHost } from '../alert-dialog/AlertDialogHost';
-import { getConfirmQueue, resolveConfirm } from '../alert-dialog/confirm-store';
-import type { DialogProps } from '../dialog';
-import { BloomThemeProvider } from '../theme/BloomThemeProvider';
-
-function renderWithTheme(ui: React.ReactElement) {
-  return render(
-    <BloomThemeProvider mode="light" colorPreset="teal">
-      {ui}
-    </BloomThemeProvider>,
-  );
-}
-
-// `AlertDialog` is a thin wrapper over `<Dialog placement="center">` that maps
-// its confirm/cancel props onto the Dialog's declarative `actions` row (the
-// shared `ActionRow`/`ActionButton` primitive). These tests assert the
-// public-API contract it owns — controlled visibility, the title/description
-// copy, the confirm/cancel actions, and — most importantly — the exact
-// `confirm()` promise-resolution contract every ecosystem call site relies on:
-// the confirm button resolves `true`; the cancel button (or Escape / backdrop,
-// which route through the Dialog's `onClose`) resolves `false`.
-describe('AlertDialog (built on Dialog)', () => {
-  afterEach(() => {
-    // Drain any confirm() entries a test left pending so the module-scoped
-    // queue never bleeds across tests.
-    for (const entry of [...getConfirmQueue()]) {
-      resolveConfirm(entry.id, false);
-    }
-  });
-
-  it('renders nothing when not visible', () => {
-    const { queryByText } = renderWithTheme(
-      <AlertDialog
-        visible={false}
-        onClose={() => {}}
-        title="Delete app?"
-        description="This cannot be undone."
-      />,
-    );
-    expect(queryByText('Delete app?')).toBeNull();
-    expect(queryByText('This cannot be undone.')).toBeNull();
-  });
-
-  it('renders title, description and the confirm/cancel row when visible', () => {
-    const { getByText } = renderWithTheme(
-      <AlertDialog
-        visible
-        onClose={() => {}}
-        title="Delete app?"
-        description="This cannot be undone."
-        confirmLabel="Delete"
-        cancelLabel="Keep"
-      />,
-    );
-    expect(getByText('Delete app?')).toBeTruthy();
-    expect(getByText('This cannot be undone.')).toBeTruthy();
-    expect(getByText('Delete')).toBeTruthy();
-    expect(getByText('Keep')).toBeTruthy();
-  });
-
-  it('runs onConfirm then onClose when the confirm button is pressed', () => {
-    const calls: string[] = [];
-    const onConfirm = jest.fn(() => calls.push('confirm'));
-    const onClose = jest.fn(() => calls.push('close'));
-    const { getByText } = renderWithTheme(
-      <AlertDialog
-        visible
-        onClose={onClose}
-        title="Confirm?"
-        confirmLabel="Yes"
-        onConfirm={onConfirm}
-      />,
-    );
-    act(() => {
-      fireEvent.press(getByText('Yes'));
-    });
-    expect(onConfirm).toHaveBeenCalledTimes(1);
-    expect(onClose).toHaveBeenCalledTimes(1);
-    // Order matters: onConfirm must resolve the promise BEFORE onClose runs.
-    expect(calls).toEqual(['confirm', 'close']);
-  });
-
-  it('requests close (resolves cancel) when the cancel button is pressed', () => {
-    const onClose = jest.fn();
-    const { getByText } = renderWithTheme(
-      <AlertDialog
-        visible
-        onClose={onClose}
-        title="Confirm?"
-        cancelLabel="No"
-      />,
-    );
-    act(() => {
-      fireEvent.press(getByText('No'));
-    });
-    // The `cancel` action dismisses via the Dialog's `close()`, which in
-    // controlled mode fires `onClose` — the confirm() host's resolve-false.
-    expect(onClose).toHaveBeenCalledTimes(1);
-  });
-
-  it('invokes onCancel after the cancel button dismisses the dialog', () => {
-    const onCancel = jest.fn();
-    function Harness() {
-      const [open, setOpen] = useState(true);
-      return (
-        <AlertDialog
-          visible={open}
-          onClose={() => setOpen(false)}
-          title="Confirm?"
-          cancelLabel="No"
-          onCancel={onCancel}
-        />
-      );
-    }
-    const { getByText } = renderWithTheme(<Harness />);
-    act(() => {
-      fireEvent.press(getByText('No'));
-    });
-    expect(onCancel).toHaveBeenCalledTimes(1);
-  });
-
-  it('hides the cancel button when hideCancel is set', () => {
-    const { queryByText, getByText } = renderWithTheme(
-      <AlertDialog
-        visible
-        onClose={() => {}}
-        title="Acknowledge"
-        confirmLabel="OK"
-        cancelLabel="Cancel"
-        hideCancel
-      />,
-    );
-    expect(getByText('OK')).toBeTruthy();
-    expect(queryByText('Cancel')).toBeNull();
-  });
-
-  it('renders a destructive confirm action', () => {
-    const onConfirm = jest.fn();
-    const { getByText } = renderWithTheme(
-      <AlertDialog
-        visible
-        onClose={() => {}}
-        title="Sign out everywhere?"
-        confirmLabel="Sign out"
-        destructive
-        onConfirm={onConfirm}
-      />,
-    );
-    const confirmButton = getByText('Sign out');
-    expect(confirmButton).toBeTruthy();
-    act(() => {
-      fireEvent.press(confirmButton);
-    });
-    expect(onConfirm).toHaveBeenCalledTimes(1);
-  });
-
-  // The authoritative ecosystem contract: `confirm()` + `<AlertDialogHost />`.
-  // Every consuming call site does `const ok = await confirm({...})`, so these
-  // assert the exact promise resolution against the REAL rendered action row.
-  describe('confirm() + AlertDialogHost promise contract', () => {
-    it('resolves true when the confirm button is pressed', async () => {
-      const { getByText } = renderWithTheme(<AlertDialogHost />);
-      let result!: Promise<boolean>;
-      act(() => {
-        result = confirm({
-          title: 'Delete app?',
-          confirmLabel: 'Delete',
-          cancelLabel: 'Keep',
-        });
-      });
-      act(() => {
-        fireEvent.press(getByText('Delete'));
-      });
-      await expect(result).resolves.toBe(true);
-      expect(getConfirmQueue()).toHaveLength(0);
-    });
-
-    it('resolves false when the cancel button is pressed', async () => {
-      const { getByText } = renderWithTheme(<AlertDialogHost />);
-      let result!: Promise<boolean>;
-      act(() => {
-        result = confirm({
-          title: 'Discard changes?',
-          confirmLabel: 'Discard',
-          cancelLabel: 'Keep editing',
-        });
-      });
-      act(() => {
-        fireEvent.press(getByText('Keep editing'));
-      });
-      await expect(result).resolves.toBe(false);
-      expect(getConfirmQueue()).toHaveLength(0);
-    });
-
-    it('resolves true even though confirm fires both onConfirm and onClose', async () => {
-      // The confirm button runs onConfirm (resolve true, drains the entry) then
-      // onClose (resolve false — a no-op once the entry is gone). The net must
-      // be `true`; this guards the double-resolution path explicitly.
-      const { getByText } = renderWithTheme(<AlertDialogHost />);
-      let result!: Promise<boolean>;
-      act(() => {
-        result = confirm({ title: 'Proceed?', confirmLabel: 'Proceed' });
-      });
-      act(() => {
-        fireEvent.press(getByText('Proceed'));
-      });
-      await expect(result).resolves.toBe(true);
-    });
-  });
-
-  // Finding 1 (control-mode) + Finding 2 (backdrop-dismiss default). These pin
-  // the two behavioural fixes at the prop boundary between `AlertDialog` and the
-  // underlying `Dialog`, using a prop-capturing mock `Dialog` so the assertions
-  // are deterministic and platform-agnostic.
-  describe('control-mode bridge + dismiss defaults', () => {
-    function captureDialogProps() {
-      const captured: { props?: DialogProps } = {};
-      const MockDialog = (props: DialogProps) => {
-        captured.props = props;
-        return null;
-      };
-      return { captured, MockDialog };
-    }
-
-    it('drives the underlying Dialog imperatively (control), never the controlled `open` prop', () => {
-      const { captured, MockDialog } = captureDialogProps();
-      const TestAlertDialog = createAlertDialog(MockDialog);
-      renderWithTheme(<TestAlertDialog visible onClose={() => {}} title="Delete?" />);
-      // The whole point of the fix: `confirm()` must take the Dialog's
-      // imperative/uncontrolled branch (the one that plays the exit animation),
-      // so an imperative `control` handle is passed and the controlled `open`
-      // boolean — which would take the other branch — is never set.
-      expect(captured.props?.control).toBeDefined();
-      expect(captured.props?.open).toBeUndefined();
-    });
-
-    it('defaults dismissOnBackdrop to true (backdrop / Escape dismiss by default)', () => {
-      const { captured, MockDialog } = captureDialogProps();
-      const TestAlertDialog = createAlertDialog(MockDialog);
-      renderWithTheme(<TestAlertDialog visible onClose={() => {}} title="Delete?" />);
-      // Matches the shared Dialog default + Mention's ConfirmPrompt.
-      expect(captured.props?.dismissOnBackdrop).toBe(true);
-    });
-
-    it('still supports an opt-in blocking confirm via dismissible={false}', () => {
-      const { captured, MockDialog } = captureDialogProps();
-      const TestAlertDialog = createAlertDialog(MockDialog);
-      renderWithTheme(
-        <TestAlertDialog visible onClose={() => {}} title="Delete?" dismissible={false} />,
-      );
-      expect(captured.props?.dismissOnBackdrop).toBe(false);
-    });
-
-    it('resolves false when dismissed via backdrop / Escape (Dialog onClose) with no button press', async () => {
-      // Backdrop tap and Escape both route through the Dialog's `onClose`. Now
-      // that dismissOnBackdrop defaults true, that path is reachable by default
-      // and must resolve the confirm as cancelled (false) and drain the queue —
-      // never trigger the (potentially destructive) confirm action.
-      const captured: { onClose?: () => void } = {};
-      const MockDialog = (props: DialogProps) => {
-        captured.onClose = props.onClose;
-        return null;
-      };
-      const Host = createAlertDialogHost(createAlertDialog(MockDialog));
-      renderWithTheme(<Host />);
-      let result!: Promise<boolean>;
-      act(() => {
-        result = confirm({ title: 'Discard unsaved changes?' });
-      });
-      act(() => {
-        // Simulate the backdrop / Escape dismissal the real Dialog fires after
-        // its exit animation settles.
-        captured.onClose?.();
-      });
-      await expect(result).resolves.toBe(false);
-      expect(getConfirmQueue()).toHaveLength(0);
-    });
-  });
-});

package/src/__tests__/AnimatedCheck.test.tsx

@@ -1,31 +0,0 @@
-import React from 'react';
-import { act, render } from '@testing-library/react-native';
-
-import { BloomThemeProvider } from '../theme/BloomThemeProvider';
-import { AnimatedCheck, type AnimatedCheckRef } from '../animated-check';
-
-function renderWithTheme(ui: React.ReactElement) {
-  return render(
-    <BloomThemeProvider mode="light" colorPreset="teal">
-      {ui}
-    </BloomThemeProvider>,
-  );
-}
-
-describe('AnimatedCheck', () => {
-  it('carries a displayName', () => {
-    expect(AnimatedCheck.displayName).toBe('AnimatedCheck');
-  });
-
-  it('renders the animated SVG when react-native-svg is available', () => {
-    const { toJSON } = renderWithTheme(<AnimatedCheck size={48} />);
-    expect(toJSON()).not.toBeNull();
-  });
-
-  it('exposes an imperative play() that runs without throwing', () => {
-    const ref = React.createRef<AnimatedCheckRef>();
-    renderWithTheme(<AnimatedCheck ref={ref} size={48} color="#6366f1" />);
-    expect(ref.current).not.toBeNull();
-    expect(() => act(() => ref.current?.play())).not.toThrow();
-  });
-});

package/src/__tests__/Avatar.test.tsx

@@ -1,87 +0,0 @@
-import React from 'react';
-import { render } from '@testing-library/react-native';
-
-import { BloomThemeProvider } from '../theme/BloomThemeProvider';
-import { Avatar } from '../avatar';
-import { ImageResolverProvider, type ImageResolver } from '../image-resolver';
-
-function renderWithProviders(
-  ui: React.ReactElement,
-  resolver: ImageResolver,
-) {
-  return render(
-    <BloomThemeProvider mode="light" colorPreset="teal">
-      <ImageResolverProvider value={resolver}>{ui}</ImageResolverProvider>
-    </BloomThemeProvider>,
-  );
-}
-
-describe('Avatar variant resolution', () => {
-  it('passes the variant to the ImageResolver for a bare file ID source', () => {
-    const resolver = jest.fn<ReturnType<ImageResolver>, Parameters<ImageResolver>>(
-      (id, variant) => `https://cloud.oxy.so/${id}?variant=${variant ?? ''}`,
-    );
-
-    renderWithProviders(
-      <Avatar source="file_123" variant="thumb" size={32} />,
-      resolver,
-    );
-
-    expect(resolver).toHaveBeenCalledWith('file_123', 'thumb');
-  });
-
-  it("defaults the variant to 'thumb' when none is supplied for a bare file ID", () => {
-    const resolver = jest.fn<ReturnType<ImageResolver>, Parameters<ImageResolver>>(
-      (id) => `https://cloud.oxy.so/${id}`,
-    );
-
-    renderWithProviders(<Avatar source="file_456" size={40} />, resolver);
-
-    // No explicit variant → the safe default 'thumb', never the full-size
-    // original (undefined would request full size per the ImageResolver contract).
-    expect(resolver).toHaveBeenCalledWith('file_456', 'thumb');
-  });
-
-  it('forwards an explicit variant unchanged, overriding the default', () => {
-    const resolver = jest.fn<ReturnType<ImageResolver>, Parameters<ImageResolver>>(
-      (id, variant) => `https://cloud.oxy.so/${id}?variant=${variant ?? ''}`,
-    );
-
-    renderWithProviders(
-      <Avatar source="file_999" variant="w320" size={96} />,
-      resolver,
-    );
-
-    expect(resolver).toHaveBeenCalledWith('file_999', 'w320');
-  });
-
-  it('does NOT invoke the resolver when source is already a full URL', () => {
-    const resolver = jest.fn<ReturnType<ImageResolver>, Parameters<ImageResolver>>(
-      (id) => `https://cloud.oxy.so/${id}`,
-    );
-
-    renderWithProviders(
-      <Avatar source="https://example.com/a.png" variant="thumb" size={40} />,
-      resolver,
-    );
-
-    expect(resolver).not.toHaveBeenCalled();
-  });
-
-  it('renders the resolved variant URL as the image uri', () => {
-    const resolver: ImageResolver = (id, variant) =>
-      `https://cloud.oxy.so/${id}?variant=${variant ?? 'full'}`;
-
-    const { UNSAFE_getByType } = renderWithProviders(
-      <Avatar source="file_789" variant="thumb" size={32} />,
-      resolver,
-    );
-
-    // The rendered RN Image (mocked) carries the resolved uri.
-    const { Image } = require('react-native');
-    const image = UNSAFE_getByType(Image);
-    expect(image.props.source).toEqual({
-      uri: 'https://cloud.oxy.so/file_789?variant=thumb',
-    });
-  });
-});

package/src/__tests__/AvatarGroupCluster.test.tsx

@@ -1,224 +0,0 @@
-import React from 'react';
-import { render } from '@testing-library/react-native';
-
-import { BloomThemeProvider } from '../theme/BloomThemeProvider';
-import { AvatarGroup } from '../avatar-group';
-import type { AvatarGroupItem } from '../avatar-group';
-import {
-  computeClusterLayout,
-  type ClusterBubble,
-} from '../avatar-group/cluster-layout';
-
-/** Returns bubble at `index` or throws — keeps the tests `!`/`as`-free under
- * `noUncheckedIndexedAccess`. */
-function bubbleAt(bubbles: readonly ClusterBubble[], index: number): ClusterBubble {
-  const bubble = bubbles[index];
-  if (!bubble) throw new Error(`expected a bubble at index ${index}`);
-  return bubble;
-}
-
-/** Nearest-neighbour edge gap for every bubble (negative = overlap). */
-function minEdgeGap(bubbles: readonly ClusterBubble[]): number {
-  let worst = Infinity;
-  for (const a of bubbles) {
-    for (const b of bubbles) {
-      if (a === b) continue;
-      const centerDist = Math.hypot(a.cx - b.cx, a.cy - b.cy);
-      const gap = centerDist - (a.d / 2 + b.d / 2);
-      if (gap < worst) worst = gap;
-    }
-  }
-  return worst;
-}
-
-describe('computeClusterLayout', () => {
-  it('returns an empty layout for non-positive counts', () => {
-    expect(computeClusterLayout(0)).toEqual([]);
-    expect(computeClusterLayout(-3)).toEqual([]);
-  });
-
-  it('returns exactly `count` bubbles', () => {
-    for (let count = 1; count <= 20; count++) {
-      expect(computeClusterLayout(count)).toHaveLength(count);
-    }
-  });
-
-  it('is fully deterministic (no Math.random)', () => {
-    for (const count of [2, 3, 4, 8, 20]) {
-      expect(computeClusterLayout(count)).toEqual(computeClusterLayout(count));
-    }
-  });
-
-  it('keeps every bubble inside the unit box with no NaN', () => {
-    for (let count = 1; count <= 20; count++) {
-      const bubbles = computeClusterLayout(count);
-      for (const bubble of bubbles) {
-        expect(Number.isNaN(bubble.cx)).toBe(false);
-        expect(Number.isNaN(bubble.cy)).toBe(false);
-        expect(Number.isNaN(bubble.d)).toBe(false);
-        expect(bubble.cx - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-        expect(bubble.cx + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-        expect(bubble.cy - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-        expect(bubble.cy + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-      }
-    }
-  });
-
-  it('makes the primary (index 0) the largest bubble', () => {
-    for (let count = 2; count <= 20; count++) {
-      const bubbles = computeClusterLayout(count);
-      const primary = bubbleAt(bubbles, 0);
-      for (const bubble of bubbles) {
-        expect(primary.d).toBeGreaterThanOrEqual(bubble.d - 1e-9);
-      }
-    }
-  });
-
-  it('fills the round box edge-to-edge for the force-packed counts (5+)', () => {
-    // After the recentre + scale, the outermost bubble edge lands on the box
-    // radius (0.5 from the box centre) — the blob fills the round box densely
-    // with no big empty margin — and the whole cluster stays roughly centred.
-    // (count=4 is the explicit 2×2 grid, covered separately below.)
-    for (const count of [5, 8, 12, 20]) {
-      const bubbles = computeClusterLayout(count);
-      let reach = 0;
-      for (const bubble of bubbles) {
-        const r = Math.hypot(bubble.cx - 0.5, bubble.cy - 0.5) + bubble.d / 2;
-        if (r > reach) reach = r;
-      }
-      expect(reach).toBeCloseTo(0.5, 6);
-      const primary = bubbleAt(bubbles, 0);
-      expect(primary.cx).toBeGreaterThan(0.4);
-      expect(primary.cx).toBeLessThan(0.6);
-      expect(primary.cy).toBeGreaterThan(0.4);
-      expect(primary.cy).toBeLessThan(0.6);
-    }
-  });
-
-  it('keeps the force-packed bubbles near-equal in size (mild taper)', () => {
-    // The pack should read as near-equal magnetic bubbles: a modestly larger
-    // primary, everyone else only slightly smaller — not a big primary ringed by
-    // tiny dots. The smallest bubble stays at least ~75% of the largest.
-    // (count=4 is the explicit 2×2 grid, covered separately below.)
-    for (const count of [5, 6, 8, 12, 20]) {
-      const diameters = computeClusterLayout(count).map((bubble) => bubble.d);
-      const maxD = Math.max(...diameters);
-      const minD = Math.min(...diameters);
-      expect(minD / maxD).toBeGreaterThan(0.75);
-    }
-  });
-
-  it('keeps a uniform, non-overlapping gap for 3+ members', () => {
-    // n=2 is the intentional "front + behind" overlap; 3+ pack with a gap.
-    for (let count = 3; count <= 20; count++) {
-      expect(minEdgeGap(computeClusterLayout(count))).toBeGreaterThan(-1e-3);
-    }
-  });
-
-  it('arranges the four-member cluster as an equal-size 2×2 grid', () => {
-    // The iMessage 4-person layout: four EQUAL-diameter bubbles at the corners of
-    // a 2×2 grid centred in the box, with a clean uniform gap (no overlap), sized
-    // so the outermost edges reach the box edge like the other counts.
-    const bubbles = computeClusterLayout(4);
-    expect(bubbles).toHaveLength(4);
-
-    // All four share one diameter.
-    const d = bubbleAt(bubbles, 0).d;
-    for (const bubble of bubbles) {
-      expect(bubble.d).toBeCloseTo(d, 10);
-    }
-
-    // Exactly two distinct rows (cy) and two distinct columns (cx), each shared by
-    // two bubbles — a true 2×2 grid, centred on the box (rows/cols symmetric
-    // about 0.5).
-    const round = (v: number) => Math.round(v * 1e6) / 1e6;
-    const cols = [...new Set(bubbles.map((b) => round(b.cx)))].sort((a, b) => a - b);
-    const rows = [...new Set(bubbles.map((b) => round(b.cy)))].sort((a, b) => a - b);
-    expect(cols).toHaveLength(2);
-    expect(rows).toHaveLength(2);
-    const col0 = cols[0];
-    const col1 = cols[1];
-    const row0 = rows[0];
-    const row1 = rows[1];
-    if (col0 === undefined || col1 === undefined || row0 === undefined || row1 === undefined) {
-      throw new Error('expected two distinct rows and columns');
-    }
-    expect((col0 + col1) / 2).toBeCloseTo(0.5, 9);
-    expect((row0 + row1) / 2).toBeCloseTo(0.5, 9);
-    // Square grid: the row and column spacings match.
-    expect(col1 - col0).toBeCloseTo(row1 - row0, 9);
-
-    // Clean uniform gap between neighbours — no overlap.
-    expect(minEdgeGap(bubbles)).toBeGreaterThan(0);
-
-    // Outermost edge reaches the box radius (fills the round box like the others).
-    let reach = 0;
-    for (const bubble of bubbles) {
-      const r = Math.hypot(bubble.cx - 0.5, bubble.cy - 0.5) + bubble.d / 2;
-      if (r > reach) reach = r;
-    }
-    expect(reach).toBeCloseTo(0.5, 6);
-
-    // Fully inside the unit box, and deterministic.
-    for (const bubble of bubbles) {
-      expect(bubble.cx - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-      expect(bubble.cx + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-      expect(bubble.cy - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-      expect(bubble.cy + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-    }
-    expect(computeClusterLayout(4)).toEqual(bubbles);
-  });
-
-  it('gives the two-member cluster equal-diameter, overlapping bubbles', () => {
-    const bubbles = computeClusterLayout(2);
-    expect(bubbles).toHaveLength(2);
-    const front = bubbleAt(bubbles, 0);
-    const behind = bubbleAt(bubbles, 1);
-    // The fix: both bubbles share the SAME diameter — the one drawn behind is no
-    // longer rendered too small.
-    expect(front.d).toBeCloseTo(behind.d, 10);
-    // Still the intentional iMessage "front + behind" overlap (negative gap).
-    expect(minEdgeGap(bubbles)).toBeLessThan(0);
-    // Deterministic (no Math.random).
-    expect(computeClusterLayout(2)).toEqual(bubbles);
-    // Both bubbles sit fully inside the unit box.
-    for (const bubble of bubbles) {
-      expect(bubble.cx - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-      expect(bubble.cx + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-      expect(bubble.cy - bubble.d / 2).toBeGreaterThanOrEqual(-1e-6);
-      expect(bubble.cy + bubble.d / 2).toBeLessThanOrEqual(1 + 1e-6);
-    }
-  });
-});
-
-const CLUSTER_ITEMS: AvatarGroupItem[] = Array.from({ length: 25 }, (_, i) => ({
-  id: `c${i}`,
-  displayName: `Member ${i}`,
-  username: `member${i}`,
-}));
-
-function renderCluster(ui: React.ReactElement) {
-  return render(<BloomThemeProvider mode="light" colorPreset="teal">{ui}</BloomThemeProvider>);
-}
-
-describe('AvatarGroup cluster layout', () => {
-  it('renders a "+N" overflow bubble past the cap', () => {
-    // 25 members, cap 20 → 19 avatars + a "+6" bubble.
-    const { getByText } = renderCluster(
-      <AvatarGroup layout="cluster" items={CLUSTER_ITEMS} size={140} max={20} showInitials />,
-    );
-    expect(getByText('+6')).toBeTruthy();
-  });
-
-  it('shows no overflow bubble when members fit under the cap', () => {
-    const { queryByText } = renderCluster(
-      <AvatarGroup
-        layout="cluster"
-        items={CLUSTER_ITEMS.slice(0, 4)}
-        size={64}
-        showInitials
-      />,
-    );
-    expect(queryByText(/^\+/)).toBeNull();
-  });
-});