@antv/f2

  • Version 5.8.0
  • Published
  • 4.05 MB
  • 10 dependencies
  • MIT license

Install

npm i @antv/f2
yarn add @antv/f2
pnpm add @antv/f2

Overview

Charts for mobile visualization.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable _default

const _default: { version: string };

    variable ArcGuide

    const ArcGuide: any;

      variable Area

      const Area: new <
      TRecord extends DataRecord = DataRecord,
      IProps extends AreaProps<TRecord> = AreaProps<TRecord>
      >(
      props: IProps & ChartChildProps<DataRecord>,
      context?: any
      ) => {
      getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
      getBaseY(): any;
      mapping(): any[];
      render(): any;
      splitPoints(points: any): any[][];
      splitNulls(points: any, connectNulls: any): any[];
      concatPoints(
      topPoints: import('../../chart').Point[],
      bottomPoints: import('../../chart').Point[]
      ): import('../../chart').Point[];
      isGeometry: boolean;
      geomType: import('../geometry').GeometryType;
      attrs: any;
      adjust: import('../geometry/Adjust').AdjustProps & {
      adjust: import('../../deps/f2-adjust/src').Adjust;
      };
      dataArray: any;
      dataRecords: any[];
      records: any[];
      mappedArray: any;
      justifyContent: boolean;
      startOnZero: boolean;
      connectNulls: boolean;
      sortable: boolean;
      attrController: import('../../controller/attr').default;
      animation: any;
      getAttrOptions(props: any): {};
      willReceiveProps(nextProps: any): void;
      willMount(): void;
      willUpdate(): void;
      didMount(): void;
      _initEvent(): void;
      _createAttrs(): void;
      _getThemeAttrsRange(): {
      x: import('../../coord/types').Range;
      y: import('../../coord/types').Range;
      color: any;
      size: any;
      shape: any;
      };
      _createAdjust(): import('../geometry/Adjust').AdjustProps & {
      adjust: import('../../deps/f2-adjust/src').Adjust;
      };
      _adjustScales(): void;
      _groupData(data: any): any[];
      _saveOrigin(originData: any): any[];
      _numberic(data: any): void;
      _adjustData(records: any): any;
      _processData(): void;
      _readjustData(records: any): void;
      _sortData(records: any): void;
      getY0Value(): any;
      _getShapeStyle(shape: any, origin: any): any;
      _mapping(records: any): any[];
      getClip(): {
      type: string;
      style: { x: number; y: number; width: number; height: number };
      };
      getAttr(attrName: string): any;
      getXScale(): import('../..').Scale;
      getYScale(): import('../..').Scale;
      getColorScale(): import('../..').Scale;
      _getXSnap(invertPointX: any): any;
      _getYSnapRecords(invertPointY: any, records: any): any;
      _getXSnapRecords(invertPointX: any, records: any): any;
      flatRecords(): any;
      getSnapRecords(point: any, inCoordRange?: any): any[];
      getRecords(data: any, field?: string): any[];
      getLegendItems(): any;
      isSelected(record: any): boolean;
      getSelectionStyle(record: any): any;
      props: IProps & ChartChildProps<DataRecord>;
      state: import('../geometry/selection').SelectionState;
      context: any;
      refs: { [key: string]: any };
      updater: any;
      container: any;
      layout: any;
      children:
      | import('@antv/f-engine/es/canvas/vnode').VNode
      | import('@antv/f-engine/es/canvas/vnode').VNode[];
      isMounted: boolean;
      animate: boolean;
      animator: any;
      destroyed: boolean;
      _vNode: any;
      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
      didUpdate(): void;
      willUnmount(): void;
      didUnmount(): void;
      setState(
      partialState: import('../geometry/selection').SelectionState,
      callback?: () => void
      ): void;
      forceUpdate(callback?: () => void): void;
      setAnimate(animate: boolean): void;
      destroy(): void;
      };

        variable Axis

        const Axis: new <
        TRecord extends DataRecord = DataRecord,
        IProps extends AxisProps<TRecord, keyof TRecord> = AxisProps<
        TRecord,
        keyof TRecord
        >
        >(
        props: IProps & ChartChildProps<DataRecord>
        ) => {
        axisStyle: import('./types').Style<void>;
        willReceiveProps(nextProps: IProps & ChartChildProps<DataRecord>): void;
        willMount(): void;
        willUpdate(): void;
        getScaleOption(props: IProps): {
        type: string;
        tickCount: number;
        range: any;
        mask: string;
        formatter: (value: DataValue<TRecord, keyof TRecord>) => string | number;
        min: number;
        max: number;
        nice: boolean;
        ticks: any;
        };
        _getDimType(): 'x' | 'y';
        getMaxBBox(
        ticks: any,
        style: import('./types').Style<void>
        ): { height: number; width: number };
        _getPosition(): 'left' | 'top' | 'right' | 'bottom';
        getTicks(): import('../../deps/f2-scale/src').Tick[];
        _generateGridPoints(ticks: any): any;
        _setTicksStyle(ticks: any): any;
        convertTicks(ticks: any): any;
        measureLayout():
        | import('../../chart').PositionLayout
        | import('../../chart').PositionLayout[];
        updateCoord(): void;
        render(): any;
        props: IProps & ChartChildProps<DataRecord>;
        state: {};
        context: any;
        refs: { [key: string]: any };
        updater: any;
        container: any;
        layout: any;
        children:
        | import('@antv/f-engine/es/canvas/vnode').VNode
        | import('@antv/f-engine/es/canvas/vnode').VNode[];
        isMounted: boolean;
        animate: boolean;
        animator: any;
        destroyed: boolean;
        _vNode: any;
        didMount(): void;
        shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
        didUpdate(): void;
        willUnmount(): void;
        didUnmount(): void;
        setState(partialState: {}, callback?: () => void): void;
        forceUpdate(callback?: () => void): void;
        setAnimate(animate: boolean): void;
        destroy(): void;
        };

          variable Candlestick

          const Candlestick: new <
          TRecord extends DataRecord = DataRecord,
          IProps extends CandlestickProps<TRecord> = CandlestickProps<TRecord>
          >(
          props: IProps & ChartChildProps<DataRecord>,
          context?: any
          ) => {
          getDefaultCfg(): { geomType: string };
          getSize(): number;
          _getColor(colors: any, child: any, prevChild: any): any;
          mapping(): any[];
          render(): any;
          isGeometry: boolean;
          geomType: import('../geometry').GeometryType;
          attrs: any;
          adjust: import('../geometry/Adjust').AdjustProps & {
          adjust: import('../../deps/f2-adjust/src').Adjust;
          };
          dataArray: any;
          dataRecords: any[];
          records: any[];
          mappedArray: any;
          justifyContent: boolean;
          startOnZero: boolean;
          connectNulls: boolean;
          sortable: boolean;
          attrController: import('../../controller/attr').default;
          animation: any;
          getAttrOptions(props: any): {};
          willReceiveProps(nextProps: any): void;
          willMount(): void;
          willUpdate(): void;
          didMount(): void;
          _initEvent(): void;
          _createAttrs(): void;
          _getThemeAttrsRange(): {
          x: import('../../coord/types').Range;
          y: import('../../coord/types').Range;
          color: any;
          size: any;
          shape: any;
          };
          _createAdjust(): import('../geometry/Adjust').AdjustProps & {
          adjust: import('../../deps/f2-adjust/src').Adjust;
          };
          _adjustScales(): void;
          _groupData(data: any): any[];
          _saveOrigin(originData: any): any[];
          _numberic(data: any): void;
          _adjustData(records: any): any;
          _processData(): void;
          _readjustData(records: any): void;
          _sortData(records: any): void;
          getY0Value(): any;
          _getShapeStyle(shape: any, origin: any): any;
          _mapping(records: any): any[];
          getClip(): {
          type: string;
          style: { x: number; y: number; width: number; height: number };
          };
          getAttr(attrName: string): any;
          getXScale(): import('../..').Scale;
          getYScale(): import('../..').Scale;
          getColorScale(): import('../..').Scale;
          _getXSnap(invertPointX: any): any;
          _getYSnapRecords(invertPointY: any, records: any): any;
          _getXSnapRecords(invertPointX: any, records: any): any;
          flatRecords(): any;
          getSnapRecords(point: any, inCoordRange?: any): any[];
          getRecords(data: any, field?: string): any[];
          getLegendItems(): any;
          isSelected(record: any): boolean;
          getSelectionStyle(record: any): any;
          props: IProps & ChartChildProps<DataRecord>;
          state: import('../geometry/selection').SelectionState;
          context: any;
          refs: { [key: string]: any };
          updater: any;
          container: any;
          layout: any;
          children:
          | import('@antv/f-engine/es/canvas/vnode').VNode
          | import('@antv/f-engine/es/canvas/vnode').VNode[];
          isMounted: boolean;
          animate: boolean;
          animator: any;
          destroyed: boolean;
          _vNode: any;
          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
          didUpdate(): void;
          willUnmount(): void;
          didUnmount(): void;
          setState(
          partialState: import('../geometry/selection').SelectionState,
          callback?: () => void
          ): void;
          forceUpdate(callback?: () => void): void;
          setAnimate(animate: boolean): void;
          destroy(): void;
          };

            variable Gauge

            const Gauge: new <P extends GaugeProps = GaugeProps>(
            props: P,
            context?: any,
            updater?: any
            ) => {
            render(): any;
            props: P;
            state: any;
            context: any;
            refs: { [key: string]: any };
            updater: any;
            container: any;
            layout: any;
            children:
            | import('@antv/f-engine/es/canvas/vnode').VNode
            | import('@antv/f-engine/es/canvas/vnode').VNode[];
            isMounted: boolean;
            animate: boolean;
            animator: any;
            destroyed: boolean;
            _vNode: any;
            willMount(): void;
            didMount(): void;
            shouldUpdate(_nextProps: P): boolean;
            willReceiveProps(_props: P, _context?: any): void;
            willUpdate(): void;
            didUpdate(): void;
            willUnmount(): void;
            didUnmount(): void;
            setState(partialState: any, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            setAnimate(animate: boolean): void;
            destroy(): void;
            };

              variable Guide

              const Guide: any;

                variable ImageGuide

                const ImageGuide: any;

                  variable Interval

                  const Interval: new <
                  TRecord extends DataRecord = DataRecord,
                  IProps extends IntervalProps<TRecord> = IntervalProps<TRecord>
                  >(
                  props: IProps & ChartChildProps<DataRecord>,
                  context?: any
                  ) => {
                  getDefaultCfg(): {
                  geomType: string;
                  justifyContent: boolean;
                  startOnZero: boolean;
                  };
                  getDefaultSize(): number;
                  mapping(): any[];
                  getPointY0(): any;
                  render(): any;
                  isGeometry: boolean;
                  geomType: import('../geometry').GeometryType;
                  attrs: any;
                  adjust: import('../geometry/Adjust').AdjustProps & {
                  adjust: import('../../deps/f2-adjust/src').Adjust;
                  };
                  dataArray: any;
                  dataRecords: any[];
                  records: any[];
                  mappedArray: any;
                  justifyContent: boolean;
                  startOnZero: boolean;
                  connectNulls: boolean;
                  sortable: boolean;
                  attrController: import('../../controller/attr').default;
                  animation: any;
                  getAttrOptions(props: any): {};
                  willReceiveProps(nextProps: any): void;
                  willMount(): void;
                  willUpdate(): void;
                  didMount(): void;
                  _initEvent(): void;
                  _createAttrs(): void;
                  _getThemeAttrsRange(): {
                  x: import('../../coord/types').Range;
                  y: import('../../coord/types').Range;
                  color: any;
                  size: any;
                  shape: any;
                  };
                  _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                  adjust: import('../../deps/f2-adjust/src').Adjust;
                  };
                  _adjustScales(): void;
                  _groupData(data: any): any[];
                  _saveOrigin(originData: any): any[];
                  _numberic(data: any): void;
                  _adjustData(records: any): any;
                  _processData(): void;
                  _readjustData(records: any): void;
                  _sortData(records: any): void;
                  getY0Value(): any;
                  _getShapeStyle(shape: any, origin: any): any;
                  _mapping(records: any): any[];
                  getClip(): {
                  type: string;
                  style: { x: number; y: number; width: number; height: number };
                  };
                  getAttr(attrName: string): any;
                  getXScale(): import('../..').Scale;
                  getYScale(): import('../..').Scale;
                  getColorScale(): import('../..').Scale;
                  _getXSnap(invertPointX: any): any;
                  _getYSnapRecords(invertPointY: any, records: any): any;
                  _getXSnapRecords(invertPointX: any, records: any): any;
                  flatRecords(): any;
                  getSnapRecords(point: any, inCoordRange?: any): any[];
                  getRecords(data: any, field?: string): any[];
                  getLegendItems(): any;
                  isSelected(record: any): boolean;
                  getSelectionStyle(record: any): any;
                  props: IProps & ChartChildProps<DataRecord>;
                  state: import('../geometry/selection').SelectionState;
                  context: any;
                  refs: { [key: string]: any };
                  updater: any;
                  container: any;
                  layout: any;
                  children:
                  | import('@antv/f-engine/es/canvas/vnode').VNode
                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                  isMounted: boolean;
                  animate: boolean;
                  animator: any;
                  destroyed: boolean;
                  _vNode: any;
                  shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                  didUpdate(): void;
                  willUnmount(): void;
                  didUnmount(): void;
                  setState(
                  partialState: import('../geometry/selection').SelectionState,
                  callback?: () => void
                  ): void;
                  forceUpdate(callback?: () => void): void;
                  setAnimate(animate: boolean): void;
                  destroy(): void;
                  };

                    variable Legend

                    const Legend: new <IProps extends LegendProps = LegendProps>(props: any) => {
                    legendStyle: any;
                    itemWidth: Number;
                    getOriginItems(): any;
                    getItems(): any;
                    setItems(items: any): void;
                    getMaxItemBox(node: any): { width: number; height: number };
                    _init(): void;
                    updateCoord(): void;
                    willMount(): void;
                    didMount(): void;
                    willUpdate(): void;
                    _onclick: (item: any) => void;
                    render(): any;
                    props: IProps & ChartChildProps<DataRecord>;
                    state: any;
                    context: any;
                    refs: { [key: string]: any };
                    updater: any;
                    container: any;
                    layout: any;
                    children:
                    | import('@antv/f-engine/es/canvas/vnode').VNode
                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                    isMounted: boolean;
                    animate: boolean;
                    animator: any;
                    destroyed: boolean;
                    _vNode: any;
                    shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                    willReceiveProps(
                    _props: IProps & ChartChildProps<DataRecord>,
                    _context?: any
                    ): void;
                    didUpdate(): void;
                    willUnmount(): void;
                    didUnmount(): void;
                    setState(partialState: any, callback?: () => void): void;
                    forceUpdate(callback?: () => void): void;
                    setAnimate(animate: boolean): void;
                    destroy(): void;
                    };

                      variable Line

                      const Line: new <
                      TRecord extends DataRecord = DataRecord,
                      IProps extends LineProps<TRecord> = LineProps<TRecord>
                      >(
                      props: IProps & ChartChildProps<DataRecord>,
                      context?: any
                      ) => {
                      getDefaultCfg(): { geomType: string; sortable: boolean };
                      splitPoints(points: any): any[][];
                      splitNulls(points: any, connectNulls: any): any[];
                      mapping(): any[];
                      concatPoints(
                      topPoints: import('../../chart').Point[],
                      bottomPoints: import('../../chart').Point[]
                      ): import('../../chart').Point[];
                      render(): any;
                      isGeometry: boolean;
                      geomType: import('../geometry').GeometryType;
                      attrs: any;
                      adjust: import('../geometry/Adjust').AdjustProps & {
                      adjust: import('../../deps/f2-adjust/src').Adjust;
                      };
                      dataArray: any;
                      dataRecords: any[];
                      records: any[];
                      mappedArray: any;
                      justifyContent: boolean;
                      startOnZero: boolean;
                      connectNulls: boolean;
                      sortable: boolean;
                      attrController: import('../../controller/attr').default;
                      animation: any;
                      getAttrOptions(props: any): {};
                      willReceiveProps(nextProps: any): void;
                      willMount(): void;
                      willUpdate(): void;
                      didMount(): void;
                      _initEvent(): void;
                      _createAttrs(): void;
                      _getThemeAttrsRange(): {
                      x: import('../../coord/types').Range;
                      y: import('../../coord/types').Range;
                      color: any;
                      size: any;
                      shape: any;
                      };
                      _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                      adjust: import('../../deps/f2-adjust/src').Adjust;
                      };
                      _adjustScales(): void;
                      _groupData(data: any): any[];
                      _saveOrigin(originData: any): any[];
                      _numberic(data: any): void;
                      _adjustData(records: any): any;
                      _processData(): void;
                      _readjustData(records: any): void;
                      _sortData(records: any): void;
                      getY0Value(): any;
                      _getShapeStyle(shape: any, origin: any): any;
                      _mapping(records: any): any[];
                      getClip(): {
                      type: string;
                      style: { x: number; y: number; width: number; height: number };
                      };
                      getAttr(attrName: string): any;
                      getXScale(): import('../..').Scale;
                      getYScale(): import('../..').Scale;
                      getColorScale(): import('../..').Scale;
                      _getXSnap(invertPointX: any): any;
                      _getYSnapRecords(invertPointY: any, records: any): any;
                      _getXSnapRecords(invertPointX: any, records: any): any;
                      flatRecords(): any;
                      getSnapRecords(point: any, inCoordRange?: any): any[];
                      getRecords(data: any, field?: string): any[];
                      getLegendItems(): any;
                      isSelected(record: any): boolean;
                      getSelectionStyle(record: any): any;
                      props: IProps & ChartChildProps<DataRecord>;
                      state: import('../geometry/selection').SelectionState;
                      context: any;
                      refs: { [key: string]: any };
                      updater: any;
                      container: any;
                      layout: any;
                      children:
                      | import('@antv/f-engine/es/canvas/vnode').VNode
                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                      isMounted: boolean;
                      animate: boolean;
                      animator: any;
                      destroyed: boolean;
                      _vNode: any;
                      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                      didUpdate(): void;
                      willUnmount(): void;
                      didUnmount(): void;
                      setState(
                      partialState: import('../geometry/selection').SelectionState,
                      callback?: () => void
                      ): void;
                      forceUpdate(callback?: () => void): void;
                      setAnimate(animate: boolean): void;
                      destroy(): void;
                      };

                        variable LineGuide

                        const LineGuide: any;

                          variable LottieGuide

                          const LottieGuide: any;

                            variable PieLabel

                            const PieLabel: new <IProps extends PieLabelProps = PieLabelProps>(props: any) => {
                            labels: [];
                            willMount(): void;
                            didMount(): void;
                            getLabels(props: any): any[];
                            render(): any;
                            props: IProps & ChartChildProps<DataRecord>;
                            state: any;
                            context: any;
                            refs: { [key: string]: any };
                            updater: any;
                            container: any;
                            layout: any;
                            children:
                            | import('@antv/f-engine/es/canvas/vnode').VNode
                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                            isMounted: boolean;
                            animate: boolean;
                            animator: any;
                            destroyed: boolean;
                            _vNode: any;
                            shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                            willReceiveProps(
                            _props: IProps & ChartChildProps<DataRecord>,
                            _context?: any
                            ): void;
                            willUpdate(): void;
                            didUpdate(): void;
                            willUnmount(): void;
                            didUnmount(): void;
                            setState(partialState: any, callback?: () => void): void;
                            forceUpdate(callback?: () => void): void;
                            setAnimate(animate: boolean): void;
                            destroy(): void;
                            };

                              variable Point

                              const Point: new <
                              TRecord extends DataRecord = DataRecord,
                              IProps extends PointProps<TRecord> = PointProps<TRecord>
                              >(
                              props: IProps & ChartChildProps<DataRecord>,
                              context?: any
                              ) => {
                              getDefaultCfg(): { geomType: string };
                              render(): any;
                              isGeometry: boolean;
                              geomType: import('../geometry').GeometryType;
                              attrs: any;
                              adjust: import('../geometry/Adjust').AdjustProps & {
                              adjust: import('../../deps/f2-adjust/src').Adjust;
                              };
                              dataArray: any;
                              dataRecords: any[];
                              records: any[];
                              mappedArray: any;
                              justifyContent: boolean;
                              startOnZero: boolean;
                              connectNulls: boolean;
                              sortable: boolean;
                              attrController: import('../../controller/attr').default;
                              animation: any;
                              getAttrOptions(props: any): {};
                              willReceiveProps(nextProps: any): void;
                              willMount(): void;
                              willUpdate(): void;
                              didMount(): void;
                              _initEvent(): void;
                              _createAttrs(): void;
                              _getThemeAttrsRange(): {
                              x: import('../../coord/types').Range;
                              y: import('../../coord/types').Range;
                              color: any;
                              size: any;
                              shape: any;
                              };
                              _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                              adjust: import('../../deps/f2-adjust/src').Adjust;
                              };
                              _adjustScales(): void;
                              _groupData(data: any): any[];
                              _saveOrigin(originData: any): any[];
                              _numberic(data: any): void;
                              _adjustData(records: any): any;
                              _processData(): void;
                              _readjustData(records: any): void;
                              _sortData(records: any): void;
                              getY0Value(): any;
                              _getShapeStyle(shape: any, origin: any): any;
                              _mapping(records: any): any[];
                              mapping(): any[];
                              getClip(): {
                              type: string;
                              style: { x: number; y: number; width: number; height: number };
                              };
                              getAttr(attrName: string): any;
                              getXScale(): import('../..').Scale;
                              getYScale(): import('../..').Scale;
                              getColorScale(): import('../..').Scale;
                              _getXSnap(invertPointX: any): any;
                              _getYSnapRecords(invertPointY: any, records: any): any;
                              _getXSnapRecords(invertPointX: any, records: any): any;
                              flatRecords(): any;
                              getSnapRecords(point: any, inCoordRange?: any): any[];
                              getRecords(data: any, field?: string): any[];
                              getLegendItems(): any;
                              isSelected(record: any): boolean;
                              getSelectionStyle(record: any): any;
                              props: IProps & ChartChildProps<DataRecord>;
                              state: import('../geometry/selection').SelectionState;
                              context: any;
                              refs: { [key: string]: any };
                              updater: any;
                              container: any;
                              layout: any;
                              children:
                              | import('@antv/f-engine/es/canvas/vnode').VNode
                              | import('@antv/f-engine/es/canvas/vnode').VNode[];
                              isMounted: boolean;
                              animate: boolean;
                              animator: any;
                              destroyed: boolean;
                              _vNode: any;
                              shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                              didUpdate(): void;
                              willUnmount(): void;
                              didUnmount(): void;
                              setState(
                              partialState: import('../geometry/selection').SelectionState,
                              callback?: () => void
                              ): void;
                              forceUpdate(callback?: () => void): void;
                              setAnimate(animate: boolean): void;
                              destroy(): void;
                              };

                                variable PointGuide

                                const PointGuide: any;

                                  variable PolylineGuide

                                  const PolylineGuide: any;

                                    variable RectGuide

                                    const RectGuide: any;

                                      variable ScrollBar

                                      const ScrollBar: new (
                                      props: ScrollBarProps &
                                      import('../../chart').ChartChildProps<import('../../chart/Data').DataRecord>
                                      ) => {
                                      willMount(): any;
                                      render(): any;
                                      startRange: { x?: import('../zoom').ZoomRange; y?: import('../zoom').ZoomRange };
                                      scale: {};
                                      originScale: {};
                                      minScale: number;
                                      dims: String[];
                                      swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                      loop: number;
                                      didMount(): void;
                                      willReceiveProps(
                                      nextProps: ScrollBarProps &
                                      import('../../chart').ChartChildProps<
                                      import('../../chart/Data').DataRecord
                                      >
                                      ): void;
                                      willUpdate(): void;
                                      didUnmount(): void;
                                      _requestAnimationFrame(calllback: Function): number;
                                      _cancelAnimationFrame(): void;
                                      onPanStart: () => void;
                                      onPan: (ev: any) => void;
                                      onPanEnd: () => void;
                                      onPinchStart: () => void;
                                      onPinch: (ev: any) => void;
                                      onPinchEnd: () => void;
                                      _bindEvents(): void;
                                      _unBindEvents(): void;
                                      onStart: () => void;
                                      update(): void;
                                      animateSwipe(
                                      dim: string,
                                      dimRange: import('../zoom').ZoomRange,
                                      velocity: number
                                      ): void;
                                      onSwipe: (ev: any) => void;
                                      onEnd: () => void;
                                      _doXPan(ev: any): import('../zoom').ZoomRange;
                                      _doYPan(ev: any): import('../zoom').ZoomRange;
                                      _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                      _doXPinch(ev: any): any;
                                      _doYPinch(ev: any): any;
                                      _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                      updateRange(
                                      originalRange: import('../zoom').ZoomRange,
                                      dim: any
                                      ): import('../zoom').ZoomRange;
                                      updateFollow(
                                      scales: import('../..').Scale[],
                                      mainScale: import('../..').Scale,
                                      data: any[]
                                      ): void;
                                      _getScale(dim: any): any;
                                      _getFollowScales(dim: any): any[];
                                      renderRange(range: any): void;
                                      props: ScrollBarProps &
                                      import('../../chart').ChartChildProps<import('../../chart/Data').DataRecord>;
                                      state: import('../zoom').ZoomState;
                                      context: any;
                                      refs: { [key: string]: any };
                                      updater: any;
                                      container: any;
                                      layout: any;
                                      children:
                                      | import('@antv/f-engine/es/canvas/vnode').VNode
                                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                      isMounted: boolean;
                                      animate: boolean;
                                      animator: any;
                                      destroyed: boolean;
                                      _vNode: any;
                                      shouldUpdate(
                                      _nextProps: ScrollBarProps &
                                      import('../../chart').ChartChildProps<
                                      import('../../chart/Data').DataRecord
                                      >
                                      ): boolean;
                                      didUpdate(): void;
                                      willUnmount(): void;
                                      setState(partialState: import('../zoom').ZoomState, callback?: () => void): void;
                                      forceUpdate(callback?: () => void): void;
                                      setAnimate(animate: boolean): void;
                                      destroy(): void;
                                      };

                                        variable Sunburst

                                        const Sunburst: new <
                                        TRecord extends DataRecord = DataRecord,
                                        IProps extends SunburstProps<TRecord> = SunburstProps<TRecord>
                                        >(
                                        props: IProps,
                                        context: any
                                        ) => {
                                        coord: import('../../controller/coord').default;
                                        color: import('../../attr/category').default;
                                        triggerRef: import('@antv/f-engine').Ref<any>[];
                                        willMount(): void;
                                        didMount(): void;
                                        _mapping(children: any): void;
                                        sunburst(): any;
                                        render(): any;
                                        props: IProps;
                                        state: any;
                                        context: any;
                                        refs: { [key: string]: any };
                                        updater: any;
                                        container: any;
                                        layout: any;
                                        children:
                                        | import('@antv/f-engine/es/canvas/vnode').VNode
                                        | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                        isMounted: boolean;
                                        animate: boolean;
                                        animator: any;
                                        destroyed: boolean;
                                        _vNode: any;
                                        shouldUpdate(_nextProps: IProps): boolean;
                                        willReceiveProps(_props: IProps, _context?: any): void;
                                        willUpdate(): void;
                                        didUpdate(): void;
                                        willUnmount(): void;
                                        didUnmount(): void;
                                        setState(partialState: any, callback?: () => void): void;
                                        forceUpdate(callback?: () => void): void;
                                        setAnimate(animate: boolean): void;
                                        destroy(): void;
                                        };

                                          variable TagGuide

                                          const TagGuide: any;

                                            variable TextGuide

                                            const TextGuide: any;

                                              variable Tooltip

                                              const Tooltip: new <IProps extends TooltipProps = TooltipProps>(
                                              props: IProps & ChartChildProps<DataRecord>
                                              ) => {
                                              updateCoord(): void;
                                              willMount(): void;
                                              didMount(): void;
                                              _initEvent(): void;
                                              willReceiveProps(nextProps: any): void;
                                              _initShow(): void;
                                              _showByData(dataItem: any): void;
                                              _triggerOn: (ev: any) => void;
                                              _triggerOff: () => void;
                                              show(point: any, _ev?: any): void;
                                              showSnapRecords(snapRecords: any): void;
                                              hide(): void;
                                              render(): any;
                                              props: IProps & ChartChildProps<DataRecord>;
                                              state: import('./withTooltip').TooltipState;
                                              context: any;
                                              refs: { [key: string]: any };
                                              updater: any;
                                              container: any;
                                              layout: any;
                                              children:
                                              | import('@antv/f-engine/es/canvas/vnode').VNode
                                              | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                              isMounted: boolean;
                                              animate: boolean;
                                              animator: any;
                                              destroyed: boolean;
                                              _vNode: any;
                                              shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                              willUpdate(): void;
                                              didUpdate(): void;
                                              willUnmount(): void;
                                              didUnmount(): void;
                                              setState(
                                              partialState: import('./withTooltip').TooltipState,
                                              callback?: () => void
                                              ): void;
                                              forceUpdate(callback?: () => void): void;
                                              setAnimate(animate: boolean): void;
                                              destroy(): void;
                                              };

                                                variable Treemap

                                                const Treemap: new <
                                                TRecord extends DataRecord = DataRecord,
                                                P extends TreemapProps<TRecord> = TreemapProps<TRecord>
                                                >(
                                                props: P & TreemapProps<DataRecord>,
                                                context: any
                                                ) => {
                                                coord: import('../../controller/coord').default;
                                                color: import('../../attr/category').default;
                                                coordRef: any;
                                                records: import('./withTreemap').RecordNode<
                                                import('../../chart/Data').DataRecord
                                                >[];
                                                isSelected(record: any): boolean;
                                                getSelectionStyle(record: any): any;
                                                willMount(): void;
                                                willReceiveProps(nextProps: P): void;
                                                treemapLayout(): import('./withTreemap').RecordNode<
                                                import('../../chart/Data').DataRecord
                                                >[];
                                                select(ev: any, trigger: any): void;
                                                render(): any;
                                                props: P & TreemapProps<DataRecord>;
                                                state: any;
                                                context: any;
                                                refs: { [key: string]: any };
                                                updater: any;
                                                container: any;
                                                layout: any;
                                                children:
                                                | import('@antv/f-engine/es/canvas/vnode').VNode
                                                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                isMounted: boolean;
                                                animate: boolean;
                                                animator: any;
                                                destroyed: boolean;
                                                _vNode: any;
                                                didMount(): void;
                                                shouldUpdate(_nextProps: P & TreemapProps<DataRecord>): boolean;
                                                willUpdate(): void;
                                                didUpdate(): void;
                                                willUnmount(): void;
                                                didUnmount(): void;
                                                setState(partialState: any, callback?: () => void): void;
                                                forceUpdate(callback?: () => void): void;
                                                setAnimate(animate: boolean): void;
                                                destroy(): void;
                                                };

                                                  Functions

                                                  function AreaView

                                                  AreaView: (props: any) => any;

                                                    function AxisView

                                                    AxisView: (props: PolarAxisProps | RectAxisProps) => any;

                                                      function CandlestickView

                                                      CandlestickView: (props: any) => any;

                                                        function GaugeView

                                                        GaugeView: (props: GaugeProps) => any;

                                                          function IntervalView

                                                          IntervalView: (props: any) => any;

                                                            function LegendView

                                                            LegendView: (props: any) => any;

                                                              function LineView

                                                              LineView: (props: any) => any;

                                                                function PieLabelView

                                                                PieLabelView: (props: any) => any;

                                                                  function PointView

                                                                  PointView: (props: any) => any;

                                                                    function ScrollBarView

                                                                    ScrollBarView: (props: any) => any;

                                                                      function SunburstView

                                                                      SunburstView: (props: any) => any;

                                                                        function TreemapView

                                                                        TreemapView: (props: TreemapProps<DataRecord> & { coord: Coord }) => any;

                                                                          function withArea

                                                                          withArea: (
                                                                          View: any
                                                                          ) => new <
                                                                          TRecord extends DataRecord = DataRecord,
                                                                          IProps extends AreaProps<TRecord> = AreaProps<TRecord>
                                                                          >(
                                                                          props: IProps & ChartChildProps<DataRecord>,
                                                                          context?: any
                                                                          ) => {
                                                                          getDefaultCfg(): { geomType: string; startOnZero: boolean; sortable: boolean };
                                                                          getBaseY(): any;
                                                                          mapping(): any[];
                                                                          render(): any;
                                                                          splitPoints(points: any): any[][];
                                                                          splitNulls(points: any, connectNulls: any): any[];
                                                                          concatPoints(
                                                                          topPoints: import('../../chart').Point[],
                                                                          bottomPoints: import('../../chart').Point[]
                                                                          ): import('../../chart').Point[];
                                                                          isGeometry: boolean;
                                                                          geomType: import('../geometry').GeometryType;
                                                                          attrs: any;
                                                                          adjust: import('../geometry/Adjust').AdjustProps & {
                                                                          adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                          };
                                                                          dataArray: any;
                                                                          dataRecords: any[];
                                                                          records: any[];
                                                                          mappedArray: any;
                                                                          justifyContent: boolean;
                                                                          startOnZero: boolean;
                                                                          connectNulls: boolean;
                                                                          sortable: boolean;
                                                                          attrController: import('../../controller/attr').default;
                                                                          animation: any;
                                                                          getAttrOptions(props: any): {};
                                                                          willReceiveProps(nextProps: any): void;
                                                                          willMount(): void;
                                                                          willUpdate(): void;
                                                                          didMount(): void;
                                                                          _initEvent(): void;
                                                                          _createAttrs(): void;
                                                                          _getThemeAttrsRange(): {
                                                                          x: import('../../coord/types').Range;
                                                                          y: import('../../coord/types').Range;
                                                                          color: any;
                                                                          size: any;
                                                                          shape: any;
                                                                          };
                                                                          _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                          adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                          };
                                                                          _adjustScales(): void;
                                                                          _groupData(data: any): any[];
                                                                          _saveOrigin(originData: any): any[];
                                                                          _numberic(data: any): void;
                                                                          _adjustData(records: any): any;
                                                                          _processData(): void;
                                                                          _readjustData(records: any): void;
                                                                          _sortData(records: any): void;
                                                                          getY0Value(): any;
                                                                          _getShapeStyle(shape: any, origin: any): any;
                                                                          _mapping(records: any): any[];
                                                                          getClip(): {
                                                                          type: string;
                                                                          style: { x: number; y: number; width: number; height: number };
                                                                          };
                                                                          getAttr(attrName: string): any;
                                                                          getXScale(): import('../..').Scale;
                                                                          getYScale(): import('../..').Scale;
                                                                          getColorScale(): import('../..').Scale;
                                                                          _getXSnap(invertPointX: any): any;
                                                                          _getYSnapRecords(invertPointY: any, records: any): any;
                                                                          _getXSnapRecords(invertPointX: any, records: any): any;
                                                                          flatRecords(): any;
                                                                          getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                          getRecords(data: any, field?: string): any[];
                                                                          getLegendItems(): any;
                                                                          isSelected(record: any): boolean;
                                                                          getSelectionStyle(record: any): any;
                                                                          props: IProps & ChartChildProps<DataRecord>;
                                                                          state: import('../geometry/selection').SelectionState;
                                                                          context: any;
                                                                          refs: { [key: string]: any };
                                                                          updater: any;
                                                                          container: any;
                                                                          layout: any;
                                                                          children:
                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                          isMounted: boolean;
                                                                          animate: boolean;
                                                                          animator: any;
                                                                          destroyed: boolean;
                                                                          _vNode: any;
                                                                          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                          didUpdate(): void;
                                                                          willUnmount(): void;
                                                                          didUnmount(): void;
                                                                          setState(
                                                                          partialState: import('../geometry/selection').SelectionState,
                                                                          callback?: () => void
                                                                          ): void;
                                                                          forceUpdate(callback?: () => void): void;
                                                                          setAnimate(animate: boolean): void;
                                                                          destroy(): void;
                                                                          };

                                                                            function withAxis

                                                                            withAxis: (
                                                                            View: any
                                                                            ) => new <
                                                                            TRecord extends DataRecord = DataRecord,
                                                                            IProps extends AxisProps<TRecord, keyof TRecord> = AxisProps<
                                                                            TRecord,
                                                                            keyof TRecord
                                                                            >
                                                                            >(
                                                                            props: IProps & ChartChildProps<DataRecord>
                                                                            ) => {
                                                                            axisStyle: Style;
                                                                            willReceiveProps(nextProps: IProps & ChartChildProps<DataRecord>): void;
                                                                            willMount(): void;
                                                                            willUpdate(): void;
                                                                            getScaleOption(props: IProps): {
                                                                            type: string;
                                                                            tickCount: number;
                                                                            range: any;
                                                                            mask: string;
                                                                            formatter: (value: DataValue<TRecord, keyof TRecord>) => string | number;
                                                                            min: number;
                                                                            max: number;
                                                                            nice: boolean;
                                                                            ticks: any;
                                                                            };
                                                                            _getDimType(): 'x' | 'y';
                                                                            getMaxBBox(ticks: any, style: Style): BBox;
                                                                            _getPosition(): 'left' | 'top' | 'right' | 'bottom';
                                                                            getTicks(): import('../../deps/f2-scale/src').Tick[];
                                                                            _generateGridPoints(ticks: any): any;
                                                                            _setTicksStyle(ticks: any): any;
                                                                            convertTicks(ticks: any): any;
                                                                            measureLayout(): PositionLayout | PositionLayout[];
                                                                            updateCoord(): void;
                                                                            render(): any;
                                                                            props: IProps & ChartChildProps<DataRecord>;
                                                                            state: {};
                                                                            context: any;
                                                                            refs: { [key: string]: Component<any, any> };
                                                                            updater: any;
                                                                            container: any;
                                                                            layout: any;
                                                                            children:
                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                            isMounted: boolean;
                                                                            animate: boolean;
                                                                            animator: any;
                                                                            destroyed: boolean;
                                                                            _vNode: any;
                                                                            didMount(): void;
                                                                            shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                            didUpdate(): void;
                                                                            willUnmount(): void;
                                                                            didUnmount(): void;
                                                                            setState(partialState: {}, callback?: () => void): void;
                                                                            forceUpdate(callback?: () => void): void;
                                                                            setAnimate(animate: boolean): void;
                                                                            destroy(): void;
                                                                            };

                                                                              function withCandlestick

                                                                              withCandlestick: (
                                                                              View: ComponentType
                                                                              ) => new <
                                                                              TRecord extends DataRecord = DataRecord,
                                                                              IProps extends CandlestickProps<TRecord> = CandlestickProps<TRecord>
                                                                              >(
                                                                              props: IProps & ChartChildProps<DataRecord>,
                                                                              context?: any
                                                                              ) => {
                                                                              getDefaultCfg(): { geomType: string };
                                                                              getSize(): number;
                                                                              _getColor(colors: any, child: any, prevChild: any): any;
                                                                              mapping(): any[];
                                                                              render(): any;
                                                                              isGeometry: boolean;
                                                                              geomType: import('../geometry').GeometryType;
                                                                              attrs: any;
                                                                              adjust: import('../geometry/Adjust').AdjustProps & {
                                                                              adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                              };
                                                                              dataArray: any;
                                                                              dataRecords: any[];
                                                                              records: any[];
                                                                              mappedArray: any;
                                                                              justifyContent: boolean;
                                                                              startOnZero: boolean;
                                                                              connectNulls: boolean;
                                                                              sortable: boolean;
                                                                              attrController: import('../../controller/attr').default;
                                                                              animation: any;
                                                                              getAttrOptions(props: any): {};
                                                                              willReceiveProps(nextProps: any): void;
                                                                              willMount(): void;
                                                                              willUpdate(): void;
                                                                              didMount(): void;
                                                                              _initEvent(): void;
                                                                              _createAttrs(): void;
                                                                              _getThemeAttrsRange(): {
                                                                              x: import('../../coord/types').Range;
                                                                              y: import('../../coord/types').Range;
                                                                              color: any;
                                                                              size: any;
                                                                              shape: any;
                                                                              };
                                                                              _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                              adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                              };
                                                                              _adjustScales(): void;
                                                                              _groupData(data: any): any[];
                                                                              _saveOrigin(originData: any): any[];
                                                                              _numberic(data: any): void;
                                                                              _adjustData(records: any): any;
                                                                              _processData(): void;
                                                                              _readjustData(records: any): void;
                                                                              _sortData(records: any): void;
                                                                              getY0Value(): any;
                                                                              _getShapeStyle(shape: any, origin: any): any;
                                                                              _mapping(records: any): any[];
                                                                              getClip(): {
                                                                              type: string;
                                                                              style: { x: number; y: number; width: number; height: number };
                                                                              };
                                                                              getAttr(attrName: string): any;
                                                                              getXScale(): import('../..').Scale;
                                                                              getYScale(): import('../..').Scale;
                                                                              getColorScale(): import('../..').Scale;
                                                                              _getXSnap(invertPointX: any): any;
                                                                              _getYSnapRecords(invertPointY: any, records: any): any;
                                                                              _getXSnapRecords(invertPointX: any, records: any): any;
                                                                              flatRecords(): any;
                                                                              getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                              getRecords(data: any, field?: string): any[];
                                                                              getLegendItems(): any;
                                                                              isSelected(record: any): boolean;
                                                                              getSelectionStyle(record: any): any;
                                                                              props: IProps & ChartChildProps<DataRecord>;
                                                                              state: import('../geometry/selection').SelectionState;
                                                                              context: any;
                                                                              refs: { [key: string]: any };
                                                                              updater: any;
                                                                              container: any;
                                                                              layout: any;
                                                                              children:
                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                              isMounted: boolean;
                                                                              animate: boolean;
                                                                              animator: any;
                                                                              destroyed: boolean;
                                                                              _vNode: any;
                                                                              shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                              didUpdate(): void;
                                                                              willUnmount(): void;
                                                                              didUnmount(): void;
                                                                              setState(
                                                                              partialState: import('../geometry/selection').SelectionState,
                                                                              callback?: () => void
                                                                              ): void;
                                                                              forceUpdate(callback?: () => void): void;
                                                                              setAnimate(animate: boolean): void;
                                                                              destroy(): void;
                                                                              };

                                                                                function withGauge

                                                                                withGauge: <IProps extends GaugeProps = GaugeProps>(
                                                                                View: ComponentType<IProps>
                                                                                ) => new <P extends IProps = IProps>(props: P, context?: any, updater?: any) => {
                                                                                render(): any;
                                                                                props: P;
                                                                                state: any;
                                                                                context: any;
                                                                                refs: { [key: string]: Component<any, any> };
                                                                                updater: any;
                                                                                container: any;
                                                                                layout: any;
                                                                                children:
                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                isMounted: boolean;
                                                                                animate: boolean;
                                                                                animator: any;
                                                                                destroyed: boolean;
                                                                                _vNode: any;
                                                                                willMount(): void;
                                                                                didMount(): void;
                                                                                shouldUpdate(_nextProps: P): boolean;
                                                                                willReceiveProps(_props: P, _context?: any): void;
                                                                                willUpdate(): void;
                                                                                didUpdate(): void;
                                                                                willUnmount(): void;
                                                                                didUnmount(): void;
                                                                                setState(partialState: any, callback?: () => void): void;
                                                                                forceUpdate(callback?: () => void): void;
                                                                                setAnimate(animate: boolean): void;
                                                                                destroy(): void;
                                                                                };

                                                                                  function withGuide

                                                                                  withGuide: <IProps extends GuideProps = GuideProps>(
                                                                                  View: ComponentType<IProps & ChartChildProps<DataRecord>>
                                                                                  ) => ComponentType<IProps & ChartChildProps<DataRecord>>;

                                                                                    function withInterval

                                                                                    withInterval: (
                                                                                    Views: any
                                                                                    ) => new <
                                                                                    TRecord extends DataRecord = DataRecord,
                                                                                    IProps extends IntervalProps<TRecord> = IntervalProps<TRecord>
                                                                                    >(
                                                                                    props: IProps & ChartChildProps<DataRecord>,
                                                                                    context?: any
                                                                                    ) => {
                                                                                    getDefaultCfg(): {
                                                                                    geomType: string;
                                                                                    justifyContent: boolean;
                                                                                    startOnZero: boolean;
                                                                                    };
                                                                                    getDefaultSize(): number;
                                                                                    mapping(): any[];
                                                                                    getPointY0(): any;
                                                                                    render(): any;
                                                                                    isGeometry: boolean;
                                                                                    geomType: import('../geometry').GeometryType;
                                                                                    attrs: any;
                                                                                    adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                    adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                    };
                                                                                    dataArray: any;
                                                                                    dataRecords: any[];
                                                                                    records: any[];
                                                                                    mappedArray: any;
                                                                                    justifyContent: boolean;
                                                                                    startOnZero: boolean;
                                                                                    connectNulls: boolean;
                                                                                    sortable: boolean;
                                                                                    attrController: import('../../controller/attr').default;
                                                                                    animation: any;
                                                                                    getAttrOptions(props: any): {};
                                                                                    willReceiveProps(nextProps: any): void;
                                                                                    willMount(): void;
                                                                                    willUpdate(): void;
                                                                                    didMount(): void;
                                                                                    _initEvent(): void;
                                                                                    _createAttrs(): void;
                                                                                    _getThemeAttrsRange(): {
                                                                                    x: import('../../coord/types').Range;
                                                                                    y: import('../../coord/types').Range;
                                                                                    color: any;
                                                                                    size: any;
                                                                                    shape: any;
                                                                                    };
                                                                                    _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                    adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                    };
                                                                                    _adjustScales(): void;
                                                                                    _groupData(data: any): any[];
                                                                                    _saveOrigin(originData: any): any[];
                                                                                    _numberic(data: any): void;
                                                                                    _adjustData(records: any): any;
                                                                                    _processData(): void;
                                                                                    _readjustData(records: any): void;
                                                                                    _sortData(records: any): void;
                                                                                    getY0Value(): any;
                                                                                    _getShapeStyle(shape: any, origin: any): any;
                                                                                    _mapping(records: any): any[];
                                                                                    getClip(): {
                                                                                    type: string;
                                                                                    style: { x: number; y: number; width: number; height: number };
                                                                                    };
                                                                                    getAttr(attrName: string): any;
                                                                                    getXScale(): import('../..').Scale;
                                                                                    getYScale(): import('../..').Scale;
                                                                                    getColorScale(): import('../..').Scale;
                                                                                    _getXSnap(invertPointX: any): any;
                                                                                    _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                    _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                    flatRecords(): any;
                                                                                    getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                    getRecords(data: any, field?: string): any[];
                                                                                    getLegendItems(): any;
                                                                                    isSelected(record: any): boolean;
                                                                                    getSelectionStyle(record: any): any;
                                                                                    props: IProps & ChartChildProps<DataRecord>;
                                                                                    state: import('../geometry/selection').SelectionState;
                                                                                    context: any;
                                                                                    refs: { [key: string]: any };
                                                                                    updater: any;
                                                                                    container: any;
                                                                                    layout: any;
                                                                                    children:
                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                    isMounted: boolean;
                                                                                    animate: boolean;
                                                                                    animator: any;
                                                                                    destroyed: boolean;
                                                                                    _vNode: any;
                                                                                    shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                    didUpdate(): void;
                                                                                    willUnmount(): void;
                                                                                    didUnmount(): void;
                                                                                    setState(
                                                                                    partialState: import('../geometry/selection').SelectionState,
                                                                                    callback?: () => void
                                                                                    ): void;
                                                                                    forceUpdate(callback?: () => void): void;
                                                                                    setAnimate(animate: boolean): void;
                                                                                    destroy(): void;
                                                                                    };

                                                                                      function withLegend

                                                                                      withLegend: (
                                                                                      View: any
                                                                                      ) => new <IProps extends LegendProps = LegendProps>(props: any) => {
                                                                                      legendStyle: GroupStyleProps;
                                                                                      itemWidth: Number;
                                                                                      getOriginItems(): any;
                                                                                      getItems(): any;
                                                                                      setItems(items: any): void;
                                                                                      getMaxItemBox(node: any): { width: number; height: number };
                                                                                      _init(): void;
                                                                                      updateCoord(): void;
                                                                                      willMount(): void;
                                                                                      didMount(): void;
                                                                                      willUpdate(): void;
                                                                                      _onclick: (item: any) => void;
                                                                                      render(): any;
                                                                                      props: IProps & ChartChildProps<DataRecord>;
                                                                                      state: any;
                                                                                      context: any;
                                                                                      refs: { [key: string]: Component<any, any> };
                                                                                      updater: any;
                                                                                      container: any;
                                                                                      layout: any;
                                                                                      children:
                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                      isMounted: boolean;
                                                                                      animate: boolean;
                                                                                      animator: any;
                                                                                      destroyed: boolean;
                                                                                      _vNode: any;
                                                                                      shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                      willReceiveProps(
                                                                                      _props: IProps & ChartChildProps<DataRecord>,
                                                                                      _context?: any
                                                                                      ): void;
                                                                                      didUpdate(): void;
                                                                                      willUnmount(): void;
                                                                                      didUnmount(): void;
                                                                                      setState(partialState: any, callback?: () => void): void;
                                                                                      forceUpdate(callback?: () => void): void;
                                                                                      setAnimate(animate: boolean): void;
                                                                                      destroy(): void;
                                                                                      };

                                                                                        function withLine

                                                                                        withLine: (
                                                                                        View: any
                                                                                        ) => new <
                                                                                        TRecord extends DataRecord = DataRecord,
                                                                                        IProps extends LineProps<TRecord> = LineProps<TRecord>
                                                                                        >(
                                                                                        props: IProps & ChartChildProps<DataRecord>,
                                                                                        context?: any
                                                                                        ) => {
                                                                                        getDefaultCfg(): { geomType: string; sortable: boolean };
                                                                                        splitPoints(points: any): any[][];
                                                                                        splitNulls(points: any, connectNulls: any): any[];
                                                                                        mapping(): any[];
                                                                                        concatPoints(topPoints: Point[], bottomPoints: Point[]): Point[];
                                                                                        render(): any;
                                                                                        isGeometry: boolean;
                                                                                        geomType: import('../geometry').GeometryType;
                                                                                        attrs: any;
                                                                                        adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                        adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                        };
                                                                                        dataArray: any;
                                                                                        dataRecords: any[];
                                                                                        records: any[];
                                                                                        mappedArray: any;
                                                                                        justifyContent: boolean;
                                                                                        startOnZero: boolean;
                                                                                        connectNulls: boolean;
                                                                                        sortable: boolean;
                                                                                        attrController: import('../../controller/attr').default;
                                                                                        animation: any;
                                                                                        getAttrOptions(props: any): {};
                                                                                        willReceiveProps(nextProps: any): void;
                                                                                        willMount(): void;
                                                                                        willUpdate(): void;
                                                                                        didMount(): void;
                                                                                        _initEvent(): void;
                                                                                        _createAttrs(): void;
                                                                                        _getThemeAttrsRange(): {
                                                                                        x: import('../../coord/types').Range;
                                                                                        y: import('../../coord/types').Range;
                                                                                        color: any;
                                                                                        size: any;
                                                                                        shape: any;
                                                                                        };
                                                                                        _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                        adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                        };
                                                                                        _adjustScales(): void;
                                                                                        _groupData(data: any): any[];
                                                                                        _saveOrigin(originData: any): any[];
                                                                                        _numberic(data: any): void;
                                                                                        _adjustData(records: any): any;
                                                                                        _processData(): void;
                                                                                        _readjustData(records: any): void;
                                                                                        _sortData(records: any): void;
                                                                                        getY0Value(): any;
                                                                                        _getShapeStyle(shape: any, origin: any): any;
                                                                                        _mapping(records: any): any[];
                                                                                        getClip(): {
                                                                                        type: string;
                                                                                        style: { x: number; y: number; width: number; height: number };
                                                                                        };
                                                                                        getAttr(attrName: string): any;
                                                                                        getXScale(): import('../..').Scale;
                                                                                        getYScale(): import('../..').Scale;
                                                                                        getColorScale(): import('../..').Scale;
                                                                                        _getXSnap(invertPointX: any): any;
                                                                                        _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                        _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                        flatRecords(): any;
                                                                                        getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                        getRecords(data: any, field?: string): any[];
                                                                                        getLegendItems(): any;
                                                                                        isSelected(record: any): boolean;
                                                                                        getSelectionStyle(record: any): any;
                                                                                        props: IProps & ChartChildProps<DataRecord>;
                                                                                        state: import('../geometry/selection').SelectionState;
                                                                                        context: any;
                                                                                        refs: { [key: string]: any };
                                                                                        updater: any;
                                                                                        container: any;
                                                                                        layout: any;
                                                                                        children:
                                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                        | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                        isMounted: boolean;
                                                                                        animate: boolean;
                                                                                        animator: any;
                                                                                        destroyed: boolean;
                                                                                        _vNode: any;
                                                                                        shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                        didUpdate(): void;
                                                                                        willUnmount(): void;
                                                                                        didUnmount(): void;
                                                                                        setState(
                                                                                        partialState: import('../geometry/selection').SelectionState,
                                                                                        callback?: () => void
                                                                                        ): void;
                                                                                        forceUpdate(callback?: () => void): void;
                                                                                        setAnimate(animate: boolean): void;
                                                                                        destroy(): void;
                                                                                        };

                                                                                          function withPieLabel

                                                                                          withPieLabel: (
                                                                                          View: any
                                                                                          ) => new <IProps extends PieLabelProps = PieLabelProps>(props: any) => {
                                                                                          labels: [];
                                                                                          willMount(): void;
                                                                                          didMount(): void;
                                                                                          getLabels(props: any): any[];
                                                                                          render(): any;
                                                                                          props: IProps & ChartChildProps<DataRecord>;
                                                                                          state: any;
                                                                                          context: any;
                                                                                          refs: { [key: string]: Component<any, any> };
                                                                                          updater: any;
                                                                                          container: any;
                                                                                          layout: any;
                                                                                          children:
                                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                          | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                          isMounted: boolean;
                                                                                          animate: boolean;
                                                                                          animator: any;
                                                                                          destroyed: boolean;
                                                                                          _vNode: any;
                                                                                          shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                          willReceiveProps(
                                                                                          _props: IProps & ChartChildProps<DataRecord>,
                                                                                          _context?: any
                                                                                          ): void;
                                                                                          willUpdate(): void;
                                                                                          didUpdate(): void;
                                                                                          willUnmount(): void;
                                                                                          didUnmount(): void;
                                                                                          setState(partialState: any, callback?: () => void): void;
                                                                                          forceUpdate(callback?: () => void): void;
                                                                                          setAnimate(animate: boolean): void;
                                                                                          destroy(): void;
                                                                                          };

                                                                                            function withPoint

                                                                                            withPoint: (
                                                                                            View: any
                                                                                            ) => new <
                                                                                            TRecord extends DataRecord = DataRecord,
                                                                                            IProps extends PointProps<TRecord> = PointProps<TRecord>
                                                                                            >(
                                                                                            props: IProps & ChartChildProps<DataRecord>,
                                                                                            context?: any
                                                                                            ) => {
                                                                                            getDefaultCfg(): { geomType: string };
                                                                                            render(): any;
                                                                                            isGeometry: boolean;
                                                                                            geomType: import('../geometry').GeometryType;
                                                                                            attrs: any;
                                                                                            adjust: import('../geometry/Adjust').AdjustProps & {
                                                                                            adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                            };
                                                                                            dataArray: any;
                                                                                            dataRecords: any[];
                                                                                            records: any[];
                                                                                            mappedArray: any;
                                                                                            justifyContent: boolean;
                                                                                            startOnZero: boolean;
                                                                                            connectNulls: boolean;
                                                                                            sortable: boolean;
                                                                                            attrController: import('../../controller/attr').default;
                                                                                            animation: any;
                                                                                            getAttrOptions(props: any): {};
                                                                                            willReceiveProps(nextProps: any): void;
                                                                                            willMount(): void;
                                                                                            willUpdate(): void;
                                                                                            didMount(): void;
                                                                                            _initEvent(): void;
                                                                                            _createAttrs(): void;
                                                                                            _getThemeAttrsRange(): {
                                                                                            x: import('../../coord/types').Range;
                                                                                            y: import('../../coord/types').Range;
                                                                                            color: any;
                                                                                            size: any;
                                                                                            shape: any;
                                                                                            };
                                                                                            _createAdjust(): import('../geometry/Adjust').AdjustProps & {
                                                                                            adjust: import('../../deps/f2-adjust/src').Adjust;
                                                                                            };
                                                                                            _adjustScales(): void;
                                                                                            _groupData(data: any): any[];
                                                                                            _saveOrigin(originData: any): any[];
                                                                                            _numberic(data: any): void;
                                                                                            _adjustData(records: any): any;
                                                                                            _processData(): void;
                                                                                            _readjustData(records: any): void;
                                                                                            _sortData(records: any): void;
                                                                                            getY0Value(): any;
                                                                                            _getShapeStyle(shape: any, origin: any): any;
                                                                                            _mapping(records: any): any[];
                                                                                            mapping(): any[];
                                                                                            getClip(): {
                                                                                            type: string;
                                                                                            style: { x: number; y: number; width: number; height: number };
                                                                                            };
                                                                                            getAttr(attrName: string): any;
                                                                                            getXScale(): import('../..').Scale;
                                                                                            getYScale(): import('../..').Scale;
                                                                                            getColorScale(): import('../..').Scale;
                                                                                            _getXSnap(invertPointX: any): any;
                                                                                            _getYSnapRecords(invertPointY: any, records: any): any;
                                                                                            _getXSnapRecords(invertPointX: any, records: any): any;
                                                                                            flatRecords(): any;
                                                                                            getSnapRecords(point: any, inCoordRange?: any): any[];
                                                                                            getRecords(data: any, field?: string): any[];
                                                                                            getLegendItems(): any;
                                                                                            isSelected(record: any): boolean;
                                                                                            getSelectionStyle(record: any): any;
                                                                                            props: IProps & ChartChildProps<DataRecord>;
                                                                                            state: import('../geometry/selection').SelectionState;
                                                                                            context: any;
                                                                                            refs: { [key: string]: any };
                                                                                            updater: any;
                                                                                            container: any;
                                                                                            layout: any;
                                                                                            children:
                                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                            | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                            isMounted: boolean;
                                                                                            animate: boolean;
                                                                                            animator: any;
                                                                                            destroyed: boolean;
                                                                                            _vNode: any;
                                                                                            shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                            didUpdate(): void;
                                                                                            willUnmount(): void;
                                                                                            didUnmount(): void;
                                                                                            setState(
                                                                                            partialState: import('../geometry/selection').SelectionState,
                                                                                            callback?: () => void
                                                                                            ): void;
                                                                                            forceUpdate(callback?: () => void): void;
                                                                                            setAnimate(animate: boolean): void;
                                                                                            destroy(): void;
                                                                                            };

                                                                                              function withScrollBar

                                                                                              withScrollBar: (
                                                                                              View: any
                                                                                              ) => new (
                                                                                              props: ScrollBarProps & ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                              ) => {
                                                                                              willMount(): any;
                                                                                              render(): any;
                                                                                              startRange: { x?: import('../zoom').ZoomRange; y?: import('../zoom').ZoomRange };
                                                                                              scale: {};
                                                                                              originScale: {};
                                                                                              minScale: number;
                                                                                              dims: String[];
                                                                                              swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                                                                              loop: number;
                                                                                              didMount(): void;
                                                                                              willReceiveProps(
                                                                                              nextProps: ScrollBarProps &
                                                                                              ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                              ): void;
                                                                                              willUpdate(): void;
                                                                                              didUnmount(): void;
                                                                                              _requestAnimationFrame(calllback: Function): number;
                                                                                              _cancelAnimationFrame(): void;
                                                                                              onPanStart: () => void;
                                                                                              onPan: (ev: any) => void;
                                                                                              onPanEnd: () => void;
                                                                                              onPinchStart: () => void;
                                                                                              onPinch: (ev: any) => void;
                                                                                              onPinchEnd: () => void;
                                                                                              _bindEvents(): void;
                                                                                              _unBindEvents(): void;
                                                                                              onStart: () => void;
                                                                                              update(): void;
                                                                                              animateSwipe(
                                                                                              dim: string,
                                                                                              dimRange: import('../zoom').ZoomRange,
                                                                                              velocity: number
                                                                                              ): void;
                                                                                              onSwipe: (ev: any) => void;
                                                                                              onEnd: () => void;
                                                                                              _doXPan(ev: any): import('../zoom').ZoomRange;
                                                                                              _doYPan(ev: any): import('../zoom').ZoomRange;
                                                                                              _doPan(ratio: number, dim: string): import('../zoom').ZoomRange;
                                                                                              _doXPinch(ev: any): any;
                                                                                              _doYPinch(ev: any): any;
                                                                                              _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                                                                              updateRange(
                                                                                              originalRange: import('../zoom').ZoomRange,
                                                                                              dim: any
                                                                                              ): import('../zoom').ZoomRange;
                                                                                              updateFollow(
                                                                                              scales: import('../..').Scale[],
                                                                                              mainScale: import('../..').Scale,
                                                                                              data: any[]
                                                                                              ): void;
                                                                                              _getScale(dim: any): any;
                                                                                              _getFollowScales(dim: any): any[];
                                                                                              renderRange(range: any): void;
                                                                                              props: ScrollBarProps & ChartChildProps<import('../../chart/Data').DataRecord>;
                                                                                              state: import('../zoom').ZoomState;
                                                                                              context: any;
                                                                                              refs: { [key: string]: any };
                                                                                              updater: any;
                                                                                              container: any;
                                                                                              layout: any;
                                                                                              children:
                                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                              | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                              isMounted: boolean;
                                                                                              animate: boolean;
                                                                                              animator: any;
                                                                                              destroyed: boolean;
                                                                                              _vNode: any;
                                                                                              shouldUpdate(
                                                                                              _nextProps: ScrollBarProps &
                                                                                              ChartChildProps<import('../../chart/Data').DataRecord>
                                                                                              ): boolean;
                                                                                              didUpdate(): void;
                                                                                              willUnmount(): void;
                                                                                              setState(partialState: import('../zoom').ZoomState, callback?: () => void): void;
                                                                                              forceUpdate(callback?: () => void): void;
                                                                                              setAnimate(animate: boolean): void;
                                                                                              destroy(): void;
                                                                                              };

                                                                                                function withSunburst

                                                                                                withSunburst: (
                                                                                                View: any
                                                                                                ) => new <
                                                                                                TRecord extends DataRecord = DataRecord,
                                                                                                IProps extends SunburstProps<TRecord> = SunburstProps<TRecord>
                                                                                                >(
                                                                                                props: IProps,
                                                                                                context: any
                                                                                                ) => {
                                                                                                coord: CoordController;
                                                                                                color: Category;
                                                                                                triggerRef: Ref[];
                                                                                                willMount(): void;
                                                                                                didMount(): void;
                                                                                                _mapping(children: any): void;
                                                                                                sunburst(): any;
                                                                                                render(): any;
                                                                                                props: IProps;
                                                                                                state: any;
                                                                                                context: any;
                                                                                                refs: { [key: string]: Component<any, any> };
                                                                                                updater: any;
                                                                                                container: any;
                                                                                                layout: any;
                                                                                                children:
                                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                isMounted: boolean;
                                                                                                animate: boolean;
                                                                                                animator: any;
                                                                                                destroyed: boolean;
                                                                                                _vNode: any;
                                                                                                shouldUpdate(_nextProps: IProps): boolean;
                                                                                                willReceiveProps(_props: IProps, _context?: any): void;
                                                                                                willUpdate(): void;
                                                                                                didUpdate(): void;
                                                                                                willUnmount(): void;
                                                                                                didUnmount(): void;
                                                                                                setState(partialState: any, callback?: () => void): void;
                                                                                                forceUpdate(callback?: () => void): void;
                                                                                                setAnimate(animate: boolean): void;
                                                                                                destroy(): void;
                                                                                                };

                                                                                                  function withTooltip

                                                                                                  withTooltip: (
                                                                                                  View: any
                                                                                                  ) => new <IProps extends TooltipProps = TooltipProps>(
                                                                                                  props: IProps & ChartChildProps<DataRecord>
                                                                                                  ) => {
                                                                                                  updateCoord(): void;
                                                                                                  willMount(): void;
                                                                                                  didMount(): void;
                                                                                                  _initEvent(): void;
                                                                                                  willReceiveProps(nextProps: any): void;
                                                                                                  _initShow(): void;
                                                                                                  _showByData(dataItem: any): void;
                                                                                                  _triggerOn: (ev: any) => void;
                                                                                                  _triggerOff: () => void;
                                                                                                  show(point: any, _ev?: any): void;
                                                                                                  showSnapRecords(snapRecords: any): void;
                                                                                                  hide(): void;
                                                                                                  render(): any;
                                                                                                  props: IProps & ChartChildProps<DataRecord>;
                                                                                                  state: TooltipState;
                                                                                                  context: any;
                                                                                                  refs: { [key: string]: Component<any, any> };
                                                                                                  updater: any;
                                                                                                  container: any;
                                                                                                  layout: any;
                                                                                                  children:
                                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                  | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                  isMounted: boolean;
                                                                                                  animate: boolean;
                                                                                                  animator: any;
                                                                                                  destroyed: boolean;
                                                                                                  _vNode: any;
                                                                                                  shouldUpdate(_nextProps: IProps & ChartChildProps<DataRecord>): boolean;
                                                                                                  willUpdate(): void;
                                                                                                  didUpdate(): void;
                                                                                                  willUnmount(): void;
                                                                                                  didUnmount(): void;
                                                                                                  setState(partialState: TooltipState, callback?: () => void): void;
                                                                                                  forceUpdate(callback?: () => void): void;
                                                                                                  setAnimate(animate: boolean): void;
                                                                                                  destroy(): void;
                                                                                                  };

                                                                                                    function withTreemap

                                                                                                    withTreemap: <
                                                                                                    IProps extends TreemapProps<DataRecord> = TreemapProps<DataRecord>
                                                                                                    >(
                                                                                                    View: ComponentType<IProps>
                                                                                                    ) => new <
                                                                                                    TRecord extends DataRecord = DataRecord,
                                                                                                    P extends TreemapProps<TRecord> = TreemapProps<TRecord>
                                                                                                    >(
                                                                                                    props: P & IProps,
                                                                                                    context: any
                                                                                                    ) => {
                                                                                                    coord: CoordController;
                                                                                                    color: Category;
                                                                                                    coordRef: Ref;
                                                                                                    records: RecordNode<DataRecord>[];
                                                                                                    isSelected(record: any): boolean;
                                                                                                    getSelectionStyle(record: any): any;
                                                                                                    willMount(): void;
                                                                                                    willReceiveProps(nextProps: P): void;
                                                                                                    treemapLayout(): RecordNode[];
                                                                                                    select(ev: any, trigger: any): void;
                                                                                                    render(): any;
                                                                                                    props: P & IProps;
                                                                                                    state: any;
                                                                                                    context: any;
                                                                                                    refs: { [key: string]: Component<any, any> };
                                                                                                    updater: any;
                                                                                                    container: any;
                                                                                                    layout: any;
                                                                                                    children:
                                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                    | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                    isMounted: boolean;
                                                                                                    animate: boolean;
                                                                                                    animator: any;
                                                                                                    destroyed: boolean;
                                                                                                    _vNode: any;
                                                                                                    didMount(): void;
                                                                                                    shouldUpdate(_nextProps: P & IProps): boolean;
                                                                                                    willUpdate(): void;
                                                                                                    didUpdate(): void;
                                                                                                    willUnmount(): void;
                                                                                                    didUnmount(): void;
                                                                                                    setState(partialState: any, callback?: () => void): void;
                                                                                                    forceUpdate(callback?: () => void): void;
                                                                                                    setAnimate(animate: boolean): void;
                                                                                                    destroy(): void;
                                                                                                    };

                                                                                                      function Zoom

                                                                                                      Zoom: (
                                                                                                      View: any
                                                                                                      ) => new <P extends ZoomProps = ZoomProps, S extends ZoomState = ZoomState>(
                                                                                                      props: P
                                                                                                      ) => {
                                                                                                      startRange: { x?: ZoomRange; y?: ZoomRange };
                                                                                                      scale: {};
                                                                                                      originScale: {};
                                                                                                      minScale: number;
                                                                                                      dims: Array<String>;
                                                                                                      swipeEnd: { startX: number; startY: number; endX: number; endY: number };
                                                                                                      loop: number;
                                                                                                      didMount(): void;
                                                                                                      willReceiveProps(nextProps: P): void;
                                                                                                      willMount(): void;
                                                                                                      willUpdate(): void;
                                                                                                      didUnmount(): void;
                                                                                                      _requestAnimationFrame(calllback: Function): number;
                                                                                                      _cancelAnimationFrame(): void;
                                                                                                      onPanStart: () => void;
                                                                                                      onPan: (ev: any) => void;
                                                                                                      onPanEnd: () => void;
                                                                                                      onPinchStart: () => void;
                                                                                                      onPinch: (ev: any) => void;
                                                                                                      onPinchEnd: () => void;
                                                                                                      _bindEvents(): void;
                                                                                                      _unBindEvents(): void;
                                                                                                      onStart: () => void;
                                                                                                      update(): void;
                                                                                                      animateSwipe(dim: string, dimRange: ZoomRange, velocity: number): void;
                                                                                                      onSwipe: (ev: any) => void;
                                                                                                      onEnd: () => void;
                                                                                                      _doXPan(ev: any): ZoomRange;
                                                                                                      _doYPan(ev: any): ZoomRange;
                                                                                                      _doPan(ratio: number, dim: string): ZoomRange;
                                                                                                      _doXPinch(ev: any): any;
                                                                                                      _doYPinch(ev: any): any;
                                                                                                      _doPinch(startRatio: number, endRatio: number, zoom: number, dim: string): any;
                                                                                                      updateRange(originalRange: ZoomRange, dim: any): ZoomRange;
                                                                                                      updateFollow(scales: Scale[], mainScale: Scale, data: any[]): void;
                                                                                                      _getScale(dim: any): any;
                                                                                                      _getFollowScales(dim: any): any[];
                                                                                                      renderRange(range: any): void;
                                                                                                      render(): any;
                                                                                                      props: P & ChartChildProps<DataRecord>;
                                                                                                      state: S;
                                                                                                      context: any;
                                                                                                      refs: { [key: string]: Component<any, any> };
                                                                                                      updater: any;
                                                                                                      container: any;
                                                                                                      layout: any;
                                                                                                      children:
                                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode
                                                                                                      | import('@antv/f-engine/es/canvas/vnode').VNode[];
                                                                                                      isMounted: boolean;
                                                                                                      animate: boolean;
                                                                                                      animator: any;
                                                                                                      destroyed: boolean;
                                                                                                      _vNode: any;
                                                                                                      shouldUpdate(_nextProps: P & ChartChildProps<DataRecord>): boolean;
                                                                                                      didUpdate(): void;
                                                                                                      willUnmount(): void;
                                                                                                      setState(partialState: S, callback?: () => void): void;
                                                                                                      forceUpdate(callback?: () => void): void;
                                                                                                      setAnimate(animate: boolean): void;
                                                                                                      destroy(): void;
                                                                                                      };

                                                                                                        Classes

                                                                                                        class Chart

                                                                                                        class Chart<
                                                                                                        TRecord extends DataRecord = DataRecord,
                                                                                                        IProps extends ChartProps<TRecord> = ChartProps<TRecord>
                                                                                                        > extends Component<IProps, ChartState> {}

                                                                                                          constructor

                                                                                                          constructor(props: ChartProps<TRecord>, context?: IContext);

                                                                                                            property adjust

                                                                                                            adjust: any;

                                                                                                              property coord

                                                                                                              coord: CoordController;

                                                                                                                property coordRef

                                                                                                                coordRef: Ref;

                                                                                                                  property scale

                                                                                                                  scale: ScaleController;

                                                                                                                    method filter

                                                                                                                    filter: (field: string, condition: any) => void;

                                                                                                                      method getColorScales

                                                                                                                      getColorScales: () => any[];

                                                                                                                        method getCoord

                                                                                                                        getCoord: () => Coord;

                                                                                                                          method getGeometrys

                                                                                                                          getGeometrys: () => Component<
                                                                                                                          import('@antv/f-engine').IProps,
                                                                                                                          import('@antv/f-engine').IState
                                                                                                                          >[];

                                                                                                                            method getLayout

                                                                                                                            getLayout: () => import('../controller/coord').Layout;

                                                                                                                              method getLegendItems

                                                                                                                              getLegendItems: (point?: any) => any;

                                                                                                                                method getPosition

                                                                                                                                getPosition: (record: any) => { x: any; y: any };
                                                                                                                                • calculate dataset's position on canvas

                                                                                                                                  Parameter record

                                                                                                                                  the dataset {Object} return the position

                                                                                                                                method getRecords

                                                                                                                                getRecords: (data: any, field: any) => any;

                                                                                                                                  method getScale

                                                                                                                                  getScale: (field: string) => import('../deps/f2-scale/src').Scale;

                                                                                                                                    method getScales

                                                                                                                                    getScales: () => { [field: string]: Scale };

                                                                                                                                      method getSnapRecords

                                                                                                                                      getSnapRecords: (point: any, inCoordRange?: any) => any;

                                                                                                                                        method getXScales

                                                                                                                                        getXScales: () => any[];

                                                                                                                                          method getYScales

                                                                                                                                          getYScales: () => any[];

                                                                                                                                            method layoutCoord

                                                                                                                                            layoutCoord: (layout: PositionLayout) => void;

                                                                                                                                              method off

                                                                                                                                              off: (eventName: string, listener: (...args: any[]) => void) => void;

                                                                                                                                                method on

                                                                                                                                                on: (eventName: string, listener: (...args: any[]) => void) => void;

                                                                                                                                                  method removeComponentsPositionCache

                                                                                                                                                  removeComponentsPositionCache: () => void;

                                                                                                                                                    method render

                                                                                                                                                    render: () => any;

                                                                                                                                                      method resetCoordLayout

                                                                                                                                                      resetCoordLayout: () => void;

                                                                                                                                                        method setScale

                                                                                                                                                        setScale: (field: string, option: ScaleConfig) => void;

                                                                                                                                                          method updateAdjust

                                                                                                                                                          updateAdjust: (adjust: any) => void;

                                                                                                                                                            method updateCoordFor

                                                                                                                                                            updateCoordFor: (
                                                                                                                                                            component: Component,
                                                                                                                                                            layout: PositionLayout | PositionLayout[]
                                                                                                                                                            ) => void;

                                                                                                                                                              method updateCoordLayout

                                                                                                                                                              updateCoordLayout: (layout: PositionLayout | PositionLayout[]) => void;

                                                                                                                                                                method willMount

                                                                                                                                                                willMount: () => void;

                                                                                                                                                                  method willReceiveProps

                                                                                                                                                                  willReceiveProps: (nextProps: IProps, context: any) => void;

                                                                                                                                                                    method willUpdate

                                                                                                                                                                    willUpdate: () => void;

                                                                                                                                                                      class Geometry

                                                                                                                                                                      class Geometry<
                                                                                                                                                                      TRecord extends DataRecord = DataRecord,
                                                                                                                                                                      P extends GeometryProps<TRecord> = GeometryProps<TRecord>,
                                                                                                                                                                      S extends SelectionState = SelectionState
                                                                                                                                                                      > extends Selection<P & ChartChildProps, S> {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(
                                                                                                                                                                        props: GeometryProps<TRecord> & ChartChildProps<DataRecord>,
                                                                                                                                                                        context?: any
                                                                                                                                                                        );

                                                                                                                                                                          property adjust

                                                                                                                                                                          adjust: AdjustProps & { adjust: Adjust };

                                                                                                                                                                            property animation

                                                                                                                                                                            animation: AnimationProps;

                                                                                                                                                                              property attrController

                                                                                                                                                                              attrController: AttrController;

                                                                                                                                                                                property attrs

                                                                                                                                                                                attrs: any;

                                                                                                                                                                                  property connectNulls

                                                                                                                                                                                  connectNulls: boolean;

                                                                                                                                                                                    property dataArray

                                                                                                                                                                                    dataArray: any;

                                                                                                                                                                                      property dataRecords

                                                                                                                                                                                      dataRecords: any[];

                                                                                                                                                                                        property geomType

                                                                                                                                                                                        geomType: GeometryType;

                                                                                                                                                                                          property isGeometry

                                                                                                                                                                                          isGeometry: boolean;

                                                                                                                                                                                            property justifyContent

                                                                                                                                                                                            justifyContent: boolean;

                                                                                                                                                                                              property mappedArray

                                                                                                                                                                                              mappedArray: any;

                                                                                                                                                                                                property records

                                                                                                                                                                                                records: any[];

                                                                                                                                                                                                  property sortable

                                                                                                                                                                                                  sortable: boolean;

                                                                                                                                                                                                    property startOnZero

                                                                                                                                                                                                    startOnZero: boolean;

                                                                                                                                                                                                      method didMount

                                                                                                                                                                                                      didMount: () => void;

                                                                                                                                                                                                        method flatRecords

                                                                                                                                                                                                        flatRecords: () => any;

                                                                                                                                                                                                          method getAttr

                                                                                                                                                                                                          getAttr: (attrName: string) => any;

                                                                                                                                                                                                            method getAttrOptions

                                                                                                                                                                                                            getAttrOptions: (props: any) => {};

                                                                                                                                                                                                              method getClip

                                                                                                                                                                                                              getClip: () => {
                                                                                                                                                                                                              type: string;
                                                                                                                                                                                                              style: { x: number; y: number; width: number; height: number };
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method getColorScale

                                                                                                                                                                                                                getColorScale: () => Scale;

                                                                                                                                                                                                                  method getDefaultCfg

                                                                                                                                                                                                                  getDefaultCfg: () => {};

                                                                                                                                                                                                                    method getLegendItems

                                                                                                                                                                                                                    getLegendItems: () => any;

                                                                                                                                                                                                                      method getRecords

                                                                                                                                                                                                                      getRecords: (data: any, field?: string) => any[];

                                                                                                                                                                                                                        method getSnapRecords

                                                                                                                                                                                                                        getSnapRecords: (point: any, inCoordRange?: any) => any[];

                                                                                                                                                                                                                          method getXScale

                                                                                                                                                                                                                          getXScale: () => Scale;

                                                                                                                                                                                                                            method getY0Value

                                                                                                                                                                                                                            getY0Value: () => any;

                                                                                                                                                                                                                              method getYScale

                                                                                                                                                                                                                              getYScale: () => Scale;

                                                                                                                                                                                                                                method mapping

                                                                                                                                                                                                                                mapping: () => any[];

                                                                                                                                                                                                                                  method willMount

                                                                                                                                                                                                                                  willMount: () => void;

                                                                                                                                                                                                                                    method willReceiveProps

                                                                                                                                                                                                                                    willReceiveProps: (nextProps: any) => void;

                                                                                                                                                                                                                                      method willUpdate

                                                                                                                                                                                                                                      willUpdate: () => void;

                                                                                                                                                                                                                                        class Pictorial

                                                                                                                                                                                                                                        class Pictorial extends Pictorial_base {}

                                                                                                                                                                                                                                          property props

                                                                                                                                                                                                                                          props: PictorialProps<DataRecord>;

                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                              class Scale

                                                                                                                                                                                                                                              abstract class Scale {}

                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                cfg: Partial<{
                                                                                                                                                                                                                                                field: string;
                                                                                                                                                                                                                                                values: any[];
                                                                                                                                                                                                                                                min: any;
                                                                                                                                                                                                                                                max: any;
                                                                                                                                                                                                                                                minLimit?: any;
                                                                                                                                                                                                                                                maxLimit?: any;
                                                                                                                                                                                                                                                alias: string;
                                                                                                                                                                                                                                                range: number[];
                                                                                                                                                                                                                                                base: number;
                                                                                                                                                                                                                                                exponent: number;
                                                                                                                                                                                                                                                nice: boolean;
                                                                                                                                                                                                                                                ticks: any[];
                                                                                                                                                                                                                                                tickInterval: number;
                                                                                                                                                                                                                                                minTickInterval: number;
                                                                                                                                                                                                                                                tickCount: number;
                                                                                                                                                                                                                                                maxTickCount: number;
                                                                                                                                                                                                                                                formatter: (value: any, index?: number) => any;
                                                                                                                                                                                                                                                tickMethod: string | TickMethod;
                                                                                                                                                                                                                                                mask?: string;
                                                                                                                                                                                                                                                showLast?: boolean;
                                                                                                                                                                                                                                                }>
                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                  property alias

                                                                                                                                                                                                                                                  alias?: string;

                                                                                                                                                                                                                                                    property field

                                                                                                                                                                                                                                                    field?: string;

                                                                                                                                                                                                                                                      property formatter

                                                                                                                                                                                                                                                      formatter?: (value: any, index?: number) => any;

                                                                                                                                                                                                                                                        property isCategory

                                                                                                                                                                                                                                                        isCategory?: boolean;
                                                                                                                                                                                                                                                        • 是否分类类型的度量

                                                                                                                                                                                                                                                        property isContinuous

                                                                                                                                                                                                                                                        isContinuous?: boolean;
                                                                                                                                                                                                                                                        • 是否连续类型的度量,linear,time,log, pow, quantile, quantize 都支持

                                                                                                                                                                                                                                                        property isIdentity

                                                                                                                                                                                                                                                        isIdentity: boolean;
                                                                                                                                                                                                                                                        • 是否是常量的度量,传入和传出一致

                                                                                                                                                                                                                                                        property isLinear

                                                                                                                                                                                                                                                        isLinear?: boolean;
                                                                                                                                                                                                                                                        • 是否线性度量,有linear, time 度量

                                                                                                                                                                                                                                                        property max

                                                                                                                                                                                                                                                        max?: any;

                                                                                                                                                                                                                                                          property maxLimit

                                                                                                                                                                                                                                                          maxLimit?: any;

                                                                                                                                                                                                                                                            property min

                                                                                                                                                                                                                                                            min?: any;

                                                                                                                                                                                                                                                              property minLimit

                                                                                                                                                                                                                                                              minLimit?: any;

                                                                                                                                                                                                                                                                property range

                                                                                                                                                                                                                                                                range: number[];

                                                                                                                                                                                                                                                                  property tickCount

                                                                                                                                                                                                                                                                  tickCount: number;

                                                                                                                                                                                                                                                                    property tickInterval

                                                                                                                                                                                                                                                                    tickInterval: number;

                                                                                                                                                                                                                                                                      property tickMethod

                                                                                                                                                                                                                                                                      tickMethod?: string | TickMethod;

                                                                                                                                                                                                                                                                        property ticks

                                                                                                                                                                                                                                                                        ticks: any[];

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                          • 度量的类型

                                                                                                                                                                                                                                                                          property values

                                                                                                                                                                                                                                                                          values: any[];

                                                                                                                                                                                                                                                                            method calcPercent

                                                                                                                                                                                                                                                                            protected calcPercent: (value: any, min: number, max: number) => number;
                                                                                                                                                                                                                                                                            • 定义域转 0~1

                                                                                                                                                                                                                                                                            method calculateTicks

                                                                                                                                                                                                                                                                            protected calculateTicks: () => any[];

                                                                                                                                                                                                                                                                              method calcValue

                                                                                                                                                                                                                                                                              protected calcValue: (percent: number, min: number, max: number) => number;
                                                                                                                                                                                                                                                                              • 0~1转定义域

                                                                                                                                                                                                                                                                              method change

                                                                                                                                                                                                                                                                              change: (cfg: ScaleConfig) => void;
                                                                                                                                                                                                                                                                              • 重新初始化

                                                                                                                                                                                                                                                                              method clone

                                                                                                                                                                                                                                                                              clone: () => Scale;

                                                                                                                                                                                                                                                                                method getConfig

                                                                                                                                                                                                                                                                                protected getConfig: (key: any) => any;

                                                                                                                                                                                                                                                                                  method getText

                                                                                                                                                                                                                                                                                  getText: (value: any, key?: number) => string;
                                                                                                                                                                                                                                                                                  • 获取Tick的格式化结果

                                                                                                                                                                                                                                                                                  method getTicks

                                                                                                                                                                                                                                                                                  getTicks: () => Tick[];
                                                                                                                                                                                                                                                                                  • 获取坐标轴需要的ticks

                                                                                                                                                                                                                                                                                  method init

                                                                                                                                                                                                                                                                                  protected init: () => void;

                                                                                                                                                                                                                                                                                    method initCfg

                                                                                                                                                                                                                                                                                    protected initCfg: () => void;

                                                                                                                                                                                                                                                                                      method invert

                                                                                                                                                                                                                                                                                      abstract invert: (scaled: number) => any;
                                                                                                                                                                                                                                                                                      • 将值域转换为定义域

                                                                                                                                                                                                                                                                                      method rangeMax

                                                                                                                                                                                                                                                                                      protected rangeMax: () => number;

                                                                                                                                                                                                                                                                                        method rangeMin

                                                                                                                                                                                                                                                                                        protected rangeMin: () => number;

                                                                                                                                                                                                                                                                                          method scale

                                                                                                                                                                                                                                                                                          abstract scale: (value: any) => number;
                                                                                                                                                                                                                                                                                          • 将定义域转换为值域

                                                                                                                                                                                                                                                                                          method setDomain

                                                                                                                                                                                                                                                                                          protected setDomain: () => void;

                                                                                                                                                                                                                                                                                            method translate

                                                                                                                                                                                                                                                                                            translate: (v: any) => any;

                                                                                                                                                                                                                                                                                              class TooltipView

                                                                                                                                                                                                                                                                                              class TooltipView extends Component {}

                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                  interface AxisProps

                                                                                                                                                                                                                                                                                                  interface AxisProps<
                                                                                                                                                                                                                                                                                                  TRecord extends DataRecord = DataRecord,
                                                                                                                                                                                                                                                                                                  TField extends DataField<TRecord> = DataField<TRecord>
                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                    property field

                                                                                                                                                                                                                                                                                                    field: TField;
                                                                                                                                                                                                                                                                                                    • 映射的字段名称

                                                                                                                                                                                                                                                                                                    property formatter

                                                                                                                                                                                                                                                                                                    formatter?: (value: DataValue<TRecord, TField>) => string | number;
                                                                                                                                                                                                                                                                                                    • 回调函数,用于格式化坐标轴刻度点的文本显示, 会影响数据在坐标轴 axis、图例 legend、提示信息 tooltip 上的显示。

                                                                                                                                                                                                                                                                                                    property grid

                                                                                                                                                                                                                                                                                                    grid?: 'arc' | 'line';

                                                                                                                                                                                                                                                                                                      property mask

                                                                                                                                                                                                                                                                                                      mask?: string;

                                                                                                                                                                                                                                                                                                        property max

                                                                                                                                                                                                                                                                                                        max?: number;

                                                                                                                                                                                                                                                                                                          property min

                                                                                                                                                                                                                                                                                                          min?: number;

                                                                                                                                                                                                                                                                                                            property nice

                                                                                                                                                                                                                                                                                                            nice?: boolean;

                                                                                                                                                                                                                                                                                                              property position

                                                                                                                                                                                                                                                                                                              position?: 'right' | 'left' | 'top' | 'bottom';
                                                                                                                                                                                                                                                                                                              • 坐标轴显示位置

                                                                                                                                                                                                                                                                                                              property range

                                                                                                                                                                                                                                                                                                              range?: any;

                                                                                                                                                                                                                                                                                                                property style

                                                                                                                                                                                                                                                                                                                style?: StyleProps;
                                                                                                                                                                                                                                                                                                                • 坐标轴样式定制

                                                                                                                                                                                                                                                                                                                property tickCount

                                                                                                                                                                                                                                                                                                                tickCount?: number;

                                                                                                                                                                                                                                                                                                                  property ticks

                                                                                                                                                                                                                                                                                                                  ticks?: Array;

                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                    type?: string;

                                                                                                                                                                                                                                                                                                                      property visible

                                                                                                                                                                                                                                                                                                                      visible?: boolean;
                                                                                                                                                                                                                                                                                                                      • 是否显示该坐标轴

                                                                                                                                                                                                                                                                                                                      interface CandlestickProps

                                                                                                                                                                                                                                                                                                                      interface CandlestickProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                      extends GeometryProps<TRecord> {}

                                                                                                                                                                                                                                                                                                                        property sizeRatio

                                                                                                                                                                                                                                                                                                                        sizeRatio?: number;
                                                                                                                                                                                                                                                                                                                        • 柱子的显示比例,默认 0.5

                                                                                                                                                                                                                                                                                                                        interface ChartProps

                                                                                                                                                                                                                                                                                                                        interface ChartProps<TRecord extends DataRecord = DataRecord> {}

                                                                                                                                                                                                                                                                                                                          property children

                                                                                                                                                                                                                                                                                                                          children?: any;

                                                                                                                                                                                                                                                                                                                            property coord

                                                                                                                                                                                                                                                                                                                            coord?: CoordType | CoordProps;

                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                              data: Data<TRecord>;

                                                                                                                                                                                                                                                                                                                                property scale

                                                                                                                                                                                                                                                                                                                                scale?: DataRecordScale<TRecord>;

                                                                                                                                                                                                                                                                                                                                  property style

                                                                                                                                                                                                                                                                                                                                  style?: GroupStyleProps;

                                                                                                                                                                                                                                                                                                                                    property theme

                                                                                                                                                                                                                                                                                                                                    theme?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                      interface GaugeProps

                                                                                                                                                                                                                                                                                                                                      interface GaugeProps {}

                                                                                                                                                                                                                                                                                                                                        property center

                                                                                                                                                                                                                                                                                                                                        center?: Point;

                                                                                                                                                                                                                                                                                                                                          property endAngle

                                                                                                                                                                                                                                                                                                                                          endAngle?: number;

                                                                                                                                                                                                                                                                                                                                            property percent

                                                                                                                                                                                                                                                                                                                                            percent: number;

                                                                                                                                                                                                                                                                                                                                              property r

                                                                                                                                                                                                                                                                                                                                              r?: number | string;

                                                                                                                                                                                                                                                                                                                                                property r0

                                                                                                                                                                                                                                                                                                                                                r0?: number | string;

                                                                                                                                                                                                                                                                                                                                                  property startAngle

                                                                                                                                                                                                                                                                                                                                                  startAngle?: number;

                                                                                                                                                                                                                                                                                                                                                    property tickCount

                                                                                                                                                                                                                                                                                                                                                    tickCount?: number;

                                                                                                                                                                                                                                                                                                                                                      property tickLength

                                                                                                                                                                                                                                                                                                                                                      tickLength?: number | string;

                                                                                                                                                                                                                                                                                                                                                        property tickOffset

                                                                                                                                                                                                                                                                                                                                                        tickOffset?: number | string;

                                                                                                                                                                                                                                                                                                                                                          property ticks

                                                                                                                                                                                                                                                                                                                                                          ticks?: Tick[];

                                                                                                                                                                                                                                                                                                                                                            interface GeometryProps

                                                                                                                                                                                                                                                                                                                                                            interface GeometryProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                                                            extends SelectionProps {}

                                                                                                                                                                                                                                                                                                                                                              property adjust

                                                                                                                                                                                                                                                                                                                                                              adjust?: AdjustType | AdjustProps;

                                                                                                                                                                                                                                                                                                                                                                property animation

                                                                                                                                                                                                                                                                                                                                                                animation?: AnimationProps;

                                                                                                                                                                                                                                                                                                                                                                  property color

                                                                                                                                                                                                                                                                                                                                                                  color?: DataField<TRecord> | string | [string, any[]] | ColorAttrObject;

                                                                                                                                                                                                                                                                                                                                                                    property onPan

                                                                                                                                                                                                                                                                                                                                                                    onPan?: Function;

                                                                                                                                                                                                                                                                                                                                                                      property onPanEnd

                                                                                                                                                                                                                                                                                                                                                                      onPanEnd?: Function;

                                                                                                                                                                                                                                                                                                                                                                        property onPanStart

                                                                                                                                                                                                                                                                                                                                                                        onPanStart?: Function;

                                                                                                                                                                                                                                                                                                                                                                          property onPress

                                                                                                                                                                                                                                                                                                                                                                          onPress?: Function;

                                                                                                                                                                                                                                                                                                                                                                            property onPressEnd

                                                                                                                                                                                                                                                                                                                                                                            onPressEnd?: Function;

                                                                                                                                                                                                                                                                                                                                                                              property onPressStart

                                                                                                                                                                                                                                                                                                                                                                              onPressStart?: Function;

                                                                                                                                                                                                                                                                                                                                                                                property shape

                                                                                                                                                                                                                                                                                                                                                                                shape?: DataField<TRecord> | number | string | [string, any[]] | ShapeAttrObject;

                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                  size?: DataField<TRecord> | number | string | [string, any[]] | SizeAttrObject;

                                                                                                                                                                                                                                                                                                                                                                                    property startOnZero

                                                                                                                                                                                                                                                                                                                                                                                    startOnZero?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                      property style

                                                                                                                                                                                                                                                                                                                                                                                      style?: any;

                                                                                                                                                                                                                                                                                                                                                                                        property viewClip

                                                                                                                                                                                                                                                                                                                                                                                        viewClip?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                        • 是否裁剪显示区

                                                                                                                                                                                                                                                                                                                                                                                        property x

                                                                                                                                                                                                                                                                                                                                                                                        x: DataField<TRecord>;

                                                                                                                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                                                                                                                          y: DataField<TRecord>;

                                                                                                                                                                                                                                                                                                                                                                                            interface GuideProps

                                                                                                                                                                                                                                                                                                                                                                                            interface GuideProps {}

                                                                                                                                                                                                                                                                                                                                                                                              property animation

                                                                                                                                                                                                                                                                                                                                                                                              animation?: ((points: Point[], chart: Chart) => AnimationProps) | AnimationProps;

                                                                                                                                                                                                                                                                                                                                                                                                property onClick

                                                                                                                                                                                                                                                                                                                                                                                                onClick?: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  property precise

                                                                                                                                                                                                                                                                                                                                                                                                  precise?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    property records

                                                                                                                                                                                                                                                                                                                                                                                                    records: any;

                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                        interface IntervalProps

                                                                                                                                                                                                                                                                                                                                                                                                        interface IntervalProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                                                                                                        extends GeometryProps<TRecord> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property labelCfg

                                                                                                                                                                                                                                                                                                                                                                                                          labelCfg?: any;

                                                                                                                                                                                                                                                                                                                                                                                                            property showLabel

                                                                                                                                                                                                                                                                                                                                                                                                            showLabel?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                              property sizeRatio

                                                                                                                                                                                                                                                                                                                                                                                                              sizeRatio?: number;
                                                                                                                                                                                                                                                                                                                                                                                                              • 柱子的显示比例

                                                                                                                                                                                                                                                                                                                                                                                                              property sizeZoom

                                                                                                                                                                                                                                                                                                                                                                                                              sizeZoom?: number | ZoomRatioCallback<TRecord>;
                                                                                                                                                                                                                                                                                                                                                                                                              • 柱子放大缩小的比例

                                                                                                                                                                                                                                                                                                                                                                                                              interface LegendProps

                                                                                                                                                                                                                                                                                                                                                                                                              interface LegendProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                property clickable

                                                                                                                                                                                                                                                                                                                                                                                                                clickable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                • 是否可点击

                                                                                                                                                                                                                                                                                                                                                                                                                property height

                                                                                                                                                                                                                                                                                                                                                                                                                height?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                • 图例高度

                                                                                                                                                                                                                                                                                                                                                                                                                property itemFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                itemFormatter?: (value: any, name: any) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                • 回调函数,用于格式化图例每项的文本显示。

                                                                                                                                                                                                                                                                                                                                                                                                                property items

                                                                                                                                                                                                                                                                                                                                                                                                                items?: LegendItem[];
                                                                                                                                                                                                                                                                                                                                                                                                                • 图例项列表。

                                                                                                                                                                                                                                                                                                                                                                                                                property itemStyle

                                                                                                                                                                                                                                                                                                                                                                                                                itemStyle?: GroupStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                • 用于设置图例项的样式

                                                                                                                                                                                                                                                                                                                                                                                                                property margin

                                                                                                                                                                                                                                                                                                                                                                                                                margin?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                • legend 和图表内容的间距

                                                                                                                                                                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                                                                                                                                                                marker?: 'circle' | 'square' | 'line';
                                                                                                                                                                                                                                                                                                                                                                                                                • 图例标记。

                                                                                                                                                                                                                                                                                                                                                                                                                property nameStyle

                                                                                                                                                                                                                                                                                                                                                                                                                nameStyle?: Omit<TextStyleProps, 'text'>;
                                                                                                                                                                                                                                                                                                                                                                                                                • 用于设置图例项的文本样式

                                                                                                                                                                                                                                                                                                                                                                                                                property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                onClick?: (item: LegendItem) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  property position

                                                                                                                                                                                                                                                                                                                                                                                                                  position?: 'right' | 'left' | 'top' | 'bottom';
                                                                                                                                                                                                                                                                                                                                                                                                                  • 图例的显示位置。默认为 top。

                                                                                                                                                                                                                                                                                                                                                                                                                  property style

                                                                                                                                                                                                                                                                                                                                                                                                                  style?: GroupStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                  • 图例样式。

                                                                                                                                                                                                                                                                                                                                                                                                                  property valuePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                  valuePrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                  • value展示文案的前缀

                                                                                                                                                                                                                                                                                                                                                                                                                  property valueStyle

                                                                                                                                                                                                                                                                                                                                                                                                                  valueStyle?: Omit<TextStyleProps, 'text'>;
                                                                                                                                                                                                                                                                                                                                                                                                                  • 用于设置图例项的文本样式

                                                                                                                                                                                                                                                                                                                                                                                                                  property width

                                                                                                                                                                                                                                                                                                                                                                                                                  width?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                  • 图例宽度

                                                                                                                                                                                                                                                                                                                                                                                                                  interface LineProps

                                                                                                                                                                                                                                                                                                                                                                                                                  interface LineProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                                                                                                                  extends GeometryProps<TRecord> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property connectNulls

                                                                                                                                                                                                                                                                                                                                                                                                                    connectNulls?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                      property endView

                                                                                                                                                                                                                                                                                                                                                                                                                      endView?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                        property sizeZoom

                                                                                                                                                                                                                                                                                                                                                                                                                        sizeZoom?: number | ZoomRatioCallback<TRecord>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • 柱子放大缩小的比例

                                                                                                                                                                                                                                                                                                                                                                                                                        interface PictorialProps

                                                                                                                                                                                                                                                                                                                                                                                                                        interface PictorialProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                                                                                                                        extends GeometryProps<TRecord> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property symbol

                                                                                                                                                                                                                                                                                                                                                                                                                          symbol?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface PieLabelProps

                                                                                                                                                                                                                                                                                                                                                                                                                            interface PieLabelProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property anchorOffset

                                                                                                                                                                                                                                                                                                                                                                                                                              anchorOffset?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                property inflectionOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                inflectionOffset?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property label1

                                                                                                                                                                                                                                                                                                                                                                                                                                  label1?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property label2

                                                                                                                                                                                                                                                                                                                                                                                                                                    label2?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                      onClick?: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property sidePadding

                                                                                                                                                                                                                                                                                                                                                                                                                                        sidePadding?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property triggerOn

                                                                                                                                                                                                                                                                                                                                                                                                                                          triggerOn?: 'click' | 'press';
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 触发的事件类型

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ScrollBarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ScrollBarProps extends ZoomProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property background

                                                                                                                                                                                                                                                                                                                                                                                                                                            background?: ShapeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 背景条样式

                                                                                                                                                                                                                                                                                                                                                                                                                                            property barStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                            barStyle?: ShapeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 滚动条样式

                                                                                                                                                                                                                                                                                                                                                                                                                                            property margin

                                                                                                                                                                                                                                                                                                                                                                                                                                            margin?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 间距

                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                            property position

                                                                                                                                                                                                                                                                                                                                                                                                                                            position?: 'bottom' | 'top' | 'left' | 'right';
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 滚动条显示位置

                                                                                                                                                                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                                                                                                                                                                            style?: ShapeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 滚动条父容器样式

                                                                                                                                                                                                                                                                                                                                                                                                                                            property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                            visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 显示滚动条

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SunburstProps

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SunburstProps<TRecord extends DataRecord = DataRecord> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property color

                                                                                                                                                                                                                                                                                                                                                                                                                                              color?: any[] | ColorAttrObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property coord

                                                                                                                                                                                                                                                                                                                                                                                                                                                coord?: CoordProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: Data<TRecord>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClick?: (ev: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                      sort?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                        value?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TooltipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TooltipProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property alwaysShow

                                                                                                                                                                                                                                                                                                                                                                                                                                                            alwaysShow?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 是否一直显示

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property background

                                                                                                                                                                                                                                                                                                                                                                                                                                                            background?: RectStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 背景样式

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property crosshairsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                            crosshairsStyle?: LineStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 十字线样式

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property crosshairsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            crosshairsType?: 'x' | 'y' | 'xy';
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 十字线类型

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property custom

                                                                                                                                                                                                                                                                                                                                                                                                                                                            custom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property customText

                                                                                                                                                                                                                                                                                                                                                                                                                                                              customText?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultItem?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property markerBackgroundStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  markerBackgroundStyle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nameStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nameStyle?: TextStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 名称样式

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onChange?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onHide?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tooltip 隐藏回调

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onShow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onShow?: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tooltip 展示回调

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property padding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      padding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 顶部边距

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property showCrosshairs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showCrosshairs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 是否显示十字线

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property showItemMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showItemMarker?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 是否显示

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property showTooltipMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showTooltipMarker?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property showXTip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showXTip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property showYTip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showYTip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property snap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            snap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 是否显示辅助点

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tooltipMarkerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tooltipMarkerStyle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property triggerOff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              triggerOff?: 'pressend';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 消失的事件名,默认为 pressend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property triggerOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              triggerOn?: 'press' | 'click';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 显示事件名,默认为 press

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property valueStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              valueStyle?: TextStyleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 值样式

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 是否显示

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property xPositionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              xPositionType?: 'record' | 'coord';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x 的位置点类型,record 表示按照数据取位置点,coord 表示按照坐标取位置点

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property yPositionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yPositionType?: 'record' | 'coord';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x 的位置点类型,record 表示按照数据取位置点,coord 表示按照坐标取位置点

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TreemapProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TreemapProps<TRecord extends DataRecord = DataRecord>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends TreemapBaseProps<TRecord> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label?: boolean | TextStyleProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClick?: (record: RecordNode<TRecord>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ZoomProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ZoomProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property autoFit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoFit?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 自动同步 x/y 的坐标值

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property minCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 最少展示数据量,用于控制最小缩放比例, 默认是10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode?: 'x' | 'y' | ['x', 'y'] | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 缩放和平移模式

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onChange?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onInit?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onPan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onPan?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onPanEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onPanEnd?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onPanStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onPanStart?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 事件回调

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onPinch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onPinch?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onPinchEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onPinchEnd?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onPinchStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onPinchStart?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pan?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 平移

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property panSensitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      panSensitive?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pinch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pinch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 缩放

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pinchSensitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pinchSensitive?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          range?: ZoomRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 显示的范围

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property swipe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          swipe?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 横扫

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property swipeDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          swipeDuration?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 横扫动画时长

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AreaProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AreaProps<TRecord extends DataRecord = DataRecord> = LineProps<TRecord>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PointProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PointProps<TRecord extends DataRecord = DataRecord> = GeometryProps<TRecord>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ScaleConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ScaleConfig = Partial<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 对应的字段id */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              field: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 输入域、定义域 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              values: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 定义域的最小值,d3为domain,ggplot2为limits,分类型下无效 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              min: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 定义域的最大值,分类型下无效 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              max: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 严格模式下的定义域最小值,设置后会强制 ticks 从最小值开始 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              minLimit?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 严格模式下的定义域最大值,设置后会强制 ticks 已最大值结束 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxLimit?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 数据字段的显示别名,scale内部不感知,外部注入 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alias: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 输出域、值域,默认值为[0, 1] */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              range: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** Log有效,底数 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              base: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** Pow有效,指数 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exponent: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 自动调整min、max */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nice: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 用于指定tick,优先级最高 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ticks: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** tick间隔,只对分类型和时间型适用,优先级高于tickCount */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tickInterval: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** tick最小间隔,只对线型适用 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              minTickInterval: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** tick个数,默认值为5 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tickCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** ticks最大值,默认值为10 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxTickCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** tick格式化函数,会影响数据在坐标轴 axis、图例 legend、tooltip 上的显示 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatter: (value: any, index?: number) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 计算 ticks 的算法 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tickMethod: string | TickMethod;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 时间度量 time, timeCat 时有效 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mask?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** 是否始终保留最后一个 tick */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showLast?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (49)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (10)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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/@antv/f2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@antv/f2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@antv/f2"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>