• Version 4.1.14
  • Published
  • 7.34 MB
  • 13 dependencies
  • MIT license


npm i bizcharts
yarn add bizcharts
pnpm add bizcharts





variable AreaChart

const AreaChart: any;

    variable BarChart

    const BarChart: any;

      variable BubbleChart

      const BubbleChart: any;

        variable BulletChart

        const BulletChart: any;

          variable CalendarChart

          const CalendarChart: any;

            variable Chart

            const Chart: any;

              variable ColumnChart

              const ColumnChart: any;

                variable DensityHeatmapChart

                const DensityHeatmapChart: any;

                  variable DonutChart

                  const DonutChart: any;

                    variable FunnelChart

                    const FunnelChart: any;

                      variable GaugeChart

                      const GaugeChart: any;

                        variable GroupedBarChart

                        const GroupedBarChart: any;

                          variable GroupedColumnChart

                          const GroupedColumnChart: any;

                            variable GroupedRoseChart

                            const GroupedRoseChart: any;

                              variable Guide

                              const Guide: {
                              (props: any): any;
                              Arc: typeof Arc;
                              DataMarker: typeof DataMarker;
                              DataRegion: typeof DataRegion;
                              Image: typeof Image;
                              Line: typeof Line;
                              Region: typeof Region;
                              Text: typeof Text;

                                variable HeatmapChart

                                const HeatmapChart: any;

                                  variable HistogramChart

                                  const HistogramChart: any;

                                    variable LineChart

                                    const LineChart: any;

                                      variable LiquidChart

                                      const LiquidChart: any;

                                        variable PercentStackedAreaChart

                                        const PercentStackedAreaChart: any;

                                          variable PercentStackedBarChart

                                          const PercentStackedBarChart: any;

                                            variable PercentStackedColumnChart

                                            const PercentStackedColumnChart: any;

                                              variable PieChart

                                              const PieChart: any;

                                                variable PlotAdapter

                                                const PlotAdapter: any;

                                                  variable ProgressChart

                                                  const ProgressChart: any;

                                                    variable RadarChart

                                                    const RadarChart: any;

                                                      variable RangeBarChart

                                                      const RangeBarChart: any;

                                                        variable RangeColumnChart

                                                        const RangeColumnChart: any;

                                                          variable RingProgressChart

                                                          const RingProgressChart: any;

                                                            variable RoseChart

                                                            const RoseChart: any;

                                                              variable ScatterChart

                                                              const ScatterChart: any;

                                                                variable StackedAreaChart

                                                                const StackedAreaChart: any;

                                                                  variable StackedBarChart

                                                                  const StackedBarChart: any;

                                                                    variable StackedColumnChart

                                                                    const StackedColumnChart: any;

                                                                      variable StackedRoseChart

                                                                      const StackedRoseChart: any;

                                                                        variable StepLineChart

                                                                        const StepLineChart: any;

                                                                          variable TinyAreaChart

                                                                          const TinyAreaChart: any;

                                                                            variable TinyColumnChart

                                                                            const TinyColumnChart: any;

                                                                              variable TinyLineChart

                                                                              const TinyLineChart: any;

                                                                                variable TreemapChart

                                                                                const TreemapChart: any;

                                                                                  variable Util

                                                                                  const Util: {
                                                                                  getLegendItems: any;
                                                                                  translate: any;
                                                                                  rotate: any;
                                                                                  zoom: any;
                                                                                  transform: (m: number[], actions: any[][]) => number[];
                                                                                  getAngle: any;
                                                                                  getSectorPath: any;
                                                                                  polarToCartesian: any;
                                                                                  getDelegationObject: any;
                                                                                  getTooltipItems: any;
                                                                                  getMappingValue: any;
                                                                                  fold: (
                                                                                  data: any[],
                                                                                  fields: string[],
                                                                                  foldCate: string,
                                                                                  foldValue: string
                                                                                  ) => any[];
                                                                                  percentage: (
                                                                                  data: object[],
                                                                                  field: string,
                                                                                  as: string,
                                                                                  groupBy?: string | string[]
                                                                                  ) => any[];
                                                                                  minifyNum: (num: any, decimal?: number) => any;
                                                                                  splitBySeparator: (num: any, separator?: string) => any;
                                                                                  visibleHelper: (
                                                                                  cfg: any,
                                                                                  defaultVisible?: boolean
                                                                                  ) => { visible: boolean; text: any } | { visible: boolean; text?: undefined };
                                                                                  cloneDeep: (deepObject: any) => any;
                                                                                  shallowEqual: typeof bxUtil.shallowEqual;
                                                                                  contains: (arr: any[], value: any) => boolean;
                                                                                  includes: (arr: any[], value: any) => boolean;
                                                                                  difference: <T>(arr: T[], values?: T[]) => T[];
                                                                                  find: any;
                                                                                  findIndex: any;
                                                                                  firstValue: (data: object[], name: string) => any;
                                                                                  flatten: <T_1>(arr: T_1[]) => T_1[];
                                                                                  flattenDeep: (arr: any[], result?: any[]) => any[];
                                                                                  getRange: (values: number[]) => any;
                                                                                  pull: <T_2>(arr: T_2[], ...values: any[]) => T_2[];
                                                                                  pullAt: <T_3>(arr: T_3[], indexes: number[]) => T_3[];
                                                                                  reduce: <T_4, G>(
                                                                                  arr: any,
                                                                                  fn: (result: T_4, data: G, idx: string | number) => T_4,
                                                                                  init: T_4
                                                                                  ) => T_4;
                                                                                  remove: <T_5>(
                                                                                  arr: T_5[],
                                                                                  predicate: (value: T_5, idx: number, arr?: T_5[]) => boolean
                                                                                  ) => T_5[];
                                                                                  sortBy: any;
                                                                                  union: (...sources: any[]) => any[];
                                                                                  uniq: any;
                                                                                  valuesOfKey: (data: any[], name: string) => any[];
                                                                                  head: any;
                                                                                  last: any;
                                                                                  startsWith: any;
                                                                                  endsWith: any;
                                                                                  filter: <T_6>(arr: T_6[], func: (v: T_6, idx: number) => boolean) => T_6[];
                                                                                  every: <T_7>(arr: T_7[], func: (v: T_7, idx?: number) => any) => boolean;
                                                                                  some: <T_8>(arr: T_8[], func: (v: T_8, idx?: number) => any) => boolean;
                                                                                  group: <T_9>(
                                                                                  data: T_9[],
                                                                                  condition: string | string[] | ((v: T_9) => string)
                                                                                  ) => T_9[][];
                                                                                  groupBy: any;
                                                                                  groupToMap: any;
                                                                                  getWrapBehavior: any;
                                                                                  wrapBehavior: any;
                                                                                  number2color: any;
                                                                                  parseRadius: any;
                                                                                  clamp: (a: number, min: number, max: number) => number;
                                                                                  fixedBase: (v: number, base: string | number) => number;
                                                                                  isDecimal: (num: any) => boolean;
                                                                                  isEven: (num: any) => boolean;
                                                                                  isInteger: (number: unknown) => boolean;
                                                                                  isNegative: (num: any) => boolean;
                                                                                  isNumberEqual: any;
                                                                                  isOdd: (num: any) => boolean;
                                                                                  isPositive: (num: any) => boolean;
                                                                                  max: (arr: number[]) => number;
                                                                                  maxBy: <T_10>(arr: T_10[], fn: string | ((v: T_10) => number)) => T_10;
                                                                                  min: (arr: number[]) => number;
                                                                                  minBy: <T_11>(arr: T_11[], fn: string | ((v: T_11) => number)) => T_11;
                                                                                  mod: (n: number, m: number) => number;
                                                                                  toDegree: (radian: number) => number;
                                                                                  toInteger: any;
                                                                                  toRadian: (degree: number) => number;
                                                                                  forIn: any;
                                                                                  has: (obj: object, key: any) => boolean;
                                                                                  hasKey: (obj: object, key: any) => boolean;
                                                                                  hasValue: (obj: object, value: any) => boolean;
                                                                                  keys: (obj: any) => any[];
                                                                                  isMatch: any;
                                                                                  values: (obj: any) => any;
                                                                                  lowerCase: (str: string) => string;
                                                                                  lowerFirst: (value: string) => string;
                                                                                  substitute: any;
                                                                                  upperCase: (str: string) => string;
                                                                                  upperFirst: (value: string) => string;
                                                                                  getType: (value: any) => string;
                                                                                  isArguments: (value: any) => boolean;
                                                                                  isArray: (value: any) => value is any[];
                                                                                  isArrayLike: (value: any) => boolean;
                                                                                  isBoolean: (value: any) => value is boolean;
                                                                                  isDate: (value: any) => value is Date;
                                                                                  isError: (value: any) => value is Error;
                                                                                  isFunction: (value: any) => value is Function;
                                                                                  isFinite: any;
                                                                                  isNil: (value: any) => value is null;
                                                                                  isNull: (value: any) => value is null;
                                                                                  isNumber: (value: any) => value is number;
                                                                                  isObject: <T_12 = object>(value: any) => value is T_12;
                                                                                  isObjectLike: (value: any) => value is object;
                                                                                  isPlainObject: (value: any) => value is object;
                                                                                  isPrototype: (value: any) => boolean;
                                                                                  isRegExp: (str: any) => str is RegExp;
                                                                                  isString: (str: any) => str is string;
                                                                                  isType: (value: any, type: string) => boolean;
                                                                                  isUndefined: (value: any) => value is undefined;
                                                                                  isElement: (o: any) => boolean;
                                                                                  requestAnimationFrame: any;
                                                                                  clearAnimationFrame: any;
                                                                                  augment: (...args: any[]) => void;
                                                                                  clone: (obj: any) => any;
                                                                                  debounce: any;
                                                                                  memoize: (
                                                                                  f: Function,
                                                                                  resolver?: (...args: any[]) => string
                                                                                  ) => { (...args: any[]): any; cache: Map<any, any> };
                                                                                  deepMix: (rst: any, ...args: any[]) => any;
                                                                                  each: any;
                                                                                  extend: (
                                                                                  subclass: any,
                                                                                  superclass: any,
                                                                                  overrides?: any,
                                                                                  staticOverrides?: any
                                                                                  ) => any;
                                                                                  indexOf: <T_13>(arr: T_13[], obj: T_13) => number;
                                                                                  isEmpty: any;
                                                                                  isEqual: (value: any, other: any) => boolean;
                                                                                  isEqualWith: <T_14>(
                                                                                  value: T_14,
                                                                                  other: T_14,
                                                                                  fn: (v1: T_14, v2: T_14) => boolean
                                                                                  ) => boolean;
                                                                                  map: <T_15, G_1>(arr: T_15[], func: (v: T_15, idx: number) => G_1) => G_1[];
                                                                                  mapValues: <T_16>(
                                                                                  object: { [key: string]: T_16 },
                                                                                  func?: (value: T_16, key: string) => any
                                                                                  ) => { [key: string]: any };
                                                                                  mix: any;
                                                                                  assign: any;
                                                                                  get: (obj: any, key: string | any[], defaultValue?: any) => any;
                                                                                  set: (obj: any, path: string | any[], value: any) => any;
                                                                                  pick: <T_17>(object: any, keys: string[]) => any;
                                                                                  omit: <T_18>(obj: any, keys: string[]) => any;
                                                                                  throttle: (func: Function, wait: number, options: any) => Function;
                                                                                  toArray: (value: any) => any[];
                                                                                  toString: (value: any) => string;
                                                                                  uniqueId: (prefix?: string) => string;
                                                                                  noop: () => void;
                                                                                  identity: <T_19>(v: T_19) => T_19;
                                                                                  size: any;
                                                                                  measureTextWidth: { (...args: any[]): any; cache: Map<any, any> };
                                                                                  getEllipsisText: (
                                                                                  text: string | number,
                                                                                  maxWidth: number,
                                                                                  font?: any,
                                                                                  str?: string
                                                                                  ) => string | number;
                                                                                  Cache: any;

                                                                                    variable VERSION

                                                                                    const VERSION: string;

                                                                                      variable WaterfallChart

                                                                                      const WaterfallChart: any;

                                                                                        variable WordCloudChart

                                                                                        const WordCloudChart: any;


                                                                                          function Axis

                                                                                          Axis: (props: IAxis) => any;

                                                                                            function Coord

                                                                                            Coord: (props: any) => any;

                                                                                              function Coordinate

                                                                                              Coordinate: (props: ICoordinateProps) => any;

                                                                                                function createPlot

                                                                                                createPlot: <IPlotConfig extends Record<string, any>>(
                                                                                                PlotClass: any,
                                                                                                name: string,
                                                                                                transCfg?: Function
                                                                                                ) => any;

                                                                                                  function createTooltipConnector

                                                                                                  createTooltipConnector: () => Connector;

                                                                                                    function Effects

                                                                                                    Effects: (props: IEffectsProps) => any;

                                                                                                      function Facet

                                                                                                      Facet: (props: IFacetProps) => any;

                                                                                                        function Geom

                                                                                                        Geom: (props: IGemo) => any;

                                                                                                          function Interaction

                                                                                                          Interaction: (props: IInteractionProps) => any;

                                                                                                            function Label

                                                                                                            Label: (props: any) => any;

                                                                                                              function Legend

                                                                                                              Legend: (props: ILegend) => any;

                                                                                                                function LineAdvance

                                                                                                                LineAdvance: (props: ILineAdvanceGemoProps) => any;

                                                                                                                  function setDefaultErrorFallback

                                                                                                                  setDefaultErrorFallback: (CustComponents: any) => void;

                                                                                                                    function Slider

                                                                                                                    Slider: (props: ISliderProps) => any;

                                                                                                                      function Tooltip

                                                                                                                      Tooltip: typeof Tooltip;

                                                                                                                        function useChartInstance

                                                                                                                        useChartInstance: () => any;

                                                                                                                          function useRootChart

                                                                                                                          useRootChart: () => any;

                                                                                                                            function useTheme

                                                                                                                            useTheme: (
                                                                                                                            defaultThemeName?: string
                                                                                                                            ) => import('@antv/g2/lib/interface').LooseObject[];

                                                                                                                              function useView

                                                                                                                              useView: () => any;

                                                                                                                                function withChartInstance

                                                                                                                                withChartInstance: <T>(Component: any) => any;

                                                                                                                                  function withView

                                                                                                                                  withView: <T>(Component: any) => (props: T) => any;


                                                                                                                                    class Area

                                                                                                                                    class AreaGeom extends BaseGemo<IAreaGemoProps> {}

                                                                                                                                      property GemoBaseClassName

                                                                                                                                      GemoBaseClassName: string;

                                                                                                                                        class BaseGeom

                                                                                                                                        abstract class BaseGeom<T extends IBaseGemoProps> extends React.Component<T> {}


                                                                                                                                          constructor(props: any);

                                                                                                                                            property GemoBaseClassName

                                                                                                                                            protected abstract readonly GemoBaseClassName: string;

                                                                                                                                              property geomHelper

                                                                                                                                              geomHelper: GeomHelper;

                                                                                                                                                property interactionTypes

                                                                                                                                                protected interactionTypes: string[];

                                                                                                                                                  method componentWillUnmount

                                                                                                                                                  componentWillUnmount: () => void;

                                                                                                                                                    method render

                                                                                                                                                    render: () => any;

                                                                                                                                                      class Edge

                                                                                                                                                      class EdgeGeom extends BaseGemo<IEdgeGemoProps> {}

                                                                                                                                                        property GemoBaseClassName

                                                                                                                                                        GemoBaseClassName: string;

                                                                                                                                                          class Heatmap

                                                                                                                                                          class HeatmapGeom extends BaseGemo<IHeatmapGemoProps> {}

                                                                                                                                                            property GemoBaseClassName

                                                                                                                                                            GemoBaseClassName: string;

                                                                                                                                                              class Interval

                                                                                                                                                              class IntervalGeom extends BaseGemo<IIntervalGemoProps> {}

                                                                                                                                                                property GemoBaseClassName

                                                                                                                                                                GemoBaseClassName: string;

                                                                                                                                                                  property interactionTypes

                                                                                                                                                                  interactionTypes: string[];

                                                                                                                                                                    class Line

                                                                                                                                                                    class LineGeom extends BaseGemo<ILineGemoProps> {}

                                                                                                                                                                      property GemoBaseClassName

                                                                                                                                                                      GemoBaseClassName: string;

                                                                                                                                                                        class Path

                                                                                                                                                                        class PathGeom extends BaseGemo<IPathGemoProps> {}

                                                                                                                                                                          property GemoBaseClassName

                                                                                                                                                                          GemoBaseClassName: string;

                                                                                                                                                                            class Point

                                                                                                                                                                            class PointGeom extends BaseGemo<IPointGemoProps> {}

                                                                                                                                                                              property GemoBaseClassName

                                                                                                                                                                              GemoBaseClassName: string;

                                                                                                                                                                                class Polygon

                                                                                                                                                                                class PolygonGeom extends BaseGemo<IPolygonGemoProps> {}

                                                                                                                                                                                  property GemoBaseClassName

                                                                                                                                                                                  GemoBaseClassName: string;

                                                                                                                                                                                    class Schema

                                                                                                                                                                                    class SchemaGeom extends BaseGemo<ISchemaGemoProps> {}

                                                                                                                                                                                      property GemoBaseClassName

                                                                                                                                                                                      GemoBaseClassName: string;

                                                                                                                                                                                        class View

                                                                                                                                                                                        class View extends React.Component<IViewProps> {}

                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                          static defaultProps: { visible: boolean; preInteractions: any[]; filter: any[] };

                                                                                                                                                                                            property name

                                                                                                                                                                                            name: string;

                                                                                                                                                                                              method componentWillUnmount

                                                                                                                                                                                              componentWillUnmount: () => void;

                                                                                                                                                                                                method render

                                                                                                                                                                                                render: () => any;


                                                                                                                                                                                                  namespace Annotation

                                                                                                                                                                                                  module 'lib/components/Annotation/index.d.ts' {}

                                                                                                                                                                                                    class Arc

                                                                                                                                                                                                    class Arc extends Base<AnnotationArcProps> {}

                                                                                                                                                                                                      property annotationType

                                                                                                                                                                                                      annotationType: string;

                                                                                                                                                                                                        class Base

                                                                                                                                                                                                        abstract class Annotation<PropsI> extends React.Component<PropsI, any> {}

                                                                                                                                                                                                          property annotation

                                                                                                                                                                                                          protected annotation: any;

                                                                                                                                                                                                            property annotationType

                                                                                                                                                                                                            protected annotationType: string;

                                                                                                                                                                                                              property contextType

                                                                                                                                                                                                              static contextType: any;

                                                                                                                                                                                                                property id

                                                                                                                                                                                                                protected id: string;

                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                  protected index: number;

                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                      componentDidUpdate: () => void;

                                                                                                                                                                                                                        method componentWillUnmount

                                                                                                                                                                                                                        componentWillUnmount: () => void;

                                                                                                                                                                                                                          method getChartIns

                                                                                                                                                                                                                          getChartIns: () => any;

                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                              class DataMarker

                                                                                                                                                                                                                              class DataMarker extends Base<AnnotationDataMarkerProps> {}

                                                                                                                                                                                                                                property annotationType

                                                                                                                                                                                                                                annotationType: string;

                                                                                                                                                                                                                                  class DataRegion

                                                                                                                                                                                                                                  class DataRegion extends Base<AnnotationDataRegionProps> {}

                                                                                                                                                                                                                                    property annotationType

                                                                                                                                                                                                                                    annotationType: string;

                                                                                                                                                                                                                                      class Html

                                                                                                                                                                                                                                      class Html extends Base<HtmlAnnotationProps> {}

                                                                                                                                                                                                                                        property annotationType

                                                                                                                                                                                                                                        annotationType: string;

                                                                                                                                                                                                                                          class Image

                                                                                                                                                                                                                                          class Image extends Base<AnnotationImageProps> {}

                                                                                                                                                                                                                                            property annotationType

                                                                                                                                                                                                                                            annotationType: string;

                                                                                                                                                                                                                                              class Line

                                                                                                                                                                                                                                              class Line extends Base<AnnotationLineProps> {}

                                                                                                                                                                                                                                                property annotationType

                                                                                                                                                                                                                                                annotationType: string;

                                                                                                                                                                                                                                                  class ReactElement

                                                                                                                                                                                                                                                  class Html extends Base<HtmlAnnotationProps> {}

                                                                                                                                                                                                                                                    property annotationType

                                                                                                                                                                                                                                                    annotationType: string;

                                                                                                                                                                                                                                                      class Region

                                                                                                                                                                                                                                                      class Region extends Base<AnnotationRegionProps> {}

                                                                                                                                                                                                                                                        property annotationType

                                                                                                                                                                                                                                                        annotationType: string;

                                                                                                                                                                                                                                                          class RegionFilter

                                                                                                                                                                                                                                                          class RegionFilter extends Base<AnnotationRegionFilterProps> {}

                                                                                                                                                                                                                                                            property annotationType

                                                                                                                                                                                                                                                            annotationType: string;

                                                                                                                                                                                                                                                              class Text

                                                                                                                                                                                                                                                              class Text extends Base<AnnotationTextProps> {}

                                                                                                                                                                                                                                                                property annotationType

                                                                                                                                                                                                                                                                protected annotationType: string;

                                                                                                                                                                                                                                                                  namespace G2

                                                                                                                                                                                                                                                                  module 'lib/g2-all.d.ts' {}

                                                                                                                                                                                                                                                                    namespace GComponents

                                                                                                                                                                                                                                                                    module 'lib/g-components/index.d.ts' {}

                                                                                                                                                                                                                                                                      variable Canvas

                                                                                                                                                                                                                                                                      const Canvas: any;

                                                                                                                                                                                                                                                                        variable Circle

                                                                                                                                                                                                                                                                        const Circle: any;

                                                                                                                                                                                                                                                                          variable Ellipse

                                                                                                                                                                                                                                                                          const Ellipse: any;

                                                                                                                                                                                                                                                                            variable Group

                                                                                                                                                                                                                                                                            const Group: any;

                                                                                                                                                                                                                                                                              variable Image

                                                                                                                                                                                                                                                                              const Image: any;

                                                                                                                                                                                                                                                                                variable Line

                                                                                                                                                                                                                                                                                const Line: any;

                                                                                                                                                                                                                                                                                  variable Marker

                                                                                                                                                                                                                                                                                  const Marker: any;

                                                                                                                                                                                                                                                                                    variable Path

                                                                                                                                                                                                                                                                                    const Path: any;

                                                                                                                                                                                                                                                                                      variable Polygon

                                                                                                                                                                                                                                                                                      const Polygon: any;

                                                                                                                                                                                                                                                                                        variable Polyline

                                                                                                                                                                                                                                                                                        const Polyline: any;

                                                                                                                                                                                                                                                                                          variable Rect

                                                                                                                                                                                                                                                                                          const Rect: any;

                                                                                                                                                                                                                                                                                            variable Text

                                                                                                                                                                                                                                                                                            const Text: any;

                                                                                                                                                                                                                                                                                              function render

                                                                                                                                                                                                                                                                                              render: (element: any, container: any) => any;

                                                                                                                                                                                                                                                                                                namespace Tooltip

                                                                                                                                                                                                                                                                                                namespace Tooltip {}

                                                                                                                                                                                                                                                                                                  variable defaultProps

                                                                                                                                                                                                                                                                                                  var defaultProps: { showMarkers: boolean; triggerOn: string };

                                                                                                                                                                                                                                                                                                    Package Files (101)

                                                                                                                                                                                                                                                                                                    Dependencies (13)

                                                                                                                                                                                                                                                                                                    Dev Dependencies (74)

                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                    No peer dependencies.


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

                                                                                                                                                                                                                                                                                                    You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                      <a href=""><img src="" alt=""></a>