recharts

recharts

Version 3.0.2
Published 8 days ago
5.28 MB
11 dependencies
MIT license

Install

npm i recharts

yarn add recharts

pnpm add recharts

Overview

React charts

Index

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<any>;

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 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 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 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.
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.

Classes

class Area

class Area extends PureComponent<Props> {}

property defaultProps

static defaultProps: {
    readonly activeDot: true;
    readonly animationBegin: 0;
    readonly animationDuration: 1500;
    readonly animationEasing: 'ease';
    readonly connectNulls: false;
    readonly dot: false;
    readonly fill: '#3182bd';
    readonly fillOpacity: 0.6;
    readonly hide: false;
    readonly isAnimationActive: boolean;
    readonly legendType: 'line';
    readonly stroke: '#3182bd';
    readonly xAxisId: 0;
    readonly yAxisId: 0;
};

property displayName

static displayName: string;

method render

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

class Bar

class Bar extends PureComponent<Props> {}

property defaultProps

static defaultProps: Partial<Props>;

property displayName

static displayName: string;

method render

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

class Brush

class Brush extends PureComponent<Props, State> {}

property defaultProps

static defaultProps: {
    height: number;
    travellerWidth: number;
    gap: number;
    fill: string;
    stroke: string;
    padding: { top: number; right: number; bottom: number; left: number };
    leaveTimeOut: number;
    alwaysShowText: boolean;
};

property displayName

static displayName: string;

method render

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

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' | 'start' | 'middle';

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 Line

class Line extends PureComponent<Props> {}

property defaultProps

static defaultProps: {
    readonly activeDot: true;
    readonly animateNewValues: true;
    readonly animationBegin: 0;
    readonly animationDuration: 1500;
    readonly animationEasing: 'ease';
    readonly connectNulls: false;
    readonly dot: true;
    readonly fill: '#fff';
    readonly hide: false;
    readonly isAnimationActive: boolean;
    readonly label: false;
    readonly legendType: 'line';
    readonly stroke: '#3182bd';
    readonly strokeWidth: 1;
    readonly xAxisId: 0;
    readonly yAxisId: 0;
};

property displayName

static displayName: string;

method render

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

class Pie

class Pie extends PureComponent<Props, State> {}

property defaultProps

static defaultProps: {
    readonly animationBegin: 400;
    readonly animationDuration: 1500;
    readonly animationEasing: 'ease';
    readonly cx: '50%';
    readonly cy: '50%';
    readonly dataKey: 'value';
    readonly endAngle: 360;
    readonly fill: '#808080';
    readonly hide: false;
    readonly innerRadius: 0;
    readonly isAnimationActive: boolean;
    readonly labelLine: true;
    readonly legendType: 'rect';
    readonly minAngle: 0;
    readonly nameKey: 'name';
    readonly outerRadius: '80%';
    readonly paddingAngle: 0;
    readonly rootTabIndex: 0;
    readonly startAngle: 0;
    readonly stroke: '#fff';
};

property displayName

static displayName: string;

property id

id: string;

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 Scatter

class Scatter extends Component<Props> {}

property defaultProps

static defaultProps: {
    readonly xAxisId: 0;
    readonly yAxisId: 0;
    readonly zAxisId: 0;
    readonly legendType: 'circle';
    readonly lineType: 'joint';
    readonly lineJointType: 'linear';
    readonly data: any[];
    readonly shape: 'circle';
    readonly hide: false;
    readonly isAnimationActive: boolean;
    readonly animationBegin: 0;
    readonly animationDuration: 400;
    readonly animationEasing: 'linear';
};

property displayName

static displayName: string;

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;

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 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 PolarAngleAxisProps

type Props = AxisSvgProps & PolarAngleAxisProps;

type PolarGridProps

type Props = SVGProps<SVGPathElement> & 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 = SVGProps<SVGPathElement> & Partial<SectorProps>;

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.
     */
    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;
    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 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[];

Package Files (59)

Dependencies (11)

Dev Dependencies (85)

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 7751 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 CartesianGrid

function Customized

Returns

function DefaultTooltipContent

function Label

function LabelList

function SunburstChart

function Tooltip

function Treemap

function useActiveTooltipLabel

Returns

function useChartHeight

Returns

function useChartWidth

Returns

Classes

class Area

property defaultProps

property displayName

method render

class Bar

property defaultProps

property displayName

method render

class Brush

property defaultProps

property displayName

method render

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