Skip to main content

Line Chart

A line chart for trends over a continuous x axis, time above all. Compose the gridlines, axes, and one LineChart.Line per series inside LineChart.Root.

When to use

  • Show how a value changes over time, such as latency percentiles, request rates, or resource usage.
  • Show whether several series move together.
  • Plot long series with many points. See High-density series.
  • Prefer BarChart to compare discrete categories by bar length from zero.
  • Prefer AreaChart for a total and its parts over time: stacked areas show how the parts sum to the total.
  • Prefer ScatterPlot to show how two measures correlate when the order of the points does not matter.

Curves, markers, and shapes

curve controls interpolation between points: "linear" (the default), "monotone" (smoothed without overshooting the data), or "step". markers draws a dot with a surface ring at each point. Markers auto-hide when points get denser than ~12px apart, so a chart that grows dense never turns to gravel. shape picks the marker glyph per series, and the hover dot and legend key wear it too.

The glyphs are "circle", "square", "triangle", "diamond", "triangle-down", "plus", "cross", and "star". Every series wears "circle" until you set shape, and the chart never picks a glyph for you. Below, last week sets shape="square", so it wears a square on its markers, in the legend, and under the crosshair. That second channel matters where color can't carry identity alone: a reader with a color vision deficiency, a grayscale print or export, forced-colors mode. All chart families share the glyph set; Point shapes on the scatter plot page is the full treatment.

String x values put the chart on a "point" scale: evenly spaced categorical positions with no band thickness.

High-density series

Rendering decimates each series to its min/max per pixel column, so series of 100,000+ points stay smooth. This chart plots a 50,000-point seeded pseudo-random walk on a "linear" x scale. Past 4 points per device pixel, the engine decimates each series to its min/max per device-pixel column, so a redraw costs O(plot width), not O(points). It is also visually lossless, because a line through every intermediate value paints the same column of pixels anyway. The idle chart costs zero CPU: there is no always-on render loop; every mutation coalesces into a single requestAnimationFrame commit. And hover never repaints the chart: the crosshair, active-point markers, and tooltip are DOM overlay elements moved with transforms.

Gaps and connectNulls

null and missing values render as gaps by default, and gaps are the honest default: a gap says "we did not measure this," where a bridged line invents values that were never recorded. Pass connectNulls to join across missing values only when a gap genuinely means "unchanged" rather than "unknown." Gapped values read as an em dash in the tooltip and as "no data" in keyboard announcements.

Reference lines

LineChart.ReferenceLine paints a dashed horizontal marker at a y value (an SLO threshold, a budget, a limit) in the neutral reference color, with an optional label above its right end. Two conventions worth copying here: a series that carries bad meaning (an error rate) wears the functional color="danger", and yDomain anchors the rate at zero so the distance to the threshold reads truthfully.

Linked charts

The active position is controllable: pass activeIndex and onActiveIndexChange to share one crosshair across charts plotted over the same rows (the dashboard "linked crosshair" pattern). Hover or arrow through either chart and both move together, so a latency spike and its error spike line up without eyeballing timestamps.

Live data

For streaming data, append points to the end of a sliding window and let the chart supply the motion. When appends arrive at a steady rate, the x domain scrolls at one constant speed. The chart measures the time between appends and glides the domain to each new target over that interval, so back-to-back appends read as one continuous scroll, never ease-stop-jump ticks. A point that arrives early or late changes the speed from the current position, with no jump. As the window slides, tick labels fade in and out per label (gridlines share their labels' fade) instead of popping between tick sets. prefers-reduced-motion snaps everything: appends land instantly, with no glide and no fades.

Motion plays only while the chart is on screen. A chart that is near the viewport but off screen paints each append settled, with no glide. On a "point" scale (string x values), a window that slides to new categories snaps each line to its new values. The y axis still glides.

This demo appends one point every 150ms to a sliding 240-point window, dropping the oldest point each time. Both series derive from pure sine compositions over a tick counter and a fixed epoch (a slow drift plus faster waves), so the demo renders deterministically; a real chart would append measurements as they arrive.

Copy as markdown

Every chart renders its data as real DOM once it takes focus: the screen-reader data table carries exact machine-readable values (an ISO 8601 timestamp in <time dateTime> for every x on a time scale, and raw numbers in data-value), so an agent that focuses the chart gets the series, not a picture of it. LineChart.CopyButton is the hand-off counterpart: one click copies the current rows to the clipboard as a GitHub-flavored markdown table, one x column plus one column per series in paint order. The output is machine-stable (an ISO 8601 timestamp for every x on a time scale, plain un-separated numbers, an em dash for gaps), so it stays parseable wherever it lands: Slack, an issue, a spreadsheet, an LLM chat.

The button renders in flow where composed; Root is relatively positioned, so className can dock it over a corner instead.

Lists of charts

A page of 100 charts pays for the handful a reader can see. A dormant LineChart.Root is a shell: the plot box, the named interaction overlay, and its screen-reader description. It holds no paint surface and no engine. The chart activates when it comes within one viewport of the visible area, takes focus, or prints. Activation runs outside React, on-screen charts first, in slices of a few milliseconds with a yield to the browser between them. Each chart paints in the task that activates it. A print paints every chart settled, with tick labels and gridlines at full opacity. The hover layers and the tooltip surface mount on the first hover. The screen-reader data table waits for focus alone: it mounts once a reader tabs into the chart, so a page of sparklines holds no hidden tables until a reader asks for one. Add content-visibility: auto to your list's cards as a complement: it skips style and layout for offscreen cards, and the chart's own gate already skips paint.

Wrap a list of interactive charts in LineChart.List. The charts inside share one role="status" live region, so a page of 100 charts mounts one region instead of one per chart, plus one for each LineChart.CopyButton. Each chart keeps its own tooltip, description, and data table. Charts of different families can share one List, so one LineChart.List can hold a grid of bar, line, area, and scatter charts. A static chart has no tooltip and no live region, so a list of sparklines needs no List.

Modes

mode sets how much of the chart's contract a Root exposes. Pick by what a reader does with the chart.

modeUse it forA reader gets
"interactive" (default)A chart a reader explores: a dashboard panel, a detail page, a report with a question behind it.A named role="application" Tab stop, hover and keyboard point cursor, a tooltip readout, polite announcements, and an sr-only data table on focus.
"static"A chart a reader glances at while the exact values sit beside it: a sparkline in a table row or a card, a trend in a print report.A named role="img" with a text description (kind, count, range, series), no Tab stop, no hover, no tooltip, no table. animate defaults to false.
"decorative"A placeholder whose values are not information: synthetic a line behind an empty state, a hero backdrop.Nothing: hidden from assistive technology, out of the tab order, inert, every series in one neutral fill.

Noninteractive is not decorative. A sparkline beside a total still tells a reader when activity happened and how it varied, so it keeps a name and a description; only its values live in the text beside it. One hundred sparklines in a table as one hundred Tab stops is a focus order no reader wants, and a readout that only a pointer can reach fails WCAG 2.2 SC 2.1.1 (Keyboard), so "static" offers neither. A chart that is the only source of its values stays "interactive".

Static charts

Set mode="static" for a chart a reader glances at while the exact values sit beside it. The plot is a named role="img": it takes the same aria-label or aria-labelledby an interactive chart does, and its aria-describedby points at the description, so a screen reader hears the chart kind, the point count, the x range, and the series labels without a Tab stop. There is no interaction overlay: no hover band, no tooltip, no keyboard point cursor, no data table, and no live region, and a composed LineChart.Tooltip has no effect. Pointer events pass through to the row or card behind it. The series keep their colors. animate defaults to false, because a list of sparklines that each play a reveal as the reader scrolls is motion with no information in it; pass animate to play the reveal. The interaction props (activeIndex, onActiveIndexChange, onDatumActivate) are forbidden at the type level. The Sparklines in a List recipe is the worked example.

<div className="flex items-center gap-2">	<LineChart.Root		data={service.requests}		xKey="day"		mode="static"		aria-label={`Requests for ${service.name}, last 30 days`}		className="aspect-auto h-6 w-28"	>		<LineChart.Line dataKey="count" label="Requests" color="blue" />	</LineChart.Root>	<span className="text-muted text-xs tabular-nums">{compact(service.requestTotal)}</span></div>

Decorative charts

Set mode="decorative" to render the chart as a placeholder backdrop instead of real data: a synthetic line behind an empty state, an atmospheric hero graphic. A decorative chart keeps its visual rendering and animation but drops every layer that only makes sense for real data: it is hidden from assistive technology, removed from the tab order, and inert to pointer and keyboard, with no hover band, tooltip, sr-only data table, or live region. Because the values aren't information, mode="decorative" is mutually exclusive with the accessible-name props (aria-label / aria-labelledby) and the interaction props (activeIndex, onActiveIndexChange, onDatumActivate); the type won't compile with both.

A decorative chart also drops the series colors. Every series paints --color-chart-decorative, one neutral fill that outranks a series' color. A backdrop carries no series identity, and a hue on values that are not information invites a reader to decode it.

That fill is what keeps an overlaid message readable. Empty.Description sits on text-muted, which measures 4.88:1 on a bare light card: 0.38 over the 4.5:1 floor for 14px text, so any tint under that copy spends the headroom. --color-chart-decorative is the darkest neutral step that still clears the floor in both themes: 4.56:1 in light and 4.93:1 in dark. The message needs no scrim behind it, no dimming, and no blur. Redeclare the token on the Root to retune the fill (className="[--color-chart-decorative:var(--color-neutral-100)]") and re-measure the copy against the value you pick.

Reach for mode="decorative" over hand-rolled inert + CSS: it removes the interaction overlay at the source, so consumers never target chart internals to neutralize it. Keep the real empty-state message as a sibling of the chart (not inside it) so screen readers still announce it; the decorative chart itself is silent.

mode="decorative" says the values are not information; it is not a disabled flag (a chart is not a form control). For real data a reader only glances at, use mode="static".

Composition

Compose the parts of a LineChart together to build your own:

LineChart.Root├── LineChart.Grid├── LineChart.XAxis├── LineChart.YAxis├── LineChart.Line (one per series)├── LineChart.ReferenceLine├── LineChart.Tooltip├── LineChart.Legend└── LineChart.CopyButton

The interaction layer ships with Root, and there is no part to add for it: a crosshair that snaps to the nearest x with an every-series tooltip, keyboard stepping, polite announcements, and a screen-reader description. The screen-reader data table mounts once the chart takes focus. If you remove a part, keyboard access to the data stays. Hover or focus the chart at the top of this page and use the arrow keys: the tooltip reads every series at the active x.

Compose LineChart.Legend on every multi-series chart. Series identity must never rely on color alone.

Wrap a list of Roots in LineChart.List so they share one live region:

LineChart.List└── LineChart.Root (one per chart)

Axes and scales

Lines encode value by vertical position along a shared y axis. This makes them the correct mark for trends over a continuous x.

The chart detects the x scale from the x value of the first row. Date values get a "time" scale with calendar-aware ticks, numbers get "linear", and strings get "point" (evenly spaced categories). Pass xScale when the detection is wrong. For example, epoch-millisecond numbers detect as "linear", so pass xScale="time" to read them as time.

Color and accessibility

A line is a part of the graphic that a reader needs to understand the chart. So WCAG 2.2 SC 1.4.11 Non-text Contrast asks for 3:1 between each line and the card behind it. Lines don't need 3:1 against each other or against the gridlines. In dark mode, every color name clears 3:1 on the card. In light mode, every name clears it except yellow (2.94:1). A 2px line carries less paint than a bar or an area, so give a line another name before you give it yellow.

Mantle doesn't promise that any set of names stays apart for a color-blind reader. Pick colors that differ in lightness as well as hue. When lines cross or run close together, give each line its own shape, as Curves, markers, and shapes does. The legend key and the hover dot always wear the glyph, and the point markers wear it when markers is on.

The Bar Chart page covers the rest: mantle's stance, what counts as an exemption under SC 1.4.11, and the eight-series guidance.

Keep a chart to eight series

A dozen lines in one plot is a tangle that no reader can follow. Rank the series by the window's total, keep the top seven, and sum the rest into one "Other" series. Give the Other line color="neutral", so it reads as the tail and not as one more series. The Bar Chart page has a worked fold.

Accessibility

Every interactive chart must have an accessible name: either a direct aria-label or an aria-labelledby reference to a visible title (preferred when the chart sits under a heading, so no duplicated text can drift). This is enforced at the type level: omitting both is a compile error, not a runtime warning. The name lands on the focusable interaction overlay, the chart's single named element (the paint surface itself is hidden from assistive technology, so the chart is never announced twice). A static chart names its plot role="img" instead and has no Tab stop. A decorative chart carries no real data, so it takes no accessible name and is hidden from assistive technology entirely.

The chart is a single tab stop with a full keyboard point cursor:

KeyBehavior
TabFocus the chart: one tab stop regardless of point count.
ArrowLeft / ArrowRightStep to the previous/next data point. When decimated, arrows stride by one device-pixel column of data, so a 50,000-point chart stays traversable in ~plot-width presses.
PageUp / PageDownJump forward/backward by 10% of the data.
Home / EndJump to the first/last point.
Enter / SpaceActivate the current point (fires onDatumActivate).
EscapeDismiss the crosshair and tooltip.

Escape, Enter, and Space act only while a point is active. An idle Escape therefore reaches the surface around the chart, such as a panel that closes on Escape. A held Enter or Space activates once, and a chord with Alt, Ctrl, or Meta passes through to the browser. With a pointer, only the primary button activates a point. In forced-colors mode, the focused chart shows a focus outline, and the crosshair and the hover dots stay visible.

Keyboard stepping announces the active point (the x value and every series value) through a debounced polite aria-live region, so rapid arrowing never floods the screen-reader queue. Announcements follow keyboard steps only: the chart doesn't announce a data update while the keyboard cursor rests on a point. When the labelFormat or valueFormat of a composed LineChart.Tooltip returns a string or a number, the announcement uses it. The data table keeps the default number format.

The overlay's aria-describedby points at a screen-reader description, data-slot="line-chart-description", so a screen reader hears what the chart holds when it takes focus: the chart kind, the number of data points, the x range from the first point to the last, the series labels, and the keyboard instructions. For example: "Line chart with 30 data points from Jul 1, 2026 to Jul 30, 2026. Series: Requests, Errors. Use the left and right arrow keys to move between data points, …". An empty chart reads "Line chart with no data." in place of the count and range. Server HTML carries the plain count alone. The range waits for hydration, because Intl output differs by locale, and the series labels register in layout effects, so both render on the client.

Every chart also renders a screen-reader-only data table once it takes focus: one column for the x value and one per series, bounded to the first 150 rows with a caption stating the summarization (an unbounded table at 100,000 rows would be unusable to assistive tech anyway). A LineChart.Root mounts dormant and engages once focus lands inside it (the overlay is the Tab stop, and a focusable part composed inside the Root, such as LineChart.CopyButton, counts too), and it never goes dormant again. Visibility paints the chart but never mounts the table. The Root stamps data-state="dormant", then data-state="engaged", and the table mounts with the flip, so a screen reader's table list names only the charts the reader has focused. The description above names what every chart holds, focused or not. Tooltips enhance, they never gate. The keyboard point cursor steps one point at a time, so it reaches every point. When the chart decimates (see High-density series), each arrow key press moves one device-pixel column. The cursor then reaches one point per column. The table holds the first 150 rows, and LineChart.CopyButton copies every row.

The table doubles as the chart's machine-readable surface. On a "time" scale, every row header carries its x (a Date, an epoch number, or a date string) as an ISO 8601 timestamp in <time dateTime>. Value cells carry the raw number in data-value, so agents and scrapers read precise data from the DOM without reverse-engineering locale formatting. A row whose x has no text form, such as null or a date that doesn't parse, shows an em dash. Assistive tech still hears the human-formatted text, and the table itself is addressable at data-slot="line-chart-data-table". To reach it, an agent focuses the chart (a scroll into view is not enough), then waits for data-state="engaged" on the Root. LineChart.CopyButton hands over the same rows as markdown with neither step.

The Bar Chart page lists the accessibility limits that every chart family shares, such as the pause control that a live chart needs from your page.

API Reference

LineChart.Line, LineChart.Grid, LineChart.XAxis, LineChart.YAxis, and LineChart.ReferenceLine are renderless: they register configuration with the Root, which paints everything on one surface: an <svg>. They accept no className and no DOM props. LineChart.Tooltip, LineChart.Legend, and LineChart.CopyButton are the parts that touch real DOM. The first two accept div props, and CopyButton accepts button props. LineChart.List also renders real DOM: a div around a list of Roots.

LineChart.Root

The root of a line chart: owns the data, the scales, the renderer, and the entire interaction contract. Renders a <div> wrapper (defaulting to a 16:9 aspect ratio, overridable via className) that holds the focusable interaction overlay, the sr-only description, and, outside a List, the aria-live region. The paint surface, the crosshair, hover-band, and marker layers, and the sr-only data table arrive later: the data attributes below say when. Lines encode value by vertical position, not length from a baseline, so the full y domain is overridable via yDomain. Lines never stack, so there is no stacked prop.

All props from div, plus:

PropTypeDefaultDescription
datareadonly TDatum[]Rows of data; each LineChart.Line reads one numeric key per row.
xKeyExtract<keyof TDatum, string>The key of each row's x value.
aria-labelstringThe chart's accessible name. Exactly one of aria-label or aria-labelledby is required, enforced at the type level. Required unless mode is \"decorative\", which forbids it.
aria-labelledbystringThe id of a visible element that names the chart. Preferred over aria-label when the chart sits under a heading. Required unless mode is \"decorative\", which forbids it.
mode?"interactive" | "static" | "decorative""interactive"How much of the contract the Root exposes: explore it ("interactive"), glance at it with its values beside it ("static": a named role="img", no Tab stop, no tooltip, no table, animate off by default), or paint a placeholder ("decorative": hidden from assistive technology, one neutral fill). The name props are required unless decorative, and the interaction props are allowed only when interactive. See Modes.
xScale?"time" | "linear" | "point"auto-detectedOverride the auto-detected x scale (Date values → "time", numbers → "linear", strings → "point").
yDomain?[number | "auto", number | "auto"]["auto", "auto"]Override the automatic y domain at either end.
animate?booleantrueAnimate enter/update transitions. When the chart first comes into view, each line sweeps in from the left. prefers-reduced-motion always wins.
pending?booleanfalseHold the previous render at reduced opacity while fresh data loads. Never swap a chart that has rendered once for a skeleton.
activeIndex?number | nullControlled active datum index (null = none). Omit for uncontrolled hover. Allowed only when mode is "interactive".
onActiveIndexChange?(index: number | null) => voidNotified when hover/keyboard moves the active index. Allowed only when mode is "interactive".
onDatumActivate?(event: ChartDatumEvent) => voidNotified on datum activation: mark click, or Enter/Space on the focused chart. The event carries index, xValue, datum, and the dataKey of the series nearest the pointer (null for keyboard activation). Allowed only when mode is "interactive".

Data attributes

Data AttributeValueDescription
data-slot"line-chart"The Root wrapper, with any forwarded chain ahead of it.
data-slot"line-chart-plot"The plot box. Every overlay layer positions against it, and the resize observer measures it.
data-slot"line-chart-svg"The <svg> the marks paint on. Always aria-hidden. Engine-owned: it is absent from server HTML and from a dormant chart, and the Root inserts it when the chart activates (near the viewport, on focus, or before print).
data-slot"line-chart-crosshair"The vertical hairline snapped to the active x. The engine writes its geometry as an inline style. Engine-owned: it is absent from server HTML. The engine appends it on the first hover, keyboard step, or controlled activeIndex that names a datum. It stays until the Root destroys the engine, such as when mode leaves "interactive". Interactive charts only: a static or decorative chart inserts the surface alone.
data-slot"line-chart-hover-band"The category highlight; a line chart never shows it. Engine-owned: it is absent from server HTML. The engine appends it on the first hover, keyboard step, or controlled activeIndex that names a datum. It stays until the Root destroys the engine, such as when mode leaves "interactive". Interactive charts only: a static or decorative chart inserts the surface alone.
data-slot"line-chart-markers"The container the engine syncs one hover dot per series into. Engine-owned: it is absent from server HTML. The engine appends it on the first hover, keyboard step, or controlled activeIndex that names a datum. It stays until the Root destroys the engine, such as when mode leaves "interactive". Interactive charts only: a static or decorative chart inserts the surface alone.
data-slot"line-chart-tooltip"The tooltip surface. The Root renders it on the first hover or keyboard step and keeps it; LineChart.Tooltip configures it. A chart nobody points at holds none.
data-slot"line-chart-description"The sr-only description the overlay's aria-describedby points at: the chart kind, the point count, the x range, the series labels, and, on an interactive chart, the keyboard instructions. Omitted when mode="decorative".
data-slot"line-chart-data-table"The sr-only data table. Mounts once focus lands inside the chart (data-state flips to "engaged") and stays. Interactive charts only.
data-state"dormant" | "engaged"On the Root. Flips to "engaged" once focus lands inside the chart, and never flips back. The data table mounts with it. Visibility paints the chart but never flips it. Interactive charts only.
data-slot"chart-active-point"One hover dot inside the markers layer. Also carries data-shape.
data-shape"circle" | "square" | "triangle" | "diamond" | "triangle-down" | "plus" | "cross" | "star"On each hover dot, naming the glyph its series wears: the shape it set, else "circle". The dot clips itself to that glyph, so target this only to restyle a dot.

LineChart.Line

One line series. Renders nothing itself: it registers the series with the chart, which paints it. Compose one Line per series.

PropTypeDefaultDescription
dataKeystringThe row key this series reads its numeric values from.
label?stringdataKeyDisplay name for the legend, tooltip, and data table.
colorSeriesColorThe color the series paints: a mantle color name (the Color that Badge takes) or any CSS color. Required. See Chart color tokens.
curve?"linear" | "monotone" | "step""linear"Interpolation between points. "monotone" smooths without overshooting the data.
markers?booleanfalseDraw point markers with a surface ring. Auto-hidden when points are denser than ~12px apart.
connectNulls?booleanfalseJoin across null/missing values instead of leaving gaps. Gaps are the default and usually correct.
shape?"circle" | "square" | "triangle" | "diamond" | "triangle-down" | "plus" | "cross" | "star""circle"The glyph the hover dot, the painted point markers, and the legend key wear. Set it for a second encoding beside color. See Point shapes.

LineChart.Grid

Horizontal hairline gridlines behind the lines (renderless; the chart paints it). Omit the part to omit the grid.

PropTypeDefaultDescription
lines?"horizontal" | "vertical" | "both""horizontal"Which gridlines to draw.

LineChart.XAxis

Tick labels along the bottom of the plot (renderless; the chart paints it). Labels that would collide are skipped, never rotated.

PropTypeDefaultDescription
tickFormat?(value: string | number | Date, context: { defaultLabel: string }) => stringscale-dependentFormat a tick label. Receives the row's x value: a Date on time scales, a number on linear scales, and the category value on point scales. Defaults to calendar-aware formatting on time scales and thousands-separated numbers on linear scales. The second argument is { defaultLabel }: the label the axis paints without a formatter.
tickCount?numberdensity-derivedTarget tick count (continuous scales only). Approximate: a linear axis over integer-only x values never renders fractional ticks.

LineChart.YAxis

Value tick labels along the left of the plot (renderless; the chart paints it). Ticks land on clean thousands-separated numbers.

PropTypeDefaultDescription
tickFormat?(value: number, context: { defaultLabel: string; step: number }) => stringthousands-separatedFormat a tick label. The second argument carries the tick step and the defaultLabel the axis paints without a formatter, so a formatter can add a unit to defaultLabel and keep its precision.
tickCount?number5Maximum tick count. When omitted, the axis aims for about 5 ticks. The axis can render fewer: ticks land on human-friendly steps, a vertical axis keeps about 28px for each tick, and a label that would overlap its neighbor is skipped. Integer-valued data never renders fractional ticks.

LineChart.ReferenceLine

A dashed horizontal marker at a y value, such as an SLO threshold, a budget, or a limit (renderless; the chart paints it).

PropTypeDefaultDescription
ynumberThe y value the line marks.
label?stringA short label painted above the line's right end.
color?SeriesColorneutral referenceLine color. Defaults to the neutral reference color in the active theme.

LineChart.Tooltip

Customizes the hover/keyboard tooltip readout. The tooltip itself is part of LineChart.Root's interaction contract and renders even when this part is absent. Compose it to format the label or values, append a footer, or replace the content entirely.

A children readout renders inside a <div data-slot="line-chart-tooltip-label">. When it goes away, React removes that div instead of your own text nodes: a browser translation engine reparents text nodes, and a removal aimed at one throws. The div is display: contents, so it adds no box and your content stays a direct layout child of the parent. To style it as a box, set a display of your own on it first. Browser translation covers the mechanism and the rules your own components need.

The footer and children render props receive a HoverSnapshot: the active index, xValue, the original datum, points (every series' dataKey, label, value, and color at the active x, in registration order), and viaKeyboard. labelFormat receives the x value directly and valueFormat receives (value, dataKey), not the snapshot.

All props from div (forwarded to the tooltip element the Root renders) except children, plus:

PropTypeDefaultDescription
labelFormat?(value: string | number | Date) => ReactNodeFormat the x/label row of the readout.
valueFormat?(value: number, dataKey: string) => ReactNodeFormat each series value.
indicator?"line" | "none""line"The per-series color key: a short stroke or nothing.
footer?ReactNode | ((snapshot: HoverSnapshot) => ReactNode)Extra content appended below the series rows (e.g. a "view logs" hint).
children?(snapshot: HoverSnapshot) => ReactNodeReplace the entire readout.

Data attributes

Data AttributeValueDescription
data-slot"line-chart-tooltip-label"On the <div> wrapping a children readout. The default readout has none.

LineChart.Legend

The legend: series names keyed by swatches carrying each series' color and glyph, rendered as real DOM in flow below the plot. Always compose it on multi-series charts: identity must never rely on color-matching alone. It renders nothing for a single series (the chart's title already names it). The legend is at most 64px tall (max-h-16) and scrolls past that, so many series never take the plot's height in a fixed-height Root. Set a max-h-* class in className to change the bound.

A children render prop renders inside a <div data-slot="line-chart-legend-label">. When it goes away, React removes that div instead of your own text nodes: a browser translation engine reparents text nodes, and a removal aimed at one throws. The div is display: contents, so it adds no box and your content stays a direct layout child of the parent. To style it as a box, set a display of your own on it first. Browser translation covers the mechanism and the rules your own components need.

All props from div except children, plus:

PropTypeDefaultDescription
children?(series: SeriesMeta[]) => ReactNodeReplace the default legend items. Receives the registered series with their dataKey, label, mark, resolved color, and resolved shape.

Data attributes

Data AttributeValueDescription
data-slot"line-chart-legend"The legend list. LineChart.Legend renders it in flow below the plot.
data-slot"line-chart-legend-label"On the <div> wrapping a children render prop. The default legend has none.
data-shape"circle" | "square" | "triangle" | "diamond" | "triangle-down" | "plus" | "cross" | "star"On the glyph riding each swatch's stroke, naming what its LineChart.Line wears. The glyph clips itself to that shape, so target this only to restyle a key.

LineChart.CopyButton

A button that copies the chart's current data to the clipboard as a GitHub-flavored markdown table: one x column plus one column per series in paint order. Values are machine-stable (an ISO 8601 timestamp for every x on a time scale, plain un-separated numbers, an em dash for gaps), so the paste target receives parseable data, not locale formatting. Renders an icon button in flow where composed; Root is relatively positioned, so className can dock it over a corner (e.g. absolute right-0 top-0).

All props from button, plus:

PropTypeDefaultDescription
label?string"Copy data as Markdown"The accessible name, rendered as the button's aria-label.
onCopy?(value: string) => voidCallback fired after a successful copy, passes the serialized markdown.
onCopyError?(error: unknown) => voidCallback fired when an error occurs during copying.
asChild?booleanfalseCompose the copy behavior onto your own element instead of the default button.

While a copy is fresh, an always-mounted role="status" element beside the button announces "Copied" to a screen reader.

Data AttributeValueDescription
data-slot"line-chart-copy-button"The button the part renders.

LineChart.List

Groups a list of charts, such as one chart per card, so they share one role="status" live region. A page of 100 charts mounts one region instead of one per chart, plus one for each LineChart.CopyButton. Each chart keeps its own tooltip, description, and data table. Charts of different families can share one List. See Lists of charts.

Renders a div (line-chart-list) that holds the charts in a display: contents wrapper (line-chart-list-items), so a grid or flex layout on the List reaches the cards, and the live region as its last child. LineChart.List takes no asChild: a list element such as ul cannot hold the live region as a child.

All props from div.

Data AttributeValueDescription
data-slot"line-chart-list"The List wrapper, with any forwarded chain ahead of it. It takes the className and the other div props.
data-slot"line-chart-list-items"The display: contents wrapper around the charts, so a grid or flex layout on the List lays out the cards.

Chart color tokens

Every series names its own color. A mantle color name reads its chart token: color="blue" paints --color-chart-blue. The names are the Color that Badge takes: the hues amber, blue, cyan, emerald, fuchsia, gray, green, indigo, lime, orange, pink, purple, red, rose, sky, teal, violet, and yellow, plus the functional names accent, danger, important, info, neutral, success, and warning. Give a series that means good or bad a functional name (danger for an error rate), and give an "Other" series neutral.

CSS VariableDescription
--color-chart-<hue>One token for each hue name. Dark mode uses the hue's 500 step. Light mode uses its 600 step, because 500 reads washed out on a white card.
--color-chart-<functional>One token for each functional name. Each aliases the hue its status color uses: accent and info → sky, danger → rose, important → purple, success → emerald, warning → amber. neutral is --color-neutral-500 in dark mode and --color-neutral-600 in light mode.
--color-chart-decorativeThe neutral fill every series wears on a decorative chart, in place of its own color.

The color prop also takes any CSS color string. A raw hex can't follow the two themes, so prefer a var(...) reference to a token you declare for each theme. A color you pick for yourself has no measurement behind it: check it for 3:1 against the card, as Color and accessibility describes.

Restyle a color for one chart

Redeclare a token on LineChart.Root to change what one name paints in that chart alone: className="[--color-chart-blue:var(--color-brand)]". Every series that sets color="blue" picks up the new value, and so do its legend key and hover dot.

The chart paints every token as CSS, so the browser resolves it inside the Root's own cascade, with no computed-style read and no hidden probe element. A declaration scoped to one Root wins for that chart alone, and sibling charts on the page keep the theme value. Declare the same custom property higher up (on a dashboard wrapper, or at :root) to retheme a whole subtree.

Below, this week paints the brand color through color="blue". Last week wears gray, and its square glyph in the legend and under the crosshair keeps it apart from this week by shape as well as color.