The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
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.tsindex 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.jsindex 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.tsxindex 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.tsxindex 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}><IconclassName={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.tsxindex 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"+ ><ActionIconvariant="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.tsxindex 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"+ ><ActionIconvariant="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.tsxindex 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.tsxindex 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.mdxindex 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.cssindex 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 offdiff --git a/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsx b/frontend/src/metabase/ui/components/overlays/Tooltip/Tooltip.tsxindex 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+ };+}