gantt-chartuiReact mirror of @uipkge/gantt-chart — see the Vue registry item for the canonical description.
Also available for Vue ->$pnpm dlx shadcn@latest add https://uipkge.dev/r/react/gantt-chart.json$npx shadcn@latest add https://uipkge.dev/r/react/gantt-chart.json$yarn dlx shadcn@latest add https://uipkge.dev/r/react/gantt-chart.json$bunx shadcn@latest add https://uipkge.dev/r/react/gantt-chart.jsonnpx shadcn@latest add @uipkge-react/gantt-chartInstalls to:components/ui/charts/gantt-chart/| Name | Type / Values | Default | Required |
|---|---|---|---|
tasks | GanttTask[] | — | required |
milestonesDiamond markers pinned to tasks. | GanttMilestone[] | — | optional |
todayISO date for a dashed "today" line. Pass explicitly (no implicit now() so SSR stays deterministic). | string | — | optional |
height | number | string | 320 | optional |
option | any | — | optional |
className | string | — | optional |
ariaLabelAccessible name announced for the chart image. Defaults to "Chart". | string | — | optional |
Type aliases from this item's source — use them to shape the data you pass in.
GanttTaskinterface GanttTask {
name: string
/** ISO date strings. */
start: string
end: string
/** 0..1 fraction shaded darker as progress. */
progress?: number
group?: string
}GanttMilestoneinterface GanttMilestone {
/** Task name to pin the diamond to. */
task: string
/** ISO date string. */
date: string
label?: string
}ChartThemeinterface ChartTheme {
colors: string[]
textColor: string
axisColor: string
splitLineColor: string
tooltipBg: string
tooltipBorder: string
tooltipText: string
bgColor: string
/** The app's accent, for the one highlighted element on a chart or map —
* a selected route, a focused bar. Category series keep using `colors`. */
accentColor: string
/** Out-of-bounds / failure colour for charts that encode good vs bad
* rather than a category — control limits, error series. CSS-level marks
* can use `var(--destructive)` directly; this exists because ECharts needs
* a resolved colour string on the canvas. */
dangerColor: string
}'use client'
import * as React from 'react'
import { ChartFrame, EChart } from '../shared'
import { useChartTheme, mergeOptionBlock } from '../useChartTheme'
// GanttChart
// ─────────────────────────────────────────────────────────────────────────
export interface GanttTask {
name: string
/** ISO date strings. */
start: string
end: string
/** 0..1 fraction shaded darker as progress. */
progress?: number
group?: string
}
export interface GanttMilestone {
/** Task name to pin the diamond to. */
task: string
/** ISO date string. */
date: string
label?: string
}
export interface GanttChartProps {
tasks: GanttTask[]
/** Diamond markers pinned to tasks. */
milestones?: GanttMilestone[]
/** ISO date for a dashed "today" line. Pass explicitly (no implicit now() so SSR stays deterministic). */
today?: string
height?: number | string
option?: any
className?: string
/** Accessible name announced for the chart image. Defaults to "Chart". */
ariaLabel?: string
}
export const GanttChart = React.forwardRef<HTMLDivElement, GanttChartProps>(
({ tasks, milestones, today, height = 320, option, className, ariaLabel }, ref) => {
const theme = useChartTheme()
const mergedOption = React.useMemo(() => {
const groups = [...new Set(tasks.map((t) => t.group ?? 'default'))]
const colorOf = (t: GanttTask) => theme.colors[groups.indexOf(t.group ?? 'default') % theme.colors.length]
const series = [
{
type: 'custom',
renderItem: (params: any, api: any) => {
const i: number = params.dataIndex
const t = tasks[i]!
const start = api.coord([api.value(0), i])
const end = api.coord([api.value(1), i])
const h = Math.max(8, api.size!([0, 1])[1] * 0.55)
const p = Math.max(0, Math.min(1, t.progress ?? 1))
return {
type: 'group',
children: [
{
type: 'rect',
shape: { x: start[0], y: start[1] - h / 2, width: Math.max(2, end[0] - start[0]), height: h, r: 4 },
style: { fill: colorOf(t), opacity: 0.3 },
},
{
type: 'rect',
shape: {
x: start[0],
y: start[1] - h / 2,
width: Math.max(2, (end[0] - start[0]) * p),
height: h,
r: 4,
},
style: { fill: colorOf(t) },
},
],
}
},
encode: { x: [0, 1], y: 2 },
data: tasks.map((t, i) => [t.start, t.end, i]),
markPoint: milestones?.length
? {
symbol: 'diamond',
symbolSize: 13,
itemStyle: { color: theme.colors[3], borderColor: theme.tooltipBg, borderWidth: 1.5 },
label: {
show: true,
fontSize: 9,
color: theme.textColor,
formatter: '{b}',
position: 'top',
distance: 6,
},
data: milestones.map((m) => ({
name: m.label ?? m.task,
coord: [m.date, tasks.findIndex((t) => t.name === m.task)],
})),
}
: undefined,
markLine: today
? {
silent: true,
symbol: 'none',
lineStyle: { type: 'dashed', color: theme.textColor, width: 1 },
label: { formatter: 'Today', color: theme.textColor, fontSize: 10, position: 'insideEndTop' },
data: [{ xAxis: today }],
}
: undefined,
},
]
const userOption: any = option ?? {}
const {
series: userSeries,
xAxis: userXAxis,
yAxis: userYAxis,
grid: userGrid,
tooltip: userTooltip,
...userRest
} = userOption
const mergedSeries = Array.isArray(userSeries)
? series.map((s, i) => ({ ...s, ...(userSeries[i] ?? {}) }))
: series
return {
color: theme.colors,
grid: mergeOptionBlock({ left: 16, right: 16, top: 24, bottom: 24, containLabel: true }, userGrid),
tooltip: mergeOptionBlock(
{
trigger: 'item',
backgroundColor: theme.tooltipBg,
borderColor: theme.tooltipBorder,
textStyle: { color: theme.tooltipText, fontSize: 12 },
formatter: (p: any) => {
const t = tasks[p.dataIndex]
return `${t?.name}<br/>${String(t?.start).slice(0, 10)} → ${String(t?.end).slice(0, 10)}`
},
},
userTooltip,
),
legend: { show: false },
xAxis: mergeOptionBlock(
{
type: 'time',
splitLine: { lineStyle: { color: theme.splitLineColor } },
axisLabel: { color: theme.textColor, fontSize: 11 },
},
userXAxis,
),
yAxis: mergeOptionBlock(
{
type: 'category',
inverse: true,
data: tasks.map((t) => t.name),
axisLine: { lineStyle: { color: theme.axisColor } },
axisLabel: { color: theme.textColor, fontSize: 11 },
axisTick: { show: false },
},
userYAxis,
),
series: mergedSeries,
...userRest,
}
}, [tasks, milestones, today, option, theme])
return (
<ChartFrame ref={ref} height={height} className={className} ariaLabel={ariaLabel}>
<EChart option={mergedOption} />
</ChartFrame>
)
},
)
GanttChart.displayName = 'GanttChart'
export { GanttChart, type GanttChartProps, type GanttTask, type GanttMilestone } from './GanttChart'
'use client'
import { useEffect, useState } from 'react'
// Chart palette is driven by Tailwind v4 CSS variables (`--chart-1`..`--chart-5`,
// `--muted-foreground`, `--border`, `--popover`, etc.) so dark/light flips
// happen automatically when the consumer toggles their theme class. The
// values resolve at runtime via `getComputedStyle`, so they pick up whatever
// the consumer set in their own `tailwind.css` -- no fork required.
//
// We bump a module-level `themeKey` whenever `<html>` class/style changes (the
// typical shadcn dark-mode pivot) and notify subscribed `useChartTheme()`
// consumers so every chart re-resolves its colors and ECharts re-paints.
let themeKey = 0
const listeners = new Set<() => void>()
function bump() {
themeKey++
listeners.forEach((l) => l())
}
if (typeof window !== 'undefined') {
// Bump once on the first paint so post-hydration getComputedStyle reads
// the *resolved* CSS values (during SSR-built bundles the very first
// read returns the fallbacks below).
requestAnimationFrame(bump)
new MutationObserver(bump).observe(document.documentElement, {
attributes: true,
attributeFilter: ['class', 'style', 'data-theme'],
})
}
// ECharts' canvas renderer does not accept OKLCH in every browser. Assigning
// one of our Tailwind tokens to `fillStyle` can silently leave the sentinel
// colour in place, turning a whole chart black. Convert OKLCH ourselves and
// let the canvas normalize older CSS colour formats.
let _hexCanvas: CanvasRenderingContext2D | null = null
export function toCanvasColor(cssColor: string): string {
const value = cssColor.trim()
const match = value.match(
/^oklch\(\s*([+-]?(?:\d+\.?\d*|\.\d+))(%?)\s+([+-]?(?:\d+\.?\d*|\.\d+))\s+([+-]?(?:\d+\.?\d*|\.\d+))(?:deg)?(?:\s*\/\s*([+-]?(?:\d+\.?\d*|\.\d+))(%?))?\s*\)$/i,
)
if (match) {
const lightness = Number(match[1]) / (match[2] === '%' ? 100 : 1)
const chroma = Number(match[3])
const hue = (Number(match[4]) * Math.PI) / 180
const alpha = match[5] == null ? 1 : Number(match[5]) / (match[6] === '%' ? 100 : 1)
const a = chroma * Math.cos(hue)
const b = chroma * Math.sin(hue)
const l = Math.pow(lightness + 0.3963377774 * a + 0.2158037573 * b, 3)
const m = Math.pow(lightness - 0.1055613458 * a - 0.0638541728 * b, 3)
const s = Math.pow(lightness - 0.0894841775 * a - 1.291485548 * b, 3)
const linear = [
4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
]
const rgb = linear.map((channel) => {
const encoded = channel <= 0.0031308 ? 12.92 * channel : 1.055 * Math.pow(channel, 1 / 2.4) - 0.055
return Math.round(Math.min(1, Math.max(0, encoded)) * 255)
})
return alpha < 1 ? `rgba(${rgb.join(', ')}, ${alpha})` : `rgb(${rgb.join(', ')})`
}
if (typeof document === 'undefined') return cssColor
if (!_hexCanvas) {
_hexCanvas = document.createElement('canvas').getContext('2d')
}
if (!_hexCanvas) return cssColor
_hexCanvas.fillStyle = '#010203'
_hexCanvas.fillStyle = value
const normalized = _hexCanvas.fillStyle as string
return normalized === '#010203' && value.toLowerCase() !== '#010203' ? value : normalized
}
// Convert any CSS color (hex, rgb, oklch, color()) + alpha 0..1 to a
// canvas-safe rgba(r,g,b,a). `colorString + '40'` (8-digit hex alpha)
// only works when `colorString` is `#rrggbb`; once tokens resolve to
// oklch() post-hydration the gradient stops break and the canvas paint
// throws every frame. Stay defensive and always return rgba.
export function toRgba(cssColor: string, alpha: number): string {
const normalized = toCanvasColor(cssColor)
if (normalized.startsWith('#') && normalized.length === 7) {
const r = parseInt(normalized.slice(1, 3), 16)
const g = parseInt(normalized.slice(3, 5), 16)
const b = parseInt(normalized.slice(5, 7), 16)
return `rgba(${r},${g},${b},${alpha})`
}
if (normalized.startsWith('rgba(')) {
return normalized.replace(/,\s*[\d.]+\s*\)$/, `,${alpha})`)
}
if (normalized.startsWith('rgb(')) {
return normalized.replace(/^rgb\(/, 'rgba(').replace(/\)$/, `,${alpha})`)
}
// Canvas refused to parse this color -- ship the original string and
// let ECharts complain (better than crashing the paint loop).
return cssColor
}
function resolveVar(name: string, fallback: string): string {
if (typeof window === 'undefined') return fallback
const v = getComputedStyle(document.documentElement).getPropertyValue(name).trim()
if (!v) return fallback
return toCanvasColor(v)
}
// SSR / pre-hydration fallback palette. Hex values picked to roughly
// match the shadcn Neutral defaults in `tailwind.css` so the first paint
// doesn't flicker.
const CHART_FALLBACK = ['#f59e0b', '#14b8a6', '#3b82f6', '#f97316', '#eab308']
/** The resolved chart theme tokens. All values are canvas-safe hex/rgba. */
export interface ChartTheme {
colors: string[]
textColor: string
axisColor: string
splitLineColor: string
tooltipBg: string
tooltipBorder: string
tooltipText: string
bgColor: string
/** The app's accent, for the one highlighted element on a chart or map —
* a selected route, a focused bar. Category series keep using `colors`. */
accentColor: string
/** Out-of-bounds / failure colour for charts that encode good vs bad
* rather than a category — control limits, error series. CSS-level marks
* can use `var(--destructive)` directly; this exists because ECharts needs
* a resolved colour string on the canvas. */
dangerColor: string
}
function resolveTheme(): ChartTheme {
return {
colors: Array.from({ length: 5 }, (_, i) => resolveVar(`--chart-${i + 1}`, CHART_FALLBACK[i]!)),
textColor: resolveVar('--muted-foreground', '#888888'),
axisColor: resolveVar('--border', '#e5e5e5'),
splitLineColor: resolveVar('--border', '#f0f0f0'),
tooltipBg: resolveVar('--popover', 'rgba(255,255,255,0.96)'),
tooltipBorder: resolveVar('--border', '#e5e5e5'),
tooltipText: resolveVar('--popover-foreground', '#333333'),
bgColor: resolveVar('--card', resolveVar('--background', '#ffffff')),
accentColor: resolveVar('--primary', '#38bdf8'),
dangerColor: resolveVar('--destructive', '#dc2626'),
}
}
/**
* Subscribe to the theme-token palette. Re-resolves (and re-renders the
* consuming chart) whenever the consumer flips their dark-mode class on
* `<html>`. The first client render resolves the real CSS values; SSR /
* pre-hydration returns the fallback palette above.
*/
export function useChartTheme(): ChartTheme {
const [, setTick] = useState(themeKey)
const [theme, setTheme] = useState<ChartTheme>(() => resolveTheme())
useEffect(() => {
const update = () => {
setTick(themeKey)
setTheme(resolveTheme())
}
listeners.add(update)
// Resolve once on mount so the first client paint reads the real CSS
// values instead of the SSR fallbacks.
update()
return () => {
listeners.delete(update)
}
}, [])
return theme
}
// Two-level deep merge for ECharts option blocks (xAxis, yAxis, grid,
// tooltip, legend, singleAxis, parallel, etc.). The top-level keys merge
// shallowly, but one nested level (axisLabel, axisLine, splitLine, etc.)
// merges shallowly too so a consumer passing `xAxis: { axisLabel: { fontSize: 9 } }`
// doesn't blow away the wrapper's `color` + base font defaults on the same
// axisLabel block. Arrays + primitives replace outright.
//
// This is the merge strategy the chart wrappers use to fold `option`
// onto their computed base option without forcing consumers to spell out
// every default they want to preserve.
export function mergeOptionBlock<T extends Record<string, any>>(base: T, user: Partial<T> | undefined): T {
if (!user) return base
const out: any = { ...base }
for (const k of Object.keys(user)) {
const bv = (base as any)[k]
const uv = (user as any)[k]
if (
bv != null &&
uv != null &&
typeof bv === 'object' &&
typeof uv === 'object' &&
!Array.isArray(bv) &&
!Array.isArray(uv)
) {
out[k] = { ...bv, ...uv }
} else {
out[k] = uv
}
}
return out
}
// Default gauge stoplight: teal (safe) -> amber (warning) -> red (danger).
// Pulled off saturated green and onto teal so the gauge ties back to the
// dashboard palette; red is kept as the universal "limit reached" cue.
// GaugeChart consumes this via its `thresholds` prop default; consumers
// pass their own array to override. Static because gauges have semantic
// meaning (green safe / red danger) that we deliberately don't theme-flip.
export const gaugeThresholds: [number, string][] = [
[0.6, '#14b8a6'],
[0.85, '#f59e0b'],
[1, '#dc2626'],
]
'use client'
import * as React from 'react'
import * as echartsCore from 'echarts/core'
import { use } from 'echarts/core'
import { CanvasRenderer } from 'echarts/renderers'
import {
LineChart as EChartsLineChart,
BarChart as EChartsBarChart,
PieChart as EChartsPieChart,
ScatterChart as EChartsScatterChart,
EffectScatterChart as EChartsEffectScatter,
PictorialBarChart as EChartsPictorialBar,
RadarChart as EChartsRadarChart,
GaugeChart as EChartsGaugeChart,
HeatmapChart as EChartsHeatmap,
TreemapChart as EChartsTreemapChart,
FunnelChart as EChartsFunnelChart,
BoxplotChart as EChartsBoxplotChart,
CandlestickChart as EChartsCandlestickChart,
CustomChart as EChartsCustomChart,
ChordChart as EChartsChordChart,
MapChart as EChartsMapChart,
GraphChart as EChartsGraphChart,
ParallelChart as EChartsParallelChart,
SankeyChart as EChartsSankeyChart,
SunburstChart as EChartsSunburstChart,
ThemeRiverChart,
TreeChart as EChartsTreeChart,
} from 'echarts/charts'
import {
GridComponent,
PolarComponent,
TooltipComponent,
LegendComponent,
MarkLineComponent,
MarkAreaComponent,
MarkPointComponent,
GraphicComponent,
RadarComponent,
VisualMapComponent,
CalendarComponent,
DataZoomComponent,
ParallelComponent,
SingleAxisComponent,
TitleComponent,
} from 'echarts/components'
import ReactECharts from 'echarts-for-react/esm/core'
import { cn } from '@/lib/utils'
export function heightToStyle(height: number | string): string {
return /^\d+$/.test(String(height)) ? `${height}px` : String(height)
}
interface ChartFrameProps {
height: number | string
className?: string
/** Apply the accessible role/tabindex/focus-ring chrome. Some chart
* wrappers ship a bare `w-full` frame -- pass `false` for those. */
focusable?: boolean
/** Accessible name for role="img". Defaults to "Chart". */
ariaLabel?: string
}
/** Shared `<div>` wrapper around the ECharts canvas. */
export const ChartFrame = React.forwardRef<HTMLDivElement, ChartFrameProps & { children: React.ReactNode }>(
({ height, className, focusable = true, ariaLabel, children }, ref) => (
<div
ref={ref}
role="img"
aria-label={ariaLabel || 'Chart'}
tabIndex={focusable ? 0 : undefined}
style={{ height: heightToStyle(height) }}
className={
focusable
? cn('focus-visible:ring-ring w-full focus-visible:ring-2 focus-visible:outline-none', className)
: cn('w-full', className)
}
>
{children}
</div>
),
)
ChartFrame.displayName = 'ChartFrame'
/** ECharts canvas filling its parent frame. */
export function EChart({ option }: { option: any }) {
return (
<ReactECharts
echarts={echartsCore as any}
option={option}
notMerge
lazyUpdate
style={{ width: '100%', height: '100%' }}
/>
)
}
export const echartsCoreModule = echartsCore
// Register every chart type the wrappers need once at module load.
use([
CanvasRenderer,
EChartsLineChart,
EChartsBarChart,
EChartsPieChart,
EChartsScatterChart,
EChartsEffectScatter,
EChartsPictorialBar,
EChartsRadarChart,
EChartsGaugeChart,
EChartsHeatmap,
EChartsTreemapChart,
EChartsFunnelChart,
EChartsBoxplotChart,
EChartsCandlestickChart,
EChartsCustomChart,
EChartsChordChart,
EChartsMapChart,
EChartsGraphChart,
EChartsParallelChart,
EChartsSankeyChart,
EChartsSunburstChart,
ThemeRiverChart,
EChartsTreeChart,
GridComponent,
PolarComponent,
TooltipComponent,
LegendComponent,
MarkLineComponent,
MarkAreaComponent,
MarkPointComponent,
GraphicComponent,
RadarComponent,
VisualMapComponent,
CalendarComponent,
DataZoomComponent,
ParallelComponent,
SingleAxisComponent,
TitleComponent,
])
Raw manifest:https://uipkge.dev/r/react/gantt-chart.json
