Skip to content

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

TypeScript

fix(RadialChart): honor interactive for touch input (#9741)

zakelstormda85f28eddd4
diff --git a/packages/lab/src/Radial/RadialChart.tsx b/packages/lab/src/Radial/RadialChart.tsx
index f2a027c975..340ad8ad09 100644
--- a/packages/lab/src/Radial/RadialChart.tsx
+++ b/packages/lab/src/Radial/RadialChart.tsx
@@ -13,6 +13,7 @@
* hidden data table (slices in pie mode, axis values in spider mode).
*/
+import * as stylex from '@stylexjs/stylex';
import {
type ReactNode,
useMemo,
@@ -74,6 +75,12 @@ export interface RadialChartProps {
*/
const MAX_TABLE_POINTS = 100;
+const styles = stylex.create({
+ interactive: {
+ touchAction: 'none',
+ },
+});
+
/**
* Row header for a spider-mode table row: the first string field in the row
* (the same heuristic RadialArea uses to match its `dataKey`), else the index.
@@ -110,6 +117,7 @@ export function RadialChart({
labelKey,
innerRadius: innerRadiusFraction = 0,
padAngle = 0.02,
+ interactive = false,
label,
children,
}: RadialChartProps) {
@@ -225,10 +233,21 @@ export function RadialChart({
innerRadius: innerRadiusPx,
data,
mode,
+ interactive,
...spiderCtx,
...pieCtx,
}),
- [cx, cy, outerRadius, innerRadiusPx, data, mode, spiderCtx, pieCtx],
+ [
+ cx,
+ cy,
+ outerRadius,
+ innerRadiusPx,
+ data,
+ mode,
+ interactive,
+ spiderCtx,
+ pieCtx,
+ ],
);
const accessibleLabel =
@@ -248,7 +267,10 @@ export function RadialChart({
data.length * axes.length <= MAX_TABLE_POINTS;
return (
- <div ref={containerRef} style={{width: '100%'}}>
+ <div
+ ref={containerRef}
+ {...stylex.props(interactive && styles.interactive)}
+ style={{width: '100%'}}>
{containerWidth > 0 && (
<svg
role="img"
diff --git a/packages/lab/src/Radial/RadialContext.ts b/packages/lab/src/Radial/RadialContext.ts
index 246c85e347..a9914d41a2 100644
--- a/packages/lab/src/Radial/RadialContext.ts
+++ b/packages/lab/src/Radial/RadialContext.ts
@@ -8,10 +8,16 @@
import {createContext, useContext} from 'react';
import type {RadialContext} from './types';
-const RadialCtx = createContext<RadialContext | null>(null);
+const RadialCtx = createContext<
+ (RadialContext & {interactive?: boolean}) | null
+>(null);
export const RadialProvider = RadialCtx.Provider;
+export function useRadialInteractive(): boolean {
+ return useContext(RadialCtx)?.interactive ?? false;
+}
+
/** Access the radial chart context. Throws if used outside RadialChart. */
export function useRadial(): RadialContext {
const ctx = useContext(RadialCtx);
diff --git a/packages/lab/src/Radial/RadialTooltip.test.tsx b/packages/lab/src/Radial/RadialTooltip.test.tsx
index c78a1e4a8f..9a78cda09d 100644
--- a/packages/lab/src/Radial/RadialTooltip.test.tsx
+++ b/packages/lab/src/Radial/RadialTooltip.test.tsx
@@ -4,14 +4,13 @@
* @file RadialTooltip.test.tsx
* @input RadialTooltip inside pie- and spider-mode RadialCharts (600x400 →
* outerRadius=160)
- * @output Mount smoke coverage only: the pointer pipeline needs
- * createSVGPoint/getScreenCTM, which jsdom does not implement, so hover
- * behavior is not exercised here. Asserts the event-capture circle mounts.
+ * @output Mount and pointer interaction coverage with stubbed SVG coordinate
+ * APIs; native touch scrolling requires browser evidence.
* @position Colocated test for RadialTooltip.tsx
*/
import {describe, it, expect, beforeEach, afterEach, vi} from 'vitest';
-import {render, act} from '@testing-library/react';
+import {render, screen, fireEvent, act} from '@testing-library/react';
import {RadialChart} from './RadialChart';
import {RadialSlice} from './RadialSlice';
import {RadialTooltip} from './RadialTooltip';
@@ -52,6 +51,67 @@ function reportWidth(width: number) {
});
}
+function tooltipChart(interactive?: boolean) {
+ return (
+ <RadialChart
+ data={pieData}
+ valueKey="revenue"
+ labelKey="region"
+ interactive={interactive}>
+ <RadialSlice colors={['#111111', '#222222']} />
+ <RadialTooltip
+ render={datum => (
+ <span data-testid="tooltip-datum">
+ {datum.label}: {datum.value}
+ </span>
+ )}
+ />
+ </RadialChart>
+ );
+}
+
+function preparePointerTarget(container: HTMLElement) {
+ reportWidth(600);
+ const svg = container.querySelector('svg');
+ const capture = container.querySelector('circle[fill="transparent"]');
+ if (!svg || !capture) {
+ throw new Error('Expected a measured chart with a tooltip target');
+ }
+
+ // jsdom has no SVG coordinate transforms; use screen coordinates as SVG units.
+ Object.defineProperties(svg, {
+ createSVGPoint: {
+ value: () => ({
+ x: 0,
+ y: 0,
+ matrixTransform() {
+ return {x: this.x, y: this.y};
+ },
+ }),
+ },
+ getScreenCTM: {value: () => ({inverse: () => ({})})},
+ });
+ return capture;
+}
+
+const firstSlice = {clientX: 400, clientY: 200};
+const secondSlice = {clientX: 200, clientY: 200};
+
+function expectIgnoredTouch(capture: Element) {
+ const pointerType = 'touch';
+ expect(
+ fireEvent.pointerDown(capture, {
+ ...firstSlice,
+ pointerType,
+ cancelable: true,
+ }),
+ ).toBe(true);
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ fireEvent.pointerMove(capture, {...secondSlice, pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ fireEvent.pointerUp(capture, {pointerType});
+}
+
describe('RadialTooltip', () => {
it('mounts in a pie-mode chart and renders the event-capture circle', () => {
const {container} = render(
@@ -68,6 +128,86 @@ describe('RadialTooltip', () => {
expect(capture).toHaveAttribute('r', '170');
});
+ it('leaves touch input alone by default', () => {
+ const {container} = render(tooltipChart());
+ expectIgnoredTouch(preparePointerTarget(container));
+ });
+
+ it('leaves touch input alone when interactive is false', () => {
+ const {container} = render(tooltipChart(false));
+ expectIgnoredTouch(preparePointerTarget(container));
+ });
+
+ it('scrubs with touch only after contact and dismisses on release', () => {
+ const {container} = render(tooltipChart(true));
+ const capture = preparePointerTarget(container);
+ const pointerType = 'touch';
+
+ fireEvent.pointerMove(capture, {...firstSlice, pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ expect(
+ fireEvent.pointerDown(capture, {
+ ...firstSlice,
+ pointerType,
+ cancelable: true,
+ }),
+ ).toBe(false);
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('NA: 500');
+ fireEvent.pointerMove(capture, {...secondSlice, pointerType});
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('EU: 300');
+ fireEvent.pointerUp(capture, {pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ fireEvent.pointerMove(capture, {...firstSlice, pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ });
+
+ it('ends an active touch on disable without reviving it on re-enable', () => {
+ const {container, rerender} = render(tooltipChart(true));
+ const capture = preparePointerTarget(container);
+ const pointerType = 'touch';
+
+ fireEvent.pointerDown(capture, {...firstSlice, pointerType});
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('NA: 500');
+ rerender(tooltipChart(false));
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ fireEvent.pointerMove(capture, {...secondSlice, pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+
+ rerender(tooltipChart(true));
+ fireEvent.pointerMove(capture, {...secondSlice, pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ fireEvent.pointerDown(capture, {...secondSlice, pointerType});
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('EU: 300');
+ fireEvent.pointerUp(capture, {pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ });
+
+ it('preserves mouse hover across every interactive setting', () => {
+ const {container, rerender} = render(tooltipChart());
+ const capture = preparePointerTarget(container);
+ const pointerType = 'mouse';
+ fireEvent.pointerMove(capture, {...firstSlice, pointerType});
+
+ for (const interactive of [undefined, true, false]) {
+ rerender(tooltipChart(interactive));
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('NA: 500');
+ expect(
+ fireEvent.pointerDown(capture, {
+ ...firstSlice,
+ pointerType,
+ cancelable: true,
+ }),
+ ).toBe(true);
+ fireEvent.pointerUp(capture, {pointerType});
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('NA: 500');
+ fireEvent.pointerMove(capture, {...secondSlice, pointerType});
+ expect(screen.getByTestId('tooltip-datum')).toHaveTextContent('EU: 300');
+ fireEvent.pointerMove(capture, {...firstSlice, pointerType});
+ }
+ fireEvent.pointerLeave(capture, {pointerType});
+ expect(screen.queryByTestId('tooltip-datum')).not.toBeInTheDocument();
+ });
+
it('mounts in a spider-mode chart without crashing', () => {
const {container} = render(
<RadialChart
diff --git a/packages/lab/src/Radial/RadialTooltip.tsx b/packages/lab/src/Radial/RadialTooltip.tsx
index de70180add..c82d9d23be 100644
--- a/packages/lab/src/Radial/RadialTooltip.tsx
+++ b/packages/lab/src/Radial/RadialTooltip.tsx
@@ -12,10 +12,16 @@
'use client';
-import {useState, useCallback, useRef, type ReactNode} from 'react';
+import {
+ useState,
+ useCallback,
+ useLayoutEffect,
+ useRef,
+ type ReactNode,
+} from 'react';
import {createPortal} from 'react-dom';
import {useLayer} from '@astryxdesign/core/Layer';
-import {useRadial} from './RadialContext';
+import {useRadial, useRadialInteractive} from './RadialContext';
export interface RadialTooltipDatum {
/** The slice key or axis name */
@@ -79,6 +85,7 @@ export function RadialTooltip({
angleByAxis,
axisDomains,
} = useRadial();
+ const interactive = useRadialInteractive();
const [hoverState, setHoverState] = useState<RadialTooltipDatum | null>(null);
const [tooltipCoords, setTooltipCoords] = useState({x: 0, y: 0});
@@ -87,6 +94,7 @@ export function RadialTooltip({
const active = useRef(false);
const layer = useLayer({mode: 'fixed'});
+ const {hide} = layer;
// Resolve SVG + portal target from the <g> mount
const gRef = useCallback((el: SVGGElement | null) => {
@@ -220,24 +228,24 @@ export function RadialTooltip({
// Touch: tap to show, drag to scrub
const handlePointerDown = useCallback(
(e: React.PointerEvent<SVGCircleElement>) => {
- if (e.pointerType !== 'mouse') {
+ if (interactive && e.pointerType !== 'mouse') {
e.preventDefault();
active.current = true;
updateTooltip(e);
}
},
- [updateTooltip],
+ [interactive, updateTooltip],
);
// Mouse: hover. Touch: drag (only if active).
const handlePointerMove = useCallback(
(e: React.PointerEvent<SVGCircleElement>) => {
- if (e.pointerType !== 'mouse' && !active.current) {
+ if (e.pointerType !== 'mouse' && (!interactive || !active.current)) {
return;
}
updateTooltip(e);
},
- [updateTooltip],
+ [interactive, updateTooltip],
);
// Touch: lift to dismiss
@@ -245,9 +253,16 @@ export function RadialTooltip({
if (active.current) {
active.current = false;
setHoverState(null);
- layer.hide();
+ hide();
}
- }, [layer]);
+ }, [hide]);
+
+ // Sync the top-layer popover with touch interaction availability.
+ useLayoutEffect(() => {
+ if (!interactive) {
+ handlePointerUp();
+ }
+ }, [interactive, handlePointerUp]);
const handlePointerLeave = useCallback(() => {
if (!active.current) {
@@ -287,7 +302,6 @@ export function RadialTooltip({
cy={cy}
r={radius + 10}
fill="transparent"
- style={{touchAction: 'none'}}
onPointerDown={handlePointerDown}
onPointerMove={handlePointerMove}
onPointerUp={handlePointerUp}