Skip to content

An open source design system that's fully customizable and agent ready

TypeScript
15.4 KB
Raw Blame
// Copyright (c) Meta Platforms, Inc. and affiliates.

/**
 * @file layerClickBoundary.test.tsx
 * @input Uses React Testing Library, every layer root (Popover, Dialog, Drawer,
 *   Lightbox, MobileNav, BottomSheet, ToastViewport), ClickableCard,
 *   ContextMenu, BaseTypeahead, SelectableCard, Tooltip and
 *   useKeepLayerOpenProps
 * @output A press inside a layer stops at the layer root in the React tree,
 *   and the native press still reaches document listeners (ContextMenu's
 *   outside mousedown, Typeahead's deferred click, the keep-open pointerup);
 *   SelectableCard's compatibility path until the next minor.
 */

import {
  act,
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from '@testing-library/react';
import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
import {useEffect, type ReactNode} from 'react';
import {Popover} from '../Popover/Popover';
import {Dialog} from '../Dialog/Dialog';
import {Drawer} from '../Drawer/Drawer';
import {Lightbox} from '../Lightbox/Lightbox';
import {MobileNav} from '../MobileNav/MobileNav';
import {BottomSheet} from '../BottomSheet/BottomSheet';
import {BottomSheetSwitcher} from '../BottomSheet/BottomSheetSwitcher';
import {ToastViewport} from '../Toast/ToastViewport';
import {useToast} from '../Toast/useToast';
import {ClickableCard} from '../ClickableCard/ClickableCard';
import {ContextMenu} from '../ContextMenu/ContextMenu';
import {BaseTypeahead} from '../Typeahead/BaseTypeahead';
import {SelectableCard} from '../SelectableCard/SelectableCard';
import {Tooltip} from '../Tooltip/Tooltip';
import {Button} from '../Button/Button';
import {useKeepLayerOpenProps} from './useLayer';
import type {SearchSource, SearchableItem} from '../Typeahead/types';

function press(target: Element) {
  fireEvent.pointerDown(target);
  fireEvent.mouseDown(target);
  fireEvent.pointerUp(target);
  fireEvent.mouseUp(target);
  fireEvent.click(target);
}

describe('layer click boundary (layer-runtime INV17)', () => {
  it('stops a press inside a popover at its root, after the handlers inside ran', () => {
    const inner = vi.fn();
    const ancestor = {
      click: vi.fn(),
      pointerDown: vi.fn(),
      mouseDown: vi.fn(),
      clickCapture: vi.fn(),
    };
    const documentClick = vi.fn();
    document.addEventListener('click', documentClick);
    try {
      render(
        <div
          onClick={ancestor.click}
          onPointerDown={ancestor.pointerDown}
          onMouseDown={ancestor.mouseDown}
          onClickCapture={ancestor.clickCapture}>
          <Popover
            isOpen
            label="Details"
            content={
              <button type="button" onClick={inner}>
                Inside
              </button>
            }>
            <button type="button">Trigger</button>
          </Popover>
        </div>,
      );
      press(screen.getByRole('button', {name: 'Inside', hidden: true}));

      expect(inner).toHaveBeenCalledTimes(1);
      expect(ancestor.click).not.toHaveBeenCalled();
      expect(ancestor.pointerDown).not.toHaveBeenCalled();
      expect(ancestor.mouseDown).not.toHaveBeenCalled();
      // Capture-phase ancestors run before the stop.
      expect(ancestor.clickCapture).toHaveBeenCalledTimes(1);
      // The native press is not stopped.
      expect(documentClick).toHaveBeenCalledTimes(1);

      // Positive control: a press outside the layer still reaches the
      // ancestor.
      press(screen.getByRole('button', {name: 'Trigger'}));
      expect(ancestor.click).toHaveBeenCalled();
    } finally {
      document.removeEventListener('click', documentClick);
    }
  });

  it('stops a press inside a nested layer at its own root', () => {
    const outerContent = vi.fn();
    render(
      <Popover
        isOpen
        label="Outer"
        content={
          <div onClick={outerContent}>
            <Popover isOpen label="Inner" content={<span>Inner text</span>}>
              <button type="button">Inner trigger</button>
            </Popover>
          </div>
        }>
        <button type="button">Outer trigger</button>
      </Popover>,
    );
    press(screen.getByText('Inner text'));
    expect(outerContent).not.toHaveBeenCalled();
  });

  describe('every kind of layer root', () => {
    const {showModal, close} = HTMLDialogElement.prototype;
    beforeEach(() => {
      HTMLDialogElement.prototype.showModal = function (
        this: HTMLDialogElement,
      ) {
        this.setAttribute('open', '');
      };
      HTMLDialogElement.prototype.close = function (this: HTMLDialogElement) {
        this.removeAttribute('open');
      };
    });
    afterEach(() => {
      // Unmount while the stubs still exist: closing calls dialog.close().
      cleanup();
      HTMLDialogElement.prototype.showModal = showModal;
      HTMLDialogElement.prototype.close = close;
    });

    function ShowToast() {
      const toast = useToast();
      useEffect(() => {
        toast({body: 'Root text', isAutoHide: false});
      }, [toast]);
      return null;
    }

    const roots: [string, () => ReactNode][] = [
      [
        'an inline useLayer layer',
        () => (
          <Popover isOpen label="Details" content={<span>Root text</span>}>
            <button type="button">Trigger</button>
          </Popover>
        ),
      ],
      [
        'a portaled useLayer layer',
        () => (
          <ul>
            <li>
              <Popover isOpen label="Details" content={<span>Root text</span>}>
                <button type="button">Trigger</button>
              </Popover>
            </li>
          </ul>
        ),
      ],
      [
        'Dialog',
        () => (
          <Dialog isOpen onOpenChange={() => {}}>
            <p>Root text</p>
          </Dialog>
        ),
      ],
      [
        'Drawer',
        () => (
          <Drawer isOpen onOpenChange={() => {}} label="Details">
            Root text
          </Drawer>
        ),
      ],
      [
        'Lightbox',
        () => (
          <Lightbox
            isOpen
            onOpenChange={() => {}}
            media={[{src: '/photo.jpg', alt: 'Root text'}]}
          />
        ),
      ],
      [
        'MobileNav',
        () => (
          <MobileNav isOpen onOpenChange={() => {}}>
            <span>Root text</span>
          </MobileNav>
        ),
      ],
      [
        'BottomSheetPanel',
        () => (
          <BottomSheet isOpen onOpenChange={() => {}} label="Filters">
            Root text
          </BottomSheet>
        ),
      ],
      [
        'ToastViewport',
        () => (
          <ToastViewport isTopLayer={false}>
            <ShowToast />
          </ToastViewport>
        ),
      ],
    ];

    const target = () =>
      screen.queryByText('Root text') ?? screen.getByAltText('Root text');

    it.each(roots)(
      'a press inside %s reaches no plain wrapper bubble handler',
      async (_name, renderRoot) => {
        const wrapper = {
          click: vi.fn(),
          pointerDown: vi.fn(),
          gotCapture: vi.fn(),
          lostCapture: vi.fn(),
        };
        render(
          <div
            onClick={wrapper.click}
            onPointerDown={wrapper.pointerDown}
            onGotPointerCapture={wrapper.gotCapture}
            onLostPointerCapture={wrapper.lostCapture}>
            {renderRoot()}
          </div>,
        );
        await waitFor(() => expect(target()).toBeInTheDocument());
        press(target());
        // A drag handle or slider inside the layer taking and releasing
        // pointer capture.
        fireEvent(target(), new Event('gotpointercapture', {bubbles: true}));
        fireEvent(target(), new Event('lostpointercapture', {bubbles: true}));
        expect(wrapper.click).not.toHaveBeenCalled();
        expect(wrapper.pointerDown).not.toHaveBeenCalled();
        expect(wrapper.gotCapture).not.toHaveBeenCalled();
        expect(wrapper.lostCapture).not.toHaveBeenCalled();
      },
    );

    it.each(roots)(
      'a press inside %s does not activate a ClickableCard around it',
      async (_name, renderRoot) => {
        const onClick = vi.fn();
        render(
          <ClickableCard label="Card" onClick={onClick}>
            {renderRoot()}
          </ClickableCard>,
        );
        await waitFor(() => expect(target()).toBeInTheDocument());
        press(target());
        expect(onClick).not.toHaveBeenCalled();
      },
    );

    it("a BottomSheetSwitcher's forwarded handlers still receive presses on sheet content", () => {
      const switcher = {click: vi.fn(), pointerDown: vi.fn()};
      const wrapperClick = vi.fn();
      render(
        <div onClick={wrapperClick}>
          <BottomSheetSwitcher
            activeSheet="details"
            onActiveSheetChange={() => {}}
            onClick={switcher.click}
            onPointerDown={switcher.pointerDown}>
            <BottomSheet sheetId="details" label="Details">
              Step text
            </BottomSheet>
          </BottomSheetSwitcher>
        </div>,
      );
      press(screen.getByText('Step text'));
      // The switcher forwards these to the step's dialog.
      expect(switcher.click).toHaveBeenCalledTimes(1);
      expect(switcher.pointerDown).toHaveBeenCalledTimes(1);
      expect(wrapperClick).not.toHaveBeenCalled();
    });

    it("runs the root's own onClick before the stop (Dialog)", () => {
      const ancestorClick = vi.fn();
      const dialogClick = vi.fn();
      render(
        <div onClick={ancestorClick}>
          <Dialog isOpen onOpenChange={() => {}} onClick={dialogClick}>
            <p>Dialog text</p>
          </Dialog>
        </div>,
      );
      press(screen.getByText('Dialog text'));
      expect(dialogClick).toHaveBeenCalledTimes(1);
      expect(ancestorClick).not.toHaveBeenCalled();
    });
  });
});

describe('document listeners still receive presses inside a layer', () => {
  it("ContextMenu's outside mousedown closes it for a press inside an open popover", () => {
    const onOpenChange = vi.fn<(isOpen: boolean) => void>();
    render(
      <>
        <ContextMenu items={[{label: 'Cut'}]} onOpenChange={onOpenChange}>
          <div>Right-click me</div>
        </ContextMenu>
        <Popover isOpen label="Details" content={<span>Popover text</span>}>
          <button type="button">Trigger</button>
        </Popover>
      </>,
    );
    fireEvent.contextMenu(screen.getByText('Right-click me'));
    expect(onOpenChange).toHaveBeenLastCalledWith(true);
    fireEvent.pointerDown(screen.getByText('Popover text'), {
      pointerType: 'mouse',
      pointerId: 7,
    });
    fireEvent.mouseDown(screen.getByText('Popover text'));
    expect(onOpenChange).toHaveBeenLastCalledWith(false);
  });

  it('a Typeahead inside a popover opens its list on the deferred document click', async () => {
    const fruits: SearchableItem[] = [
      {id: 'apple', label: 'Apple'},
      {id: 'banana', label: 'Banana'},
    ];
    const source: SearchSource = {
      bootstrap: () => fruits,
      search: query =>
        fruits.filter(item => item.label.toLowerCase().includes(query)),
    };
    render(
      <Popover
        isOpen
        label="Filters"
        content={
          <BaseTypeahead
            searchSource={source}
            value={null}
            onChange={() => {}}
            hasEntriesOnFocus
            debounceMs={0}
          />
        }>
        <button type="button">Trigger</button>
      </Popover>,
    );
    const input = screen.getByRole('combobox', {hidden: true});
    // The press focuses the input; the list's show waits for the press's
    // click on the document, then a frame.
    fireEvent.pointerDown(input);
    act(() => {
      input.focus();
    });
    fireEvent.pointerUp(input);
    fireEvent.click(input);
    await waitFor(() => {
      expect(input).toHaveAttribute('aria-expanded', 'true');
    });
  });

  it('a keep-open control inside a popover releases its invoker on the document pointerup', async () => {
    function KeepOpen() {
      const props = useKeepLayerOpenProps('some-layer', true);
      return (
        <button type="button" {...props}>
          Keep open
        </button>
      );
    }
    render(
      <Popover isOpen label="Details" content={<KeepOpen />}>
        <button type="button">Trigger</button>
      </Popover>,
    );
    const control = screen.getByRole('button', {
      name: 'Keep open',
      hidden: true,
    });
    fireEvent.pointerDown(control);
    expect(control).toHaveAttribute('popovertarget', 'some-layer');
    fireEvent.pointerUp(control);
    await waitFor(() => {
      expect(control).not.toHaveAttribute('popovertarget');
    });
  });
});

// Until the next minor, the caller's onClick still runs for a click inside an
// open layer within the card, during capture, and the card does not toggle.
describe('SelectableCard compatibility until the next minor', () => {
  it("still calls the caller's onClick for a click inside an open tooltip, without toggling", () => {
    const onClick = vi.fn();
    const onChange = vi.fn();
    render(
      <SelectableCard
        label="Plan"
        isSelected={false}
        onChange={onChange}
        onClick={onClick}>
        <Tooltip content="Tooltip text" isOpen>
          <span tabIndex={0}>Info</span>
        </Tooltip>
        <span>Card body</span>
      </SelectableCard>,
    );
    fireEvent.click(screen.getByText('Tooltip text'));
    expect(onClick).toHaveBeenCalledTimes(1);
    expect(onChange).not.toHaveBeenCalled();

    fireEvent.click(screen.getByText('Card body'));
    expect(onChange).toHaveBeenCalledWith(true);
    expect(onClick).toHaveBeenCalledTimes(2);
  });

  it('a caller onClick that stops propagation does not block a control inside the layer', () => {
    const inside = vi.fn();
    const onClick = vi.fn((event: {stopPropagation: () => void}) => {
      event.stopPropagation();
    });
    render(
      <SelectableCard
        label="Plan"
        isSelected={false}
        onChange={() => {}}
        onClick={onClick}>
        <Popover
          isOpen
          label="Details"
          content={
            <button type="button" onClick={inside}>
              Inside
            </button>
          }>
          <button type="button">Trigger</button>
        </Popover>
      </SelectableCard>,
    );
    fireEvent.click(screen.getByRole('button', {name: 'Inside', hidden: true}));
    expect(onClick).toHaveBeenCalledTimes(1);
    expect(inside).toHaveBeenCalledTimes(1);
  });

  it("a caller onClick that prevents default does not cancel a Button's clickAction inside the layer, and the default stays cancelled", () => {
    const clickAction = vi.fn();
    render(
      <SelectableCard
        label="Plan"
        isSelected={false}
        onChange={() => {}}
        onClick={event => event.preventDefault()}>
        <Popover
          isOpen
          label="Details"
          content={<Button label="Apply" clickAction={clickAction} />}>
          <button type="button">Trigger</button>
        </Popover>
      </SelectableCard>,
    );
    const isNotCancelled = fireEvent.click(
      screen.getByRole('button', {name: 'Apply', hidden: true}),
    );
    expect(clickAction).toHaveBeenCalledTimes(1);
    expect(isNotCancelled).toBe(false);
  });

  it('calls onClick once for a click inside a caller-written popover, which is not a layer root', () => {
    const onClick = vi.fn();
    render(
      <SelectableCard
        label="Plan"
        isSelected={false}
        onChange={() => {}}
        onClick={onClick}>
        <div popover="manual">Own popover text</div>
      </SelectableCard>,
    );
    fireEvent.click(screen.getByText('Own popover text'));
    expect(onClick).toHaveBeenCalledTimes(1);
  });
});