recharts

recharts

Version 3.1.2
Published 8 days ago
5.41 MB
11 dependencies
MIT license

Install

npm i recharts

yarn add recharts

pnpm add recharts

Overview

React charts

Index

Classes

CartesianAxis
DefaultLegendContent
ErrorBar
Funnel
Legend
PolarAngleAxis
PolarRadiusAxis
Radar
RadialBar
ReferenceArea
ReferenceDot
ReferenceLine
Sankey
XAxis
YAxis
ZAxis

Variables

variable AreaChart

const AreaChart: React.ForwardRefExoticComponent<any>;

variable BarChart

const BarChart: React.ForwardRefExoticComponent<any>;

variable Cell

const Cell: FunctionComponent<SVGProps<SVGElement>>;

variable ComposedChart

const ComposedChart: React.ForwardRefExoticComponent<any>;

variable Cross

const Cross: React.FC<any>;

variable Curve

const Curve: React.FC<Props>;

variable Dot

const Dot: React.FC<any>;

variable FunnelChart

const FunnelChart: React.ForwardRefExoticComponent<any>;

variable getNiceTickValues

const getNiceTickValues: (
    [min, max]: [number, number],
    tickCount?: number,
    allowDecimals?: boolean
) => number[];

variable Global

const Global: { isSsr: boolean };

variable Layer

const Layer: React.ForwardRefExoticComponent<any>;

variable LineChart

const LineChart: React.ForwardRefExoticComponent<any>;

variable PieChart

const PieChart: React.ForwardRefExoticComponent<any>;

variable PolarGrid

const PolarGrid: {
    ({
        gridType,
        radialLines,
        angleAxisId,
        radiusAxisId,
        cx: cxFromOutside,
        cy: cyFromOutside,
        innerRadius: innerRadiusFromOutside,
        outerRadius: outerRadiusFromOutside,
        ...inputs
    }: Props): React.JSX.Element;
    displayName: string;
};

variable Polygon

const Polygon: React.FC<Props>;

variable RadarChart

const RadarChart: React.ForwardRefExoticComponent<any>;

variable RadialBarChart

const RadialBarChart: React.ForwardRefExoticComponent<any>;

variable Rectangle

const Rectangle: React.FC<Props>;

variable ResponsiveContainer

const ResponsiveContainer: React.ForwardRefExoticComponent<any>;

variable ScatterChart

const ScatterChart: React.ForwardRefExoticComponent<any>;

variable Sector

const Sector: React.FC<Props>;

variable Surface

const Surface: React.ForwardRefExoticComponent<any>;

variable Symbols

const Symbols: {
    ({ type, size, sizeType, ...rest }: SymbolsProps): React.JSX.Element;
    registerSymbol: (key: string, factory: D3SymbolType) => void;
};

variable Text

const Text: React.ForwardRefExoticComponent<any>;

variable Trapezoid

const Trapezoid: React.FC<any>;

Functions

function Area

Area: typeof Area;

function Bar

Bar: typeof Bar;

function Brush

Brush: typeof Brush;

function CartesianGrid

CartesianGrid: typeof CartesianGrid;

function Customized

Customized: typeof Customized;

custom svg elements by rechart instance props and state.
Returns
{Object} svg elements

function DefaultTooltipContent

DefaultTooltipContent: <TValue extends ValueType, TName extends NameType>(
    props: Props<TValue, TName>
) => React.JSX.Element;

function Label

Label: typeof Label;

function LabelList

LabelList: typeof LabelList;

function Line

Line: typeof Line;

function Pie

Pie: typeof Pie;

function Scatter

Scatter: typeof Scatter;

function SunburstChart

SunburstChart: (props: SunburstChartProps) => React.JSX.Element;

Tooltip: <TValue extends ValueType, TName extends NameType>(
    outsideProps: TooltipProps<TValue, TName>
) => React.JSX.Element;

function Treemap

Treemap: (props: Props) => React.JSX.Element;

function useActiveTooltipDataPoints

useActiveTooltipDataPoints: <T = unknown>() => readonly T[];

Returns the currently active data points being displayed in the Tooltip. Active means that it is currently visible; this hook will return undefined if there is no current interaction.
This follows the <Tooltip /> props, if the Tooltip element is present in the chart. If there is no <Tooltip /> then this hook will follow the default Tooltip props.
Data point is whatever you pass as an input to the chart using the data={} prop.
This returns an array because a chart can have multiple graphical items in it (multiple Lines for example) and tooltip with shared={true} will display all items at the same time.
Returns undefined when used outside a chart context.
Returns
Data points that are currently visible in a Tooltip

function useActiveTooltipLabel

useActiveTooltipLabel: () => string | undefined;

Returns the active tooltip label. The label is one of the values from the chart data, and is used to display in the tooltip content.
Returns undefined if there is no active user interaction or if used outside a chart context
Returns
string | undefined

function useChartHeight

useChartHeight: () => number | undefined;

Returns the height of the chart in pixels.
If you are using chart with hardcoded height props, then the height returned will be the same as the height prop on the main chart element.
If you are using a chart with a ResponsiveContainer, the height will be the size of the chart as the ResponsiveContainer has decided it would be.
If the chart has any axes or legend, the height will be the size of the chart including the axes and legend. Meaning: adding axes and legend will not change the height.
The dimensions do not scale, meaning as user zoom in and out, the height number will not change as the chart gets visually larger or smaller.
Returns undefined if used outside a chart context.
Returns
{number | undefined} The height of the chart in pixels, or undefined if not in a chart context.

function useChartWidth

useChartWidth: () => number | undefined;

Returns the width of the chart in pixels.
If you are using chart with hardcoded width prop, then the width returned will be the same as the width prop on the main chart element.
If you are using a chart with a ResponsiveContainer, the width will be the size of the chart as the ResponsiveContainer has decided it would be.
If the chart has any axes or legend, the width will be the size of the chart including the axes and legend. Meaning: adding axes and legend will not change the width.
The dimensions do not scale, meaning as user zoom in and out, the width number will not change as the chart gets visually larger or smaller.
Returns undefined if used outside a chart context.
Returns
{number | undefined} The width of the chart in pixels, or undefined if not in a chart context.

function useOffset

useOffset: () => ChartOffset | undefined;

Offset defines the blank space between the chart and the plot area. This blank space is occupied by supporting elements like axes, legends, and brushes. This also includes any margins that might be applied to the chart.
Returns
Offset of the chart in pixels, or undefined if used outside a chart context.

function usePlotArea

usePlotArea: () => PlotArea | undefined;

Plot area is the area where the actual chart data is rendered. This means: bars, lines, scatter points, etc.
The plot area is calculated based on the chart dimensions and the offset.
Returns
Plot area of the chart in pixels, or undefined if used outside a chart context.

Classes

class CartesianAxis

class CartesianAxis extends Component<Props, IState> {}

constructor

constructor(props: Props);

property defaultProps

static defaultProps: Partial<Props>;

property displayName

static displayName: string;

property tickRefs

tickRefs: React.MutableRefObject<Element[]>;

method getTickLineCoord

getTickLineCoord: (data: CartesianTickItem) => {
    line: { x1: number; y1: number; x2: number; y2: number };
    tick: { x: number; y: number };
};

Calculate the coordinates of endpoints in ticks
Parameter data
The data of a simple tick (x1, y1): The coordinate of endpoint close to tick text (x2, y2): The coordinate of endpoint close to axis

method getTickTextAnchor

getTickTextAnchor: () => string;

method getTickVerticalAnchor

getTickVerticalAnchor: () => 'end' | 'middle' | 'start';

method render

render: () => React.JSX.Element;

method renderAxisLine

renderAxisLine: () => React.JSX.Element;

method renderTickItem

static renderTickItem: (
    option: Props['tick'],
    props: any,
    value: ReactNode
) => React.JSX.Element;

method renderTicks

renderTicks: (
    fontSize: string,
    letterSpacing: string,
    ticks?: ReadonlyArray<CartesianTickItem>
) => React.ReactElement | null;

render the ticks
Parameter fontSize
Fontsize to consider for tick spacing
Parameter letterSpacing
Letter spacing to consider for tick spacing
Parameter ticks
The ticks to actually render (overrides what was passed in props) {ReactElement | null} renderedTicks

method shouldComponentUpdate

shouldComponentUpdate: (
    { viewBox, ...restProps }: Props,
    nextState: IState
) => boolean;

class DefaultLegendContent

class DefaultLegendContent extends PureComponent<Props> {}

property defaultProps

static defaultProps: Partial<Props>;

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

method renderIcon

renderIcon: (
    data: LegendPayload,
    iconType: IconType | undefined
) => React.JSX.Element;

Render the path of icon
Parameter data
Data of each legend item
Parameter iconType
if defined, it will always render this icon. If undefined then it uses icon from data.type Path element

method renderItems

renderItems: () => React.JSX.Element[];

Draw items of legend Items

class ErrorBar

class ErrorBar extends Component<Props> {}

property defaultProps

static defaultProps: {
    readonly stroke: 'black';
    readonly strokeWidth: 1.5;
    readonly width: 5;
    readonly offset: 0;
    readonly isAnimationActive: true;
    readonly animationBegin: 0;
    readonly animationDuration: 400;
    readonly animationEasing: 'ease-in-out';
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class Funnel

class Funnel extends PureComponent<Props> {}

property defaultProps

static defaultProps: {
    readonly stroke: '#fff';
    readonly fill: '#808080';
    readonly legendType: 'rect';
    readonly hide: false;
    readonly isAnimationActive: boolean;
    readonly animationBegin: 400;
    readonly animationDuration: 1500;
    readonly animationEasing: 'ease';
    readonly nameKey: 'name';
    readonly lastShapeType: 'triangle';
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class Legend

class Legend extends PureComponent<Props, State> {}

property defaultProps

static defaultProps: {
    align: string;
    iconSize: number;
    itemSorter: string;
    layout: string;
    verticalAlign: string;
};

property displayName

static displayName: string;

method getWidthOrHeight

static getWidthOrHeight: (
    layout: LayoutType | undefined,
    height: number | undefined,
    width: number | undefined,
    maxWidth: number
) => null | { height?: number; width?: number };

method render

render: () => React.JSX.Element;

class PolarAngleAxis

class PolarAngleAxis extends PureComponent<Props> {}

property axisType

static axisType: string;

property defaultProps

static defaultProps: {
    readonly allowDuplicatedCategory: true;
    readonly angleAxisId: 0;
    readonly axisLine: true;
    readonly cx: 0;
    readonly cy: 0;
    readonly orientation: 'outer';
    readonly reversed: false;
    readonly scale: 'auto';
    readonly tick: true;
    readonly tickLine: true;
    readonly tickSize: 8;
    readonly type: 'category';
};

property displayName

static displayName: string;

method render

render: () => React.ReactNode;

class PolarRadiusAxis

class PolarRadiusAxis extends PureComponent<Props> {}

property axisType

static axisType: string;

property defaultProps

static defaultProps: {
    readonly allowDataOverflow: false;
    readonly allowDuplicatedCategory: true;
    readonly angle: 0;
    readonly axisLine: true;
    readonly cx: 0;
    readonly cy: 0;
    readonly orientation: 'right';
    readonly radiusAxisId: 0;
    readonly scale: 'auto';
    readonly stroke: '#ccc';
    readonly tick: true;
    readonly tickCount: 5;
    readonly type: 'number';
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class Radar

class Radar extends PureComponent<Props> {}

property defaultProps

static defaultProps: Partial<Props>;

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class RadialBar

class RadialBar extends PureComponent<RadialBarProps> {}

property defaultProps

static defaultProps: Partial<RadialBarProps>;

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class ReferenceArea

class ReferenceArea extends Component<Props> {}

property defaultProps

static defaultProps: {
    ifOverflow: string;
    xAxisId: number;
    yAxisId: number;
    r: number;
    fill: string;
    fillOpacity: number;
    stroke: string;
    strokeWidth: number;
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class ReferenceDot

class ReferenceDot extends Component<Props> {}

property defaultProps

static defaultProps: Partial<any>;

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class ReferenceLine

class ReferenceLine extends Component<Props> {}

property defaultProps

static defaultProps: {
    ifOverflow: string;
    xAxisId: number;
    yAxisId: number;
    fill: string;
    stroke: string;
    fillOpacity: number;
    strokeWidth: number;
    position: string;
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class Sankey

class Sankey extends PureComponent<Props, State> {}

property defaultProps

static defaultProps: {
    nameKey: string;
    dataKey: string;
    nodePadding: number;
    nodeWidth: number;
    linkCurvature: number;
    iterations: number;
    margin: { top: number; right: number; bottom: number; left: number };
    sort: boolean;
};

property displayName

static displayName: string;

property state

state: State;

method getDerivedStateFromProps

static getDerivedStateFromProps: (nextProps: Props, prevState: State) => State;

method handleClick

handleClick: (
    item: NodeProps | LinkProps,
    type: SankeyElementType,
    e: MouseEvent
) => void;

method handleMouseEnter

handleMouseEnter: (
    item: NodeProps | LinkProps,
    type: SankeyElementType,
    e: MouseEvent
) => void;

method handleMouseLeave

handleMouseLeave: (
    item: NodeProps | LinkProps,
    type: SankeyElementType,
    e: MouseEvent
) => void;

method render

render: () => React.JSX.Element;

class XAxis

class XAxis extends Component<Props> {}

property defaultProps

static defaultProps: {
    allowDataOverflow: boolean;
    allowDecimals: boolean;
    allowDuplicatedCategory: boolean;
    height: number;
    hide: boolean;
    mirror: boolean;
    orientation: XAxisOrientation;
    padding: XAxisPadding;
    reversed: boolean;
    scale:
        | import('../util/types').ScaleType
        | import('../util/ChartUtils').RechartsScale;
    tickCount: number;
    type: import('../util/types').AxisDomainType;
    xAxisId: number;
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class YAxis

class YAxis extends Component<Props> {}

property defaultProps

static defaultProps: Partial<Props>;

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

class ZAxis

class ZAxis extends Component<Props> {}

property defaultProps

static defaultProps: {
    zAxisId: number;
    range: AxisRange;
    scale: ScaleType | RechartsScale;
    type: import('../util/types').AxisDomainType;
};

property displayName

static displayName: string;

method render

render: () => React.JSX.Element;

Interfaces

interface DefaultTooltipContentProps

interface Props<TValue extends ValueType, TName extends NameType> {}

property accessibilityLayer

accessibilityLayer: boolean;

property contentStyle

contentStyle?: CSSProperties;

property formatter

formatter?: Formatter<TValue, TName>;

property itemSorter

itemSorter?:
    | 'dataKey'
    | 'value'
    | 'name'
    | ((item: Payload<TValue, TName>) => number | string);

property itemStyle

itemStyle?: CSSProperties;

property label

label?: any;

property labelClassName

labelClassName?: string;

property labelFormatter

labelFormatter?: (
    label: any,
    payload: ReadonlyArray<Payload<TValue, TName>>
) => ReactNode;

property labelStyle

labelStyle?: CSSProperties;

property payload

payload?: ReadonlyArray<Payload<TValue, TName>>;

property separator

separator?: string;

property wrapperClassName

wrapperClassName?: string;

interface LegendPayload

interface LegendPayload {}

property color

color?: string;

property dataKey

dataKey?: DataKey<any>;

property formatter

formatter?: Formatter;

property inactive

inactive?: boolean;

property legendIcon

legendIcon?: ReactElement<SVGElement>;

property payload

payload?: {
    strokeDasharray?: number | string;
    value?: any;
};

property type

type?: LegendType;

property value

value: string | undefined;

This is the text that will be displayed in the legend in the DOM. If undefined, the text will not be displayed, so the icon will be rendered without text.

interface PieLabelRenderProps

interface PieLabelRenderProps extends PieDef {}

property index

index?: number;

property name

name: string;

property percent

percent?: number;

property stroke

stroke: string;

property textAnchor

textAnchor: string;

property x

x: number;

property y

y: number;

index signature

[key: string]: any;

interface ResponsiveContainerProps

interface Props {}

property aspect

aspect?: number;

property children

children: ReactElement;

property className

className?: string | number;

property debounce

debounce?: number;

property height

height?: string | number;

property id

id?: string | number;

property initialDimension

initialDimension?: {
    width: number;
    height: number;
};

property maxHeight

maxHeight?: number;

property minHeight

minHeight?: string | number;

property minWidth

minWidth?: string | number;

property onResize

onResize?: (width: number, height: number) => void;

property style

style?: Omit<CSSProperties, keyof Props>;

property width

width?: string | number;

interface TreemapProps

interface Props {}

property animationBegin

animationBegin?: number;

property animationDuration

animationDuration?: AnimationDuration;

property animationEasing

animationEasing?: AnimationTiming;

property animationId

animationId?: number;

Deprecated
unused prop, doesn't do anything, use key instead

property aspectRatio

aspectRatio?: number;

property children

children?: any;

property className

className?: string;

property colorPanel

colorPanel?: [];

property content

content?: React.ReactElement | ((props: TreemapNode) => React.ReactElement);

property data

data?: ReadonlyArray<TreemapDataType>;

property dataKey

dataKey?: DataKey<any>;

property fill

fill?: string;

property height

height?: number;

property isAnimationActive

isAnimationActive?: boolean;

property isUpdateAnimationActive

isUpdateAnimationActive?: boolean;

property nameKey

nameKey?: DataKey<any>;

property nestIndexContent

nestIndexContent?: React.ReactElement | ((item: any, i: number) => any);

property onAnimationEnd

onAnimationEnd?: () => void;

property onAnimationStart

onAnimationStart?: () => void;

property onClick

onClick?: (node: TreemapNode) => void;

property onMouseEnter

onMouseEnter?: (node: TreemapNode, e: any) => void;

property onMouseLeave

onMouseLeave?: (node: TreemapNode, e: any) => void;

property stroke

stroke?: string;

property style

style?: any;

property type

type?: 'flat' | 'nest';

property width

width?: number;

interface ZAxisProps

interface Props {}

property dataKey

dataKey?: DataKey<any>;

The key of data displayed in the axis

property domain

domain?: AxisDomain;

The domain of scale in this axis

property name

name?: string;

The name of data displayed in the axis

property range

range?: AxisRange;

The range of axis

property scale

scale?: ScaleType | RechartsScale | undefined;

property type

type?: 'number' | 'category';

property unit

unit?: string;

The unit of data displayed in the axis

property zAxisId

zAxisId?: string | number;

The unique id of z-axis

Type Aliases

type AreaProps

type Props = AreaSvgProps & AreaProps;

type BarProps

type Props = Partial<BarEvents> & BarProps & Omit<BarSvgProps, keyof BarEvents>;

type BrushProps

type Props = Omit<SVGProps<SVGElement>, 'onChange' | 'onDragEnd' | 'ref'> &
    BrushProps;

type CartesianAxisProps

type Props = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'viewBox' | 'scale'
> &
    CartesianAxisProps;

type CartesianGridProps

type Props = AcceptedSvgProps & CartesianGridProps;

type CellProps

type Props = SVGProps<SVGElement>;

type ChartOffset

type ChartOffset = {
    /**
     * Distance from the top edge of the chart to the top edge of the plot area.
     */
    readonly top: number;
    /**
     * Distance from the bottom edge of the chart to the bottom edge of the plot area.
     * Note that this is not a coordinate, this is a distance.
     * Meaning, `offset.bottom` could be 0 in a perfectly fine big chart.
     */
    readonly bottom: number;
    /**
     * Distance from the left edge of the chart to the left edge of the plot area.
     */
    readonly left: number;
    /**
     * Distance from the right edge of the chart to the right edge of the plot area.
     * Note that this is not a coordinate, this is a distance.
     * Meaning, `offset.right` could be 0 in a perfectly fine big chart.
     */
    readonly right: number;
};

Defines the blank space between the chart and the plot area. This blank space is occupied by supporting elements like axes, legends, and brushes. This also includes any margins that might be applied to the chart.

type CrossProps

type Props = SVGProps<SVGPathElement> & CrossProps;

type CurveProps

type Props = Omit<
    PresentationAttributesWithProps<CurveProps, SVGPathElement>,
    'type' | 'points'
> &
    CurveProps;

type CustomizedProps

type Props<P, C extends Comp<P>> = P & {
    component: C;
};

type DefaultLegendContentProps

type Props = InternalProps &
    Omit<
        PresentationAttributesAdaptChildEvent<any, ReactElement>,
        keyof InternalProps
    >;

type DotProps

type Props = PresentationAttributesWithProps<DotProps, SVGCircleElement> & DotProps;

type ErrorBarProps

type Props = SVGProps<SVGLineElement> & ErrorBarProps;

type FunnelProps

type Props = FunnelSvgProps & FunnelProps;

type LabelListProps

type Props<T extends Data> = SVGProps<SVGTextElement> & LabelListProps<T>;

type LabelProps

type Props = Omit<SVGProps<SVGTextElement>, 'viewBox'> & LabelProps;

type LayerProps

type Props = SVGAttributes<SVGGElement> & LayerProps;

type LegendProps

type Props = Omit<DefaultProps, 'payload' | 'ref'> & {
    wrapperStyle?: CSSProperties;
    width?: number;
    height?: number;
    payloadUniqBy?: UniqueOption<LegendPayload>;
    onBBoxUpdate?: (box: ElementOffset | null) => void;
    /**
     * If portal is defined, then Legend will use this element as a target
     * for rendering using React Portal: https://react.dev/reference/react-dom/createPortal
     *
     * If this is undefined then Legend renders inside the recharts-wrapper element.
     */
    portal?: HTMLElement | null;
    itemSorter?: LegendItemSorter;
};

type LegendType

type LegendType =
    | 'circle'
    | 'cross'
    | 'diamond'
    | 'line'
    | 'plainline'
    | 'rect'
    | 'square'
    | 'star'
    | 'triangle'
    | 'wye'
    | 'none';

type LineProps

type Props = LineSvgProps & LineProps;

type PieLabel

type PieLabel<P extends PieLabelProps = PieLabelProps> =
    | ReactElement<SVGElement>
    | ((props: P) => ReactNode | ReactElement<SVGElement>)
    | (SVGProps<SVGTextElement> & {
          offsetRadius?: number;
      })
    | boolean;

type PieProps

type Props = PieSvgAttributes & PieProps;

type PlotArea

type PlotArea = {
    /**
     * The width of the plot area.
     * This will be the same as `chartWidth - offset.left - offset.right`
     */
    readonly width: number;
    /**
     * The height of the plot area.
     * This will be the same as `chartHeight - offset.top - offset.bottom`
     */
    readonly height: number;
    /**
     * The x coordinate of the top-left corner of the plot area.
     * This will be the same as `offset.left`
     */
    readonly x: number;
    /**
     * The y coordinate of the top-left corner of the plot area.
     * This will be the same as `offset.top`
     */
    readonly y: number;
};

Plot area is the area where the actual chart data is rendered. This means: bars, lines, scatter points, etc.

type PolarAngleAxisProps

type Props = AxisSvgProps & PolarAngleAxisProps;

type PolarGridProps

type Props = SVGProps<SVGLineElement> & PolarGridProps;

type PolarRadiusAxisProps

type Props = AxisSvgProps & PolarRadiusAxisProps;

type PolygonProps

type Props = Omit<SVGProps<SVGPolygonElement>, 'points'> & PolygonProps;

type RadarProps

type Props = Omit<
    SVGProps<SVGElement>,
    'onMouseEnter' | 'onMouseLeave' | 'points' | 'ref'
> &
    RadarProps;

type RadialBarProps

type RadialBarProps = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'ref'
> &
    InternalRadialBarProps;

type RectangleProps

type Props = Omit<SVGProps<SVGPathElement>, 'radius'> & RectangleProps;

type ReferenceAreaProps

type Props = RectangleProps & ReferenceAreaProps;

type ReferenceDotProps

type Props = DotProps & ReferenceDotProps;

type ReferenceLineProps

type Props = Omit<SVGProps<SVGLineElement>, 'viewBox'> & ReferenceLineProps;

This excludes viewBox prop from svg for two reasons: 1. The components wants viewBox of object type, and svg wants string - so there's a conflict, and the component will throw if it gets string 2. Internally the component calls filterProps which filters the viewBox away anyway

type ScatterProps

type Props = BaseScatterSvgProps & ScatterProps;

type SectorProps

type Props = Omit<SVGProps<SVGPathElement>, 'cx' | 'cy'> & Partial<SectorProps>;

SVG cx, cy are string | number | undefined, but internally we use number so let's override the types here.

type SurfaceProps

type Props = Omit<SVGProps<SVGSVGElement>, 'viewBox'> & SurfaceProps;

type SymbolsProps

type SymbolsProps = SVGProps<SVGPathElement> & InnerSymbolsProp;

type TextProps

type Props = Omit<SVGProps<SVGTextElement>, 'textAnchor' | 'verticalAnchor'> &
    TextProps;

type TooltipContentProps

type TooltipContentProps<
    TValue extends ValueType,
    TName extends NameType
> = TooltipProps<TValue, TName> & {
    label?: string | number;
    payload: any[];
    coordinate: ChartCoordinate;
    active: boolean;
    accessibilityLayer: boolean;
};

type TooltipProps

type TooltipProps<TValue extends ValueType, TName extends NameType> = Omit<
    DefaultTooltipContentProps<TValue, TName>,
    PropertiesReadFromContext
> & {
    /**
     * If true, then Tooltip is always displayed, once an activeIndex is set by mouse over, or programmatically.
     * If false, then Tooltip is never displayed.
     * If active is undefined, Recharts will control when the Tooltip displays. This includes mouse and keyboard controls.
     */
    active?: boolean;
    /**
     * If true, then Tooltip will information about hidden series (defaults to false).
     * Interacting with the hide property of Area, Bar, Line, Scatter.
     *
     * default: false
     */
    includeHidden?: boolean | undefined;
    allowEscapeViewBox?: AllowInDimension;
    animationDuration?: AnimationDuration;
    animationEasing?: AnimationTiming;
    content?: ContentType<TValue, TName>;
    cursor?: CursorDefinition;
    filterNull?: boolean;
    defaultIndex?: number | TooltipIndex;
    isAnimationActive?: boolean;
    offset?: number;
    payloadUniqBy?: UniqueOption<Payload<TValue, TName>>;
    /**
     * If portal is defined, then Tooltip will use this element as a target
     * for rendering using React Portal: https://react.dev/reference/react-dom/createPortal
     *
     * If this is undefined then Tooltip renders inside the recharts-wrapper element.
     */
    portal?: HTMLElement | null;
    position?: Partial<Coordinate>;
    reverseDirection?: AllowInDimension;
    /**
     * If true, tooltip will appear on top of all bars on an axis tick.
     * If false, tooltip will appear on individual bars.
     * Currently only supported in BarChart and RadialBarChart.
     * If undefined then defaults to true.
     */
    shared?: boolean;
    /**
     * If `hover` then the Tooltip shows on mouse enter and hides on mouse leave.
     *
     * If `click` then the Tooltip shows after clicking and stays active.
     *
     * Default `hover`
     */
    trigger?: TooltipTrigger;
    useTranslate3d?: boolean;
    wrapperStyle?: CSSProperties;
    /**
     * Tooltip always attaches itself to the "Tooltip" axis. Which axis is it? Depends on the layout:
     * - horizontal layout -> X axis
     * - vertical layout -> Y axis
     * - radial layout -> radial axis
     * - centric layout -> angle axis
     *
     * Tooltip will use the default axis for the layout, unless you specify an axisId.
     */
    axisId?: AxisId;
};

type TrapezoidProps

type Props = SVGProps<SVGPathElement> & TrapezoidProps;

type XAxisProps

type Props = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'scale' | 'ref'
> &
    XAxisProps;

type YAxisProps

type Props = Omit<
    PresentationAttributesAdaptChildEvent<any, SVGElement>,
    'scale' | 'ref'
> &
    YAxisProps;

Namespaces

namespace Area

namespace Area {}

variable displayName

var displayName: string;

namespace Bar

namespace Bar {}

variable displayName

var displayName: string;

namespace Brush

namespace Brush {}

variable displayName

var displayName: string;

namespace CartesianGrid

namespace CartesianGrid {}

variable displayName

var displayName: string;

namespace Customized

namespace Customized {}

variable displayName

var displayName: string;

namespace Label

namespace Label {}

variable displayName

var displayName: string;

function parseViewBox

parseViewBox: (props: any) => ViewBox;

function renderCallByParent

renderCallByParent: (
    parentProps: {
        children?: ReactNode;
        label?: unknown;
        labelRef?: React.RefObject<Element>;
    },
    viewBox?: ViewBox,
    checkPropsLabel?: boolean
) => ReactElement[] | null;

namespace LabelList

namespace LabelList {}

variable displayName

var displayName: string;

function renderCallByParent

renderCallByParent: <T extends Data>(
    parentProps: { children?: ReactNode; label?: unknown },
    data: readonly T[],
    checkPropsLabel?: boolean
) => React.JSX.Element[];

namespace Line

namespace Line {}

variable displayName

var displayName: string;

namespace Pie

namespace Pie {}

variable displayName

var displayName: string;

namespace Scatter

namespace Scatter {}

variable displayName

var displayName: string;

Package Files (60)

Dependencies (11)

Dev Dependencies (78)

Peer Dependencies (3)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/recharts.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/recharts)

HTML

<a href="https://www.jsdocs.io/package/recharts"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 7 days ago.
Package analyzed in 7444 ms.
Missing or incorrect documentation? Open an issue for this package.

recharts

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable AreaChart

variable BarChart

variable Cell

variable ComposedChart

variable Cross

variable Curve

variable Dot

variable FunnelChart

variable getNiceTickValues

variable Global

variable Layer

variable LineChart

variable PieChart

variable PolarGrid

variable Polygon

variable RadarChart

variable RadialBarChart

variable Rectangle

variable ResponsiveContainer

variable ScatterChart

variable Sector

variable Surface

variable Symbols

variable Text

variable Trapezoid

Functions

function Area

function Bar

function Brush

function CartesianGrid

function Customized

Returns

function DefaultTooltipContent

function Label

function LabelList

function Line

function Pie

function Scatter

function SunburstChart

function Tooltip

function Treemap

function useActiveTooltipDataPoints

Returns

function useActiveTooltipLabel

Returns

function useChartHeight

Returns

function useChartWidth

Returns

function useOffset

Returns

function usePlotArea

Returns

Classes

class CartesianAxis

constructor

property defaultProps

property displayName

property tickRefs

method getTickLineCoord

Parameter data

method getTickTextAnchor

method getTickVerticalAnchor

method render

method renderAxisLine

method renderTickItem

method renderTicks

Parameter fontSize

Parameter letterSpacing