bizcharts

bizcharts

Version 4.1.23
Published 1 year ago
7.28 MB
12 dependencies
MIT license

Install

npm i bizcharts

yarn add bizcharts

pnpm add bizcharts

Overview

bizcharts

Index

Variables

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: React.ForwardRefExoticComponent<any>;

variable ColumnChart

const ColumnChart: any;

variable DensityHeatmapChart

const DensityHeatmapChart: any;

variable DonutChart

const DonutChart: any;

variable DualAxesChart

const DualAxesChart: 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: React.FC<IAdapterProps>;

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:
                  | string
                  | import('react').ReactElement<
                        unknown,
                        string | import('react').JSXElementConstructor<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;

Functions

function Axis

Axis: (props: IAxis) => any;

function Coord

Coord: (props: any) => React.JSX.Element;

function Coordinate

Coordinate: (props: ICoordinateProps) => any;

function createPlot

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

function createTooltipConnector

createTooltipConnector: () => Connector;

function Effects

Effects: (props: IEffectsProps) => React.ReactElement<unknown, any>;

Facet: (props: IFacetProps) => any;

function Geom

Geom: (props: IGemo) => React.JSX.Element;

function Interaction

Interaction: (props: IInteractionProps) => any;

function Label

Label: (props: any) => React.JSX.Element;

function Legend

Legend: (props: ILegend) => any;

function LineAdvance

LineAdvance: (props: ILineAdvanceGemoProps) => React.JSX.Element;

function setDefaultErrorFallback

setDefaultErrorFallback: (CustComponents: any) => void;

function Slider

Slider: (props: ISliderProps) => any;

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: () => Chart;

function withChartInstance

withChartInstance: <T>(Component: any) => React.ForwardRefExoticComponent<any>;

function withView

withView: <T>(Component: any) => (props: T) => React.JSX.Element;

Classes

class Area

class AreaGeom extends BaseGemo<IAreaGemoProps> {}

property GemoBaseClassName

GemoBaseClassName: string;

class BaseGeom

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

constructor

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: () => React.JSX.Element;

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: () => React.JSX.Element;

Namespaces

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: () => React.JSX.Element;

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: React.ForwardRefExoticComponent<any>;

variable Circle

const Circle: React.ForwardRefExoticComponent<any>;

variable Ellipse

const Ellipse: React.ForwardRefExoticComponent<any>;

variable Group

const Group: React.ForwardRefExoticComponent<any>;

variable Image

const Image: React.ForwardRefExoticComponent<any>;

variable Line

const Line: React.ForwardRefExoticComponent<any>;

variable Marker

const Marker: React.ForwardRefExoticComponent<any>;

variable Path

const Path: React.ForwardRefExoticComponent<any>;

variable Polygon

const Polygon: React.ForwardRefExoticComponent<any>;

variable Polyline

const Polyline: React.ForwardRefExoticComponent<any>;

variable Rect

const Rect: React.ForwardRefExoticComponent<any>;

variable Text

const Text: React.ForwardRefExoticComponent<any>;

function render

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

namespace Tooltip {}

variable defaultProps

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

Package Files (102)

Dependencies (12)

Dev Dependencies (75)

Peer Dependencies (0)

No peer dependencies.

Badge

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

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

Markdown

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

HTML

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

Updated 1 year ago.
Package analyzed in 5992 ms.
Missing or incorrect documentation? Open an issue for this package.

bizcharts

Install

Overview

Index

Variables

Functions

Classes

Namespaces

Variables

variable AreaChart

variable BarChart

variable BubbleChart

variable BulletChart

variable CalendarChart

variable Chart

variable ColumnChart

variable DensityHeatmapChart

variable DonutChart

variable DualAxesChart

variable FunnelChart

variable GaugeChart

variable GroupedBarChart

variable GroupedColumnChart

variable GroupedRoseChart

variable Guide

variable HeatmapChart

variable HistogramChart

variable LineChart

variable LiquidChart

variable PercentStackedAreaChart

variable PercentStackedBarChart

variable PercentStackedColumnChart

variable PieChart

variable PlotAdapter

variable ProgressChart

variable RadarChart

variable RangeBarChart

variable RangeColumnChart

variable RingProgressChart

variable RoseChart

variable ScatterChart

variable StackedAreaChart

variable StackedBarChart

variable StackedColumnChart

variable StackedRoseChart

variable StepLineChart

variable TinyAreaChart

variable TinyColumnChart

variable TinyLineChart

variable TreemapChart

variable Util

variable VERSION

variable WaterfallChart

variable WordCloudChart

Functions

function Axis

function Coord

function Coordinate

function createPlot

function createTooltipConnector

function Effects

function Facet

function Geom

function Interaction

function Label

function Legend

function LineAdvance

function setDefaultErrorFallback

function Slider

function Tooltip

function useChartInstance

function useRootChart

function useTheme

function useView

function withChartInstance

function withView

Classes

class Area

property GemoBaseClassName

class BaseGeom