• Version 4.1.23
  • Published
  • 7.28 MB
  • 12 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: 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;
                                                                                    | string
                                                                                    | import('react').ReactElement<
                                                                                    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;


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

                                                                                                        function Facet

                                                                                                        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;

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

                                                                                                                                  function withChartInstance

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

                                                                                                                                    function withView

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


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


                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                  namespace Tooltip {}

                                                                                                                                                                                                                                                                                                    variable defaultProps

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

                                                                                                                                                                                                                                                                                                      Package Files (102)

                                                                                                                                                                                                                                                                                                      Dependencies (12)

                                                                                                                                                                                                                                                                                                      Dev Dependencies (75)

                                                                                                                                                                                                                                                                                                      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>