Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

GDGT-3369: Keep tooltips open while the pointer is over them (#84372)

Will Frycd43a9aeded2
diff --git a/e2e/test/scenarios/data-model/data-model-shared-3.cy.spec.ts b/e2e/test/scenarios/data-model/data-model-shared-3.cy.spec.ts
index 41c55eb9bc8..814a63045aa 100644
--- a/e2e/test/scenarios/data-model/data-model-shared-3.cy.spec.ts
+++ b/e2e/test/scenarios/data-model/data-model-shared-3.cy.spec.ts
@@ -645,8 +645,9 @@ areas.forEach((area) => {
.realHover({ scrollBehavior: "center" });
H.tooltip().should("be.visible").and("have.text", longPrefix);
- // hide tooltip
- FieldSection.getDescriptionInput().realHover();
+ // hide tooltip, by hovering something it can't be covering (it can
+ // flip below the prefix, over the description input)
+ FieldSection.get().findByText("Field settings").realHover();
H.tooltip().should("not.exist");
cy.log("in table section");
diff --git a/e2e/test/scenarios/visualizations/tabular/object_detail.cy.spec.js b/e2e/test/scenarios/visualizations/tabular/object_detail.cy.spec.js
index 38730a717aa..5def9f2d816 100644
--- a/e2e/test/scenarios/visualizations/tabular/object_detail.cy.spec.js
+++ b/e2e/test/scenarios/visualizations/tabular/object_detail.cy.spec.js
@@ -94,6 +94,9 @@ describe("scenarios > question > object details", { tags: "@slow" }, () => {
cy.findByTestId("object-detail").should("not.exist");
cy.log("Open object details by clicking the PK cell (metabase#27094)");
+ // `openObjectDetail` opens row 1's "View details" tooltip with a synthetic
+ // hover that never ends, and the tooltip covers row 0's PK cell.
+ cy.realPress("Escape");
drillPK({ id: 1 });
cy.findByTestId("object-detail").within(() => {
cy.findByRole("heading", { name: "Awesome Concrete Shoes" }).should(
diff --git a/frontend/src/metabase/admin/people/components/MembershipSelect/MembershipSelect.tsx b/frontend/src/metabase/admin/people/components/MembershipSelect/MembershipSelect.tsx
index 85eb0d14b49..fb72501d387 100644
--- a/frontend/src/metabase/admin/people/components/MembershipSelect/MembershipSelect.tsx
+++ b/frontend/src/metabase/admin/people/components/MembershipSelect/MembershipSelect.tsx
@@ -141,7 +141,7 @@ export const MembershipSelect = ({
</Tooltip>
{canEditMembershipType && (
<PLUGIN_GROUP_MANAGERS.UserTypeToggle
- tooltipPlacement="bottom"
+ tooltipPlacement="right"
isManager={memberships.get(group.id)?.is_group_manager}
onChange={(is_group_manager: boolean) =>
handleChangeMembership(group.id, {
diff --git a/frontend/src/metabase/admin/permissions/components/PermissionsTable/PermissionsTable.tsx b/frontend/src/metabase/admin/permissions/components/PermissionsTable/PermissionsTable.tsx
index b1545797b72..7a48a8666c0 100644
--- a/frontend/src/metabase/admin/permissions/components/PermissionsTable/PermissionsTable.tsx
+++ b/frontend/src/metabase/admin/permissions/components/PermissionsTable/PermissionsTable.tsx
@@ -173,11 +173,7 @@ export function PermissionsTable({
<Label display="inline" m={0}>
{name}{" "}
{hint && (
- <Tooltip
- label={hint}
- closeDelay={100}
- classNames={{ tooltip: CS.pointerEventsAuto }}
- >
+ <Tooltip label={hint}>
<Icon
className={CS.cursorPointer}
name="info"
diff --git a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/BulkTableVisibilityToggle.tsx b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/BulkTableVisibilityToggle.tsx
index b93d91e688a..f4708f7b7ce 100644
--- a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/BulkTableVisibilityToggle.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/BulkTableVisibilityToggle.tsx
@@ -86,7 +86,10 @@ export function BulkTableVisibilityToggle({
};
return (
- <Tooltip label={areAllHidden ? t`Unhide all tables` : t`Hide all tables`}>
+ <Tooltip
+ label={areAllHidden ? t`Unhide all tables` : t`Hide all tables`}
+ position="right"
+ >
<ActionIcon
variant="subtle"
aria-label={areAllHidden ? t`Unhide all tables` : t`Hide all tables`}
diff --git a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/TableVisibilityToggle.tsx b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/TableVisibilityToggle.tsx
index 4294b0fdbfa..acf328e12ee 100644
--- a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/TableVisibilityToggle.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/components/TableVisibilityToggle.tsx
@@ -78,7 +78,10 @@ export function TableVisibilityToggle({ className, table, onUpdate }: Props) {
};
return (
- <Tooltip label={isHidden ? t`Unhide table` : t`Hide table`}>
+ <Tooltip
+ label={isHidden ? t`Unhide table` : t`Hide table`}
+ position="right"
+ >
<ActionIcon
variant="subtle"
aria-label={isHidden ? t`Unhide table` : t`Hide table`}
diff --git a/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/premium.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/premium.unit.spec.tsx
index bd107a4ce01..a566cf8e948 100644
--- a/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/premium.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/premium.unit.spec.tsx
@@ -103,6 +103,14 @@ describe("QuestionInfoSidebar > premium", () => {
});
describe("for admins", () => {
+ beforeEach(() => {
+ jest.useFakeTimers();
+ });
+
+ afterEach(() => {
+ jest.useRealTimers();
+ });
+
it("should show tabs for Overview, History, and Relationships, and a link for Insights", async () => {
setupEnterprise({ user: { is_superuser: true } });
const tabs = await screen.findAllByRole("tab");
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.config.tsx b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.config.tsx
index 02f0b7e3fb0..3e01b4376b1 100644
--- a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.config.tsx
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.config.tsx
@@ -13,6 +13,8 @@ import TooltipStyles from "./Tooltip.module.css";
const ARROW_WIDTH = 9;
const ARROW_SIZE = ARROW_WIDTH / Math.SQRT2;
const ARROW_TO_TARGET_GAP = 8;
+// Long enough for the pointer to cross the gap from the target onto the tooltip.
+export const TOOLTIP_CLOSE_DELAY_MS = 100;
export const tooltipOverrides: MantineThemeOverride["components"] = {
Tooltip: Tooltip.extend({
@@ -37,6 +39,7 @@ export const tooltipOverrides: MantineThemeOverride["components"] = {
// sets the status synchronously instead.
duration: isTest ? 0 : 200,
},
+ closeDelay: TOOLTIP_CLOSE_DELAY_MS,
events: {
hover: true,
focus: true,
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.mdx b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.mdx
index 8fcdf2e17de..cab7b382daa 100644
--- a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.mdx
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.mdx
@@ -13,6 +13,10 @@ Our themed wrapper around [Mantine Tooltip](https://mantine.dev/core/tooltip/).
- [Mantine Tooltip Docs](https://mantine.dev/core/tooltip/)
+## Behaviour
+
+A tooltip opened by hover stays open while the pointer is on it, so its content can be selected and links in it clicked ([WCAG 1.4.13](https://www.w3.org/WAI/WCAG22/Understanding/content-on-hover-or-focus.html)). It closes shortly after the pointer leaves both the target and the tooltip. Tooltips with a controlled `opened` prop don't take pointer events.
+
## Examples
<Canvas of={TooltipStories.Default} />
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.module.css b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.module.css
index 58d1d78c5ce..8f470cb30e0 100644
--- a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.module.css
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.module.css
@@ -12,6 +12,11 @@
overflow-wrap: anywhere;
}
+.tooltip[data-hoverable] {
+ /* Let the pointer move onto an open tooltip without closing it (WCAG 1.4.13). */
+ pointer-events: auto;
+}
+
.arrow {
/*
* Disabling the clip-path property to prevent the arrow from being cut off
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsx b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsx
index 5cd847fdec9..99b47ff722b 100644
--- a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsx
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsx
@@ -1,4 +1,8 @@
-import { Tooltip as MantineTooltip, type TooltipProps } from "@mantine/core";
+import {
+ Tooltip as MantineTooltip,
+ type TooltipProps,
+ useProps,
+} from "@mantine/core";
import {
type PropsWithChildren,
createContext,
@@ -7,6 +11,9 @@ import {
useMemo,
} from "react";
+import { useIsTransitionOpen } from "./use-is-transition-open";
+import { useTooltipEventIsolation } from "./use-tooltip-event-isolation";
+
const TooltipPortalTargetContext = createContext<HTMLElement | null>(null);
export function TooltipPortalTargetProvider({
@@ -21,18 +28,44 @@ export function TooltipPortalTargetProvider({
}
const TooltipImpl = forwardRef<HTMLDivElement, TooltipProps>(
- function TooltipImpl({ portalProps, ...props }, ref) {
+ function TooltipImpl(props, ref) {
+ const { label, portalProps, transitionProps, mod, ...rest } = useProps(
+ "Tooltip",
+ {},
+ props,
+ );
const contextTarget = useContext(TooltipPortalTargetContext);
+ const callerPortalTarget = props.portalProps?.target;
const resolvedPortalProps = useMemo(
() =>
- contextTarget && portalProps?.target == null
+ contextTarget && callerPortalTarget == null
? { ...portalProps, target: contextTarget }
: portalProps,
- [contextTarget, portalProps],
+ [contextTarget, callerPortalTarget, portalProps],
);
+ const isControlled = rest.opened !== undefined;
+ const { isOpen, transitionProps: resolvedTransitionProps } =
+ useIsTransitionOpen(transitionProps);
+
+ const isHoverable = isOpen && !isControlled;
+
+ const { tooltipProps, labelProps } = useTooltipEventIsolation(rest);
+
return (
- <MantineTooltip {...props} portalProps={resolvedPortalProps} ref={ref} />
+ <MantineTooltip
+ {...rest}
+ {...tooltipProps}
+ // The delay only gives the pointer time to reach the tooltip. Mantine
+ // still opens a disabled one invisibly, and while open it takes the
+ // Escape key, so it shouldn't linger.
+ closeDelay={rest.disabled ? 0 : rest.closeDelay}
+ label={<div {...labelProps}>{label}</div>}
+ mod={[{ hoverable: isHoverable }, mod]}
+ portalProps={resolvedPortalProps}
+ transitionProps={resolvedTransitionProps}
+ ref={ref}
+ />
);
},
);
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.unit.spec.tsx b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.unit.spec.tsx
new file mode 100644
index 00000000000..d751700272d
--- /dev/null
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.unit.spec.tsx
@@ -0,0 +1,203 @@
+import userEvent from "@testing-library/user-event";
+import { useState } from "react";
+
+import { act, fireEvent, render, screen, waitFor } from "__support__/ui";
+
+import { Tooltip, TooltipPortalTargetProvider } from "./Tooltip";
+
+// Well past the close delay and the fade-out, so a tooltip that's going to
+// close has gone.
+const LONGER_THAN_CLOSE_MS = 1000;
+
+const setupUser = () =>
+ userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+
+const FADE_DURATION_MS = 200;
+
+const setup = () => {
+ const user = setupUser();
+ render(
+ <Tooltip
+ label="Tooltip content"
+ transitionProps={{ duration: FADE_DURATION_MS }}
+ >
+ <button>Target</button>
+ </Tooltip>,
+ );
+ return { user };
+};
+
+const ISOLATED_EVENTS = [
+ { type: "click", fire: fireEvent.click },
+ { type: "dblclick", fire: fireEvent.dblClick },
+ { type: "contextmenu", fire: fireEvent.contextMenu },
+ { type: "mousedown", fire: fireEvent.mouseDown },
+ { type: "mouseup", fire: fireEvent.mouseUp },
+ { type: "pointerdown", fire: fireEvent.pointerDown },
+ { type: "pointerup", fire: fireEvent.pointerUp },
+ { type: "touchstart", fire: fireEvent.touchStart },
+];
+
+const setupEventIsolation = () => {
+ const onParentEvent = jest.fn<void, [string]>();
+ const recordType = (event: { type: string }) => onParentEvent(event.type);
+
+ render(
+ <div
+ onClick={recordType}
+ onDoubleClick={recordType}
+ onContextMenu={recordType}
+ onMouseDown={recordType}
+ onMouseUp={recordType}
+ onPointerDown={recordType}
+ onPointerUp={recordType}
+ onTouchStart={recordType}
+ >
+ <Tooltip label="Tooltip content" opened>
+ <button>Target</button>
+ </Tooltip>
+ </div>,
+ );
+
+ return { onParentEvent };
+};
+
+describe("Tooltip", () => {
+ beforeEach(() => {
+ jest.useFakeTimers();
+ });
+
+ afterEach(() => {
+ jest.useRealTimers();
+ });
+
+ it("stays open while the pointer is over the tooltip and closes when it leaves", async () => {
+ const { user } = setup();
+ const target = screen.getByRole("button", { name: "Target" });
+
+ await user.hover(target);
+ const tooltip = await screen.findByRole("tooltip");
+ await waitFor(() => expect(tooltip).toHaveAttribute("data-hoverable"));
+
+ await user.unhover(target);
+ await user.hover(tooltip);
+ act(() => jest.advanceTimersByTime(LONGER_THAN_CLOSE_MS));
+ expect(screen.getByRole("tooltip")).toBeInTheDocument();
+
+ await user.unhover(tooltip);
+ // While it fades out, it lets the pointer through to what's underneath.
+ await waitFor(() => {
+ expect(tooltip).not.toHaveAttribute("data-hoverable");
+ });
+ expect(tooltip).toBeInTheDocument();
+ await waitFor(() => {
+ expect(screen.queryByRole("tooltip")).not.toBeInTheDocument();
+ });
+ });
+
+ it("closes when the pointer leaves the target without moving onto the tooltip", async () => {
+ const { user } = setup();
+ const target = screen.getByRole("button", { name: "Target" });
+
+ await user.hover(target);
+ expect(await screen.findByRole("tooltip")).toBeInTheDocument();
+
+ await user.unhover(target);
+ await waitFor(() => {
+ expect(screen.queryByRole("tooltip")).not.toBeInTheDocument();
+ });
+ });
+
+ it.each(ISOLATED_EVENTS)(
+ "lets $type on the target reach its parents",
+ async ({ type, fire }) => {
+ const { onParentEvent } = setupEventIsolation();
+ await screen.findByRole("tooltip");
+
+ fire(screen.getByRole("button", { name: "Target" }));
+ expect(onParentEvent).toHaveBeenCalledWith(type);
+ },
+ );
+
+ it.each(ISOLATED_EVENTS)(
+ "keeps $type on the tooltip from reaching the target's parents",
+ async ({ type, fire }) => {
+ const { onParentEvent } = setupEventIsolation();
+ const tooltip = await screen.findByRole("tooltip");
+
+ fire(screen.getByText("Tooltip content"));
+ fire(tooltip);
+ expect(onParentEvent).not.toHaveBeenCalledWith(type);
+ },
+ );
+
+ it("still stops events on the tooltip reaching the target's parents when the caller handles them", async () => {
+ const user = setupUser();
+ const onParentDoubleClick = jest.fn<void, []>();
+ const onTooltipDoubleClick = jest.fn<void, []>();
+ render(
+ <div onDoubleClick={onParentDoubleClick}>
+ <Tooltip label="Tooltip content" onDoubleClick={onTooltipDoubleClick}>
+ <button>Target</button>
+ </Tooltip>
+ </div>,
+ );
+
+ await user.hover(screen.getByRole("button", { name: "Target" }));
+ await user.dblClick(await screen.findByRole("tooltip"));
+ expect(onTooltipDoubleClick).toHaveBeenCalledTimes(1);
+ expect(onParentDoubleClick).not.toHaveBeenCalled();
+ });
+
+ it("closes straight away when disabled and the pointer leaves the target", async () => {
+ const user = setupUser();
+ render(
+ <div>
+ <Tooltip label="Tooltip content" disabled>
+ <button>Target</button>
+ </Tooltip>
+ <span>Elsewhere</span>
+ </div>,
+ );
+ const target = screen.getByRole("button", { name: "Target" });
+
+ await user.hover(target);
+ expect(target).toHaveAttribute("aria-describedby");
+
+ await user.hover(screen.getByText("Elsewhere"));
+ expect(target).not.toHaveAttribute("aria-describedby");
+ });
+
+ it("doesn't catch the pointer when its owner controls whether it's open", async () => {
+ const TooltipWithTarget = ({ opened }: { opened: boolean }) => (
+ <Tooltip label="Tooltip content" opened={opened}>
+ <button>Target</button>
+ </Tooltip>
+ );
+ const { rerender } = render(<TooltipWithTarget opened={false} />);
+ rerender(<TooltipWithTarget opened />);
+
+ const tooltip = await screen.findByRole("tooltip");
+ act(() => jest.advanceTimersByTime(LONGER_THAN_CLOSE_MS));
+ expect(tooltip).not.toHaveAttribute("data-hoverable");
+ });
+
+ it("renders inside the portal target from context", async () => {
+ const TooltipInsideTarget = () => {
+ const [target, setTarget] = useState<HTMLElement | null>(null);
+ return (
+ <div ref={setTarget} data-testid="portal-target">
+ <TooltipPortalTargetProvider target={target}>
+ <Tooltip label="Tooltip content" opened>
+ <button>Target</button>
+ </Tooltip>
+ </TooltipPortalTargetProvider>
+ </div>
+ );
+ };
+ render(<TooltipInsideTarget />);
+
+ const tooltip = await screen.findByRole("tooltip");
+ expect(screen.getByTestId("portal-target")).toContainElement(tooltip);
+ });
+});
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/use-is-transition-open.ts b/frontend/src/metabase/ui/components/overlays/Tooltip/use-is-transition-open.ts
new file mode 100644
index 00000000000..03bf157fe57
--- /dev/null
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/use-is-transition-open.ts
@@ -0,0 +1,28 @@
+import type { TransitionOverride } from "@mantine/core";
+import { useMemo, useState } from "react";
+
+/**
+ * Tracks whether the tooltip is shown or fading in. Returns transition props
+ * to pass on to Mantine, which still call any `onEnter`/`onExit` given.
+ * Stays `false` for a tooltip that mounts already open.
+ */
+export function useIsTransitionOpen(
+ transitionProps: TransitionOverride | undefined,
+) {
+ const [isOpen, setIsOpen] = useState(false);
+ const resolvedTransitionProps = useMemo(
+ () => ({
+ ...transitionProps,
+ onEnter: () => {
+ setIsOpen(true);
+ transitionProps?.onEnter?.();
+ },
+ onExit: () => {
+ setIsOpen(false);
+ transitionProps?.onExit?.();
+ },
+ }),
+ [transitionProps],
+ );
+ return { isOpen, transitionProps: resolvedTransitionProps };
+}
diff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/use-tooltip-event-isolation.ts b/frontend/src/metabase/ui/components/overlays/Tooltip/use-tooltip-event-isolation.ts
new file mode 100644
index 00000000000..bf6bf2af4b2
--- /dev/null
+++ b/frontend/src/metabase/ui/components/overlays/Tooltip/use-tooltip-event-isolation.ts
@@ -0,0 +1,99 @@
+import type { TooltipProps } from "@mantine/core";
+import { type ComponentPropsWithRef, type SyntheticEvent, useRef } from "react";
+
+const stopPropagation = (event: SyntheticEvent) => event.stopPropagation();
+
+type IsolatedTooltipProps = Pick<
+ TooltipProps,
+ | "onDoubleClick"
+ | "onContextMenu"
+ | "onPointerUp"
+ | "onTouchStart"
+ | "onPointerDown"
+ | "onClickCapture"
+ | "onMouseDownCapture"
+ | "onMouseUpCapture"
+>;
+
+type TooltipEventIsolation = {
+ /** Spread onto the tooltip, after the caller's own props. */
+ tooltipProps: IsolatedTooltipProps;
+ /** Spread onto an element wrapping the tooltip's label. */
+ labelProps: Pick<
+ ComponentPropsWithRef<"div">,
+ "ref" | "onClick" | "onMouseDown" | "onMouseUp"
+ >;
+};
+
+/**
+ * Stops presses, clicks and touches on the tooltip from reaching the trigger's
+ * React ancestors. Events on the trigger itself are untouched, and any of
+ * these handlers the caller passed in still run.
+ */
+export function useTooltipEventIsolation(
+ handlers: IsolatedTooltipProps,
+): TooltipEventIsolation {
+ const labelRef = useRef<HTMLDivElement>(null);
+
+ // Mantine sends `onPointerDown` to the trigger as well as the tooltip.
+ const stopPropagationUnlessOnTrigger = (event: SyntheticEvent) => {
+ const isOnTooltip =
+ labelRef.current != null &&
+ event.currentTarget.contains(labelRef.current);
+ if (isOnTooltip) {
+ event.stopPropagation();
+ }
+ };
+
+ // Mantine and floating-ui use the tooltip's `onClick`, `onMouseDown` and
+ // `onMouseUp`, so the label stops those for its content and this covers the
+ // padding and arrow.
+ const stopPropagationOutsideLabel = (event: SyntheticEvent) => {
+ const isInLabel =
+ event.target instanceof Node && labelRef.current?.contains(event.target);
+ if (!isInLabel) {
+ event.stopPropagation();
+ }
+ };
+
+ return {
+ tooltipProps: {
+ onDoubleClick: withHandler(stopPropagation, handlers.onDoubleClick),
+ onContextMenu: withHandler(stopPropagation, handlers.onContextMenu),
+ onPointerUp: withHandler(stopPropagation, handlers.onPointerUp),
+ onTouchStart: withHandler(stopPropagation, handlers.onTouchStart),
+ onPointerDown: withHandler(
+ stopPropagationUnlessOnTrigger,
+ handlers.onPointerDown,
+ ),
+ onClickCapture: withHandler(
+ stopPropagationOutsideLabel,
+ handlers.onClickCapture,
+ ),
+ onMouseDownCapture: withHandler(
+ stopPropagationOutsideLabel,
+ handlers.onMouseDownCapture,
+ ),
+ onMouseUpCapture: withHandler(
+ stopPropagationOutsideLabel,
+ handlers.onMouseUpCapture,
+ ),
+ },
+ labelProps: {
+ ref: labelRef,
+ onClick: stopPropagation,
+ onMouseDown: stopPropagation,
+ onMouseUp: stopPropagation,
+ },
+ };
+}
+
+function withHandler<E extends SyntheticEvent>(
+ isolate: (event: E) => void,
+ handler: ((event: E) => void) | undefined,
+) {
+ return (event: E) => {
+ handler?.(event);
+ isolate(event);
+ };
+}