recharts

  • Version 3.1.2
  • Published
  • 5.41 MB
  • 11 dependencies
  • MIT license

Install

npm i recharts
yarn add recharts
pnpm add recharts

Overview

React charts

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

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;

                                                                          function Tooltip

                                                                          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 onejsDocs.io badgeto 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>