echarts

echarts

Version 6.1.0
Published 12 days ago
60.3 MB
2 dependencies
Apache-2.0 license

Install

npm i echarts

yarn add echarts

pnpm add echarts

Overview

Apache ECharts is a powerful, interactive charting and data visualization library for browser

Index

Variables

variable availableMethods

const availableMethods: (keyof EChartsType)[];

variable AXIS_BREAK_CHANGED_EVENT_TYPE

const AXIS_BREAK_CHANGED_EVENT_TYPE: string;

variable AXIS_BREAK_COLLAPSE_ACTION_TYPE

const AXIS_BREAK_COLLAPSE_ACTION_TYPE: string;

variable AXIS_BREAK_EXPAND_ACTION_TYPE

const AXIS_BREAK_EXPAND_ACTION_TYPE: string;

variable AXIS_BREAK_TOGGLE_ACTION_TYPE

const AXIS_BREAK_TOGGLE_ACTION_TYPE: string;

variable AXIS_EXTENT_INFO_BUILD_FROM_COORD_SYS_UPDATE

const AXIS_EXTENT_INFO_BUILD_FROM_COORD_SYS_UPDATE: number;

variable AXIS_EXTENT_INFO_BUILD_FROM_DATA_ZOOM

const AXIS_EXTENT_INFO_BUILD_FROM_DATA_ZOOM: number;

variable AXIS_EXTENT_INFO_BUILD_FROM_EMPTY

const AXIS_EXTENT_INFO_BUILD_FROM_EMPTY: number;

variable AXIS_TYPES

const AXIS_TYPES: {
    readonly value: 1;
    readonly category: 1;
    readonly time: 1;
    readonly log: 1;
};

variable AxisTickLabelComputingKind

const AxisTickLabelComputingKind: { readonly estimate: 1; readonly determine: 2 };

variable bind

const bind: FunctionBind;

variable color_d_fastLerp

const color_d_fastLerp: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable color_d_fastMapToColor

const color_d_fastMapToColor: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable color_d_lift

const color_d_lift: (color: string, level: number) => string;

variable color_d_liftColor

const color_d_liftColor: {
    (color: GradientObject): GradientObject;
    (color: string): string;
};

variable color_d_lum

const color_d_lum: (color: string, backgroundLum: number) => number;

variable color_d_mapToColor

const color_d_mapToColor: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

variable color_d_modifyAlpha

const color_d_modifyAlpha: (color: string, alpha?: number) => string;

variable color_d_modifyHSL

const color_d_modifyHSL: (
    color: string,
    h?: number | ((h: number) => number),
    s?: string | number | ((s: number) => number),
    l?: string | number | ((l: number) => number)
) => string;

variable color_d_parse

const color_d_parse: (colorStr: string, rgbaArr?: number[]) => number[];

variable color_d_parseCssFloat

const color_d_parseCssFloat: (val: string | number) => number;

variable color_d_parseCssInt

const color_d_parseCssInt: (val: string | number) => number;

variable color_d_random

const color_d_random: () => string;

variable color_d_stringify

const color_d_stringify: (arrColor: number[], type: string) => string;

variable color_d_toHex

const color_d_toHex: (color: string) => string;

variable CONNECT_STATUS_KEY

const CONNECT_STATUS_KEY: string;

variable dataCtors

const dataCtors: {
    readonly float: ArrayConstructor | Float64ArrayConstructor;
    readonly int: ArrayConstructor | Int32ArrayConstructor;
    readonly ordinal: ArrayConstructor;
    readonly number: ArrayConstructor;
    readonly time: ArrayConstructor | Float64ArrayConstructor;
};

Multi dimensional data store

variable dataStack

const dataStack: {
    isDimensionStacked: typeof isDimensionStacked;
    enableDataStack: typeof enableDataStack;
    getStackedDimension: typeof getStackedDimension;
};

variable dataTool

const dataTool: {};

variable dependencies

const dependencies: { zrender: string };

variable dimPermutations

const dimPermutations: readonly [
    readonly ['x0', 'y0'],
    readonly ['x1', 'y0'],
    readonly ['x1', 'y1'],
    readonly ['x0', 'y1']
];

variable disConnect

const disConnect: (groupId: string) => void;

Alias and backward compatibility
Deprecated

variable dist

const dist: (v1: VectorArray, v2: VectorArray) => number;

variable distSquare

const distSquare: (v1: VectorArray, v2: VectorArray) => number;

variable easingFuncs

const easingFuncs: {
    linear(k: number): number;
    quadraticIn(k: number): number;
    quadraticOut(k: number): number;
    quadraticInOut(k: number): number;
    cubicIn(k: number): number;
    cubicOut(k: number): number;
    cubicInOut(k: number): number;
    quarticIn(k: number): number;
    quarticOut(k: number): number;
    quarticInOut(k: number): number;
    quinticIn(k: number): number;
    quinticOut(k: number): number;
    quinticInOut(k: number): number;
    sinusoidalIn(k: number): number;
    sinusoidalOut(k: number): number;
    sinusoidalInOut(k: number): number;
    exponentialIn(k: number): number;
    exponentialOut(k: number): number;
    exponentialInOut(k: number): number;
    circularIn(k: number): number;
    circularOut(k: number): number;
    circularInOut(k: number): number;
    elasticIn(k: number): number;
    elasticOut(k: number): number;
    elasticInOut(k: number): number;
    backIn(k: number): number;
    backOut(k: number): number;
    backInOut(k: number): number;
    bounceIn(k: number): number;
    bounceOut(k: number): number;
    bounceInOut(k: number): number;
};

variable EC_UPDATE_CYCLE_VERSION_KEY

const EC_UPDATE_CYCLE_VERSION_KEY: string;

variable env

const env: Env;

variable EPSILON

const EPSILON: number;

variable extendPathFromString

const extendPathFromString: (
    str: string,
    defaultOpts?: SVGPathOption
) => typeof SVGPath;

variable extensionRegisters

const extensionRegisters: {
    registerPreprocessor: typeof registerPreprocessor;
    registerProcessor: typeof registerProcessor;
    registerPostInit: typeof registerPostInit;
    registerPostUpdate: typeof registerPostUpdate;
    registerUpdateLifecycle: typeof registerUpdateLifecycle;
    registerAction: typeof registerAction;
    registerCoordinateSystem: typeof registerCoordinateSystem;
    registerLayout: typeof registerLayout;
    registerVisual: typeof registerVisual;
    registerTransform: typeof registerExternalTransform;
    registerLoading: typeof registerLoading;
    registerMap: typeof registerMap;
    registerImpl: typeof registerImpl;
    PRIORITY: {
        PROCESSOR: {
            SERIES_FILTER: number;
            AXIS_STATISTICS: number;
            FILTER: number;
            STATISTIC: number;
            STATISTICS: number;
        };
        VISUAL: {
            LAYOUT: number;
            PROGRESSIVE_LAYOUT: number;
            GLOBAL: number;
            CHART: number;
            POST_CHART_LAYOUT: number;
            COMPONENT: number;
            BRUSH: number;
            CHART_ITEM: number;
            ARIA: number;
            DECAL: number;
        };
    };
    ComponentModel: typeof ComponentModel;
    ComponentView: typeof ComponentView;
    SeriesModel: typeof SeriesModel;
    ChartView: typeof ChartView;
    registerComponentModel(ComponentModelClass: Constructor): void;
    registerComponentView(ComponentViewClass: typeof ComponentView): void;
    registerSeriesModel(SeriesModelClass: Constructor): void;
    registerChartView(ChartViewClass: typeof ChartView): void;
    registerCustomSeries(
        seriesType: string,
        renderItem: CustomSeriesRenderItem
    ): void;
    registerSubTypeDefaulter(
        componentType: string,
        defaulter: SubTypeDefaulter
    ): void;
    registerPainter(
        painterType: string,
        PainterCtor: Parameters<typeof registerPainter>[1]
    ): void;
};

variable fastMapToColor

const fastMapToColor: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable format_d_addCommas

const format_d_addCommas: (x: string | number) => string;

variable format_d_capitalFirst

const format_d_capitalFirst: (str: string) => string;

variable format_d_encodeHTML

const format_d_encodeHTML: (source: string) => string;

variable format_d_formatTime

const format_d_formatTime: (tpl: string, value: unknown, isUTC?: boolean) => string;

variable format_d_formatTpl

const format_d_formatTpl: (
    tpl: string,
    paramsList: TplFormatterParam | TplFormatterParam[],
    encode?: boolean
) => string;

variable format_d_getTextRect

const format_d_getTextRect: (
    text: string,
    font?: string,
    align?: TextAlign,
    verticalAlign?: TextVerticalAlign,
    padding?: number | number[],
    rich?: Dictionary<TextStylePropsPart>,
    truncate?: boolean,
    lineHeight?: number
) => BoundingRect;

variable format_d_getTooltipMarker

const format_d_getTooltipMarker: {
    (color: string, extraCssText?: string): TooltipMarker;
    (opt: GetTooltipMarkerOpt): TooltipMarker;
};

variable format_d_toCamelCase

const format_d_toCamelCase: (str: string, upperCaseFirst?: boolean) => string;

variable format_d_truncateText

const format_d_truncateText: (
    text: string,
    containerWidth: number,
    font: string,
    ellipsis?: string,
    options?: InnerTruncateOption
) => string;

variable graphic_d_Arc

const graphic_d_Arc: typeof Arc;

variable graphic_d_BezierCurve

const graphic_d_BezierCurve: typeof BezierCurve;

variable graphic_d_BoundingRect

const graphic_d_BoundingRect: typeof BoundingRect;

variable graphic_d_Circle

const graphic_d_Circle: typeof Circle;

variable graphic_d_clipPointsByRect

const graphic_d_clipPointsByRect: (
    points: VectorArray[],
    rect: RectLike
) => number[][];

variable graphic_d_clipRectByRect

const graphic_d_clipRectByRect: (targetRect: RectLike, rect: RectLike) => RectLike;

variable graphic_d_CompoundPath

const graphic_d_CompoundPath: typeof CompoundPath;

variable graphic_d_createIcon

const graphic_d_createIcon: (
    iconStr: string,
    opt?: Omit<DisplayableProps, 'style'>,
    rect?: RectLike
) => SVGPath | ZRImage;

variable graphic_d_Ellipse

const graphic_d_Ellipse: typeof Ellipse;

variable graphic_d_extendPath

const graphic_d_extendPath: (
    pathData: string,
    opts: SVGPathOption
) => typeof SVGPath;

variable graphic_d_extendShape

const graphic_d_extendShape: (opts: {
    type?: string;
    shape?: Dictionary<any>;
    style?: PathStyleProps;
    beforeBrush?: (param: BeforeBrushParam) => void;
    afterBrush?: () => void;
    getBoundingRect?: () => BoundingRect;
    calculateTextPosition?: ElementCalculateTextPosition;
    buildPath(
        this: Path<PathProps>,
        ctx: CanvasRenderingContext2D | PathProxy,
        shape: Dictionary<any>,
        inBatch?: boolean
    ): void;
    init?(this: Path<PathProps>, opts: PathProps): void;
}) => new (opts?: PathProps & { shape: Dictionary<any> }) => Path<PathProps>;

variable graphic_d_getShapeClass

const graphic_d_getShapeClass: (name: string) => new () => Path<PathProps>;

variable graphic_d_getTransform

const graphic_d_getTransform: (
    target: Transformable,
    ancestor?: Transformable
) => MatrixArray;

variable graphic_d_Group

const graphic_d_Group: typeof Group;

variable graphic_d_IncrementalDisplayable

const graphic_d_IncrementalDisplayable: typeof IncrementalDisplayable;

variable graphic_d_initProps

const graphic_d_initProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?: number | AnimateOrSetPropsOption | (() => void),
    cb?: (() => void) | ((percent: number) => void),
    during?: (percent: number) => void
) => void;

variable graphic_d_Line

const graphic_d_Line: typeof Line;

variable graphic_d_LinearGradient

const graphic_d_LinearGradient: typeof LinearGradient;

variable graphic_d_makeImage

const graphic_d_makeImage: (
    imageUrl: string,
    rect: RectLike,
    layout?: 'center' | 'cover'
) => ZRImage;

variable graphic_d_makePath

const graphic_d_makePath: (
    pathData: string,
    opts: SVGPathOption,
    rect: RectLike,
    layout?: 'center' | 'cover'
) => SVGPath;

variable graphic_d_Polygon

const graphic_d_Polygon: typeof Polygon;

variable graphic_d_Polyline

const graphic_d_Polyline: typeof Polyline;

variable graphic_d_RadialGradient

const graphic_d_RadialGradient: typeof RadialGradient;

variable graphic_d_Rect

const graphic_d_Rect: typeof Rect;

variable graphic_d_registerShape

const graphic_d_registerShape: (
    name: string,
    ShapeClass: new () => Path<PathProps>
) => void;

variable graphic_d_resizePath

const graphic_d_resizePath: (path: SVGPath, rect: RectLike) => void;

variable graphic_d_Ring

const graphic_d_Ring: typeof Ring;

variable graphic_d_Sector

const graphic_d_Sector: typeof Sector;

variable graphic_d_updateProps

const graphic_d_updateProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?: number | AnimateOrSetPropsOption | (() => void),
    cb?: (() => void) | ((percent: number) => void),
    during?: (percent: number) => void
) => void;

variable helper_d_createDimensions

const helper_d_createDimensions: (
    source:
        | OptionSourceData<OptionDataValue, OptionDataItemOriginal<OptionDataValue>>
        | Source,
    opt?: PrepareSeriesDataSchemaParams
) => SeriesDimensionDefine[];

variable helper_d_createList

const helper_d_createList: (
    seriesModel: SeriesModel<SeriesOption<unknown, DefaultStatesMixin>>
) => SeriesData<Model<any>, DefaultDataVisual>;

variable helper_d_createScale

const helper_d_createScale: (
    dataExtent: number[],
    option: object | AxisBaseModel<AxisBaseOptionCommon>
) => Scale<unknown>;

variable helper_d_createSymbol

const helper_d_createSymbol: (
    symbolType: string,
    x: number,
    y: number,
    w: number,
    h: number,
    color?: ZRColor,
    keepAspect?: boolean
) => ECSymbol;

variable helper_d_createTextStyle

const helper_d_createTextStyle: (
    textStyleModel: Model<TextCommonOption<TextCommonOptionNuanceDefault>>,
    opts?: { state?: DisplayState }
) => TextStyleProps;

variable helper_d_dataStack

const helper_d_dataStack: {
    isDimensionStacked: (
        data: SeriesData<Model<any>, DefaultDataVisual>,
        stackedDim: string
    ) => boolean;
    enableDataStack: (
        seriesModel: SeriesModel<
            SeriesOption<unknown, DefaultStatesMixin> & SeriesStackOptionMixin
        >,
        dimensionsInput:
            | EnableDataStackDimensionsInput
            | EnableDataStackDimensionsInputLegacy,
        opt?: { stackedCoordDimension?: string; byIndex?: boolean }
    ) => Pick<
        DataCalculationInfo<unknown>,
        | 'stackedDimension'
        | 'stackedByDimension'
        | 'isStackedByIndex'
        | 'stackedOverDimension'
        | 'stackResultDimension'
    >;
    getStackedDimension: (
        data: SeriesData<Model<any>, DefaultDataVisual>,
        targetDim: string
    ) => string;
};

variable helper_d_enableHoverEmphasis

const helper_d_enableHoverEmphasis: (
    el: Element<ElementProps>,
    focus?: InnerFocus,
    blurScope?: BlurScope
) => void;

variable helper_d_getECData

const helper_d_getECData: (hostObj: Element<ElementProps>) => ECData;

variable helper_d_getLayoutRect

const helper_d_getLayoutRect: (
    positionInfo: BoxLayoutOptionMixin & { aspect?: number },
    containerRect: GetLayoutRectInputContainerRect,
    margin?: number | number[]
) => LayoutRect;

variable helper_d_mixinAxisModelCommonMethods

const helper_d_mixinAxisModelCommonMethods: (Model: Model<any>) => void;

variable ICON_TYPES

const ICON_TYPES: readonly ['rect', 'polygon', 'lineX', 'lineY', 'keep', 'clear'];

variable ICON_TYPES$1

const ICON_TYPES$1: readonly ['zoom', 'back'];

variable ICON_TYPES$2

const ICON_TYPES$2: readonly ['line', 'bar', 'stack'];

variable IN_EC_CYCLE_KEY

const IN_EC_CYCLE_KEY: string;

[EC_CYCLE] (ec updating/rendering cycles):
- Common Rules: - Nested entry is not allowed. If triggering a new run of EC_CYCLE during a unfinished run, the new run will be delayed until the current run finishes (if triggered by dispatchAction), or throw error (if triggered by other API calls). - All user-visible ec events are triggered outside EC_CYCLE. (i.e. be triggered after this[IN_EC_CYCLE_KEY] becoming false).
- [EC_FULL_UPDATE_CYCLE]: - It designates a run of a series of processing/updating/rendering. - It is triggered by: - setOption - dispatchAction (It is typically internally triggered by user inputs; but can also an explicit API call.) - resize - The next "animation frame" if in lazyMode: true. - A run of EC_FULL_UPDATE_CYCLE comprises: - EC_PREPARE (may be absent) - EC_FULL_UPDATE: - CoordinateSystem['create'] - Data processing (may be absent) (see registerProcessor) - CoordinateSystem['update'] (may be absent) - Visual encoding (may be absent) (see registerVisual) - Layout (may be absent) (see registerLayout) - Rendering (ComponentView or SeriesView)
- [EC_PARTIAL_UPDATE_CYCLE]s: - They are shortcuts for performance. - They are triggered by: - dispatchAction - These steps are typically omitted: - No EC_PREPARE - No CoordinateSystem['create'] and CoordinateSystem['update'] - They require careful implementation, otherwise inconsistency may be introduced.
- [EC_PROGRESSIVE_CYCLE]: - It also carries out a series of processing/updating/rendering. - It is performed in each subsequent "animation frame" until finished. - It can be triggered by EC_FULL_UPDATE_CYCLE, EC_PARTIAL_UPDATE_CYCLE or EC_APPEND_DATA_CYCLE. - A run of EC_PROGRESSIVE_CYCLE comprises: - Data processing (may be absent) (see registerProcessor) - Visual encoding (may be absent) (see registerVisual) - Layout (may be absent) (see registerLayout) - Rendering (ComponentView or SeriesView) - PENDING: currently all data processing tasks (via registerProcessor) run in "block" mode. (see performDataProcessorTasks).
- [EC_APPEND_DATA_CYCLE]: - See appendData. It is only supported for some special cases.
- [SERIES_SPECIFIC_CYCLE]s: - Series may have specific update/render cycles. For example, graph force layout performs layout and rendering in each "animation frame".
- Model updating: - Model can only be modified at the beginning of ec cycles, including only: - EC_PREPARE (see method prepare()) in setOption call. - EC action handlers in dispatchAction call. - appendData (a special case, where only data can be modified).
- The lifetime of CoordinateSystem/Axis/Scale instances: - They are only re-created per run of EC_FULL_UPDATE_CYCLE.
- Global caches: see cycleCache.ts

variable IN_HOVER_LAYER_KIND_NO

const IN_HOVER_LAYER_KIND_NO: number;

variable IN_HOVER_LAYER_KIND_ONLY_STYLE_CHANGE

const IN_HOVER_LAYER_KIND_ONLY_STYLE_CHANGE: number;

variable length

const length: (v: VectorArray) => number;

variable lengthSquare

const lengthSquare: (v: VectorArray) => number;

variable mapToColor

const mapToColor: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

variable matrix_d_identity

const matrix_d_identity: (out: MatrixArray) => MatrixArray;

variable matrix_d_invert

const matrix_d_invert: (out: MatrixArray, a: MatrixArray) => MatrixArray;

variable matrix_d_rotate

const matrix_d_rotate: (
    out: MatrixArray,
    a: MatrixArray,
    rad: number,
    pivot?: VectorArray
) => MatrixArray;

variable matrix_d_translate

const matrix_d_translate: (
    out: MatrixArray,
    a: MatrixArray,
    v: VectorArray
) => MatrixArray;

variable MatrixCellLayoutInfoType

const MatrixCellLayoutInfoType: {
    readonly level: 1;
    readonly leaf: 2;
    readonly nonLeaf: 3;
};

variable MAX_SAFE_INTEGER

const MAX_SAFE_INTEGER: number;

variable mergePath$1

const mergePath$1: (pathEls: Path<PathProps>[], opts: PathProps) => Path<PathProps>;

variable NICE_MODE_MIN

const NICE_MODE_MIN: number;

variable NICE_MODE_ROUND

const NICE_MODE_ROUND: number;

variable NON_STYLE_VISUAL_PROPS

const NON_STYLE_VISUAL_PROPS: {
    readonly symbol: 1;
    readonly symbolSize: 1;
    readonly symbolKeepAspect: 1;
    readonly legendIcon: 1;
    readonly visualMeta: 1;
    readonly liftZ: 1;
    readonly decal: 1;
};

variable normalizeCssArray$1

const normalizeCssArray$1: (val: number | number[]) => number[];

variable number_d_asc

const number_d_asc: <T extends number[]>(arr: T) => T;

variable number_d_getPercentWithPrecision

const number_d_getPercentWithPrecision: (
    valueList: number[],
    idx: number,
    precision: number
) => number;

variable number_d_getPixelPrecision

const number_d_getPixelPrecision: (
    dataExtent: [number, number],
    pixelExtent: [number, number]
) => number;

variable number_d_getPrecision

const number_d_getPrecision: (val: string | number) => number;

variable number_d_getPrecisionSafe

const number_d_getPrecisionSafe: (val: string | number) => number;

variable number_d_isNumeric

const number_d_isNumeric: (val: unknown) => val is number;

variable number_d_isRadianAroundZero

const number_d_isRadianAroundZero: (val: number) => boolean;

variable number_d_linearMap

const number_d_linearMap: (
    val: number,
    domain: number[],
    range: number[],
    clamp?: boolean
) => number;

variable number_d_MAX_SAFE_INTEGER

const number_d_MAX_SAFE_INTEGER: number;

variable number_d_nice

const number_d_nice: (val: number, mode?: boolean | 2 | 1) => number;

variable number_d_numericToNumber

const number_d_numericToNumber: (val: unknown) => number;

variable number_d_parseDate

const number_d_parseDate: (value: unknown) => Date;

variable number_d_parsePercent

const number_d_parsePercent: (
    option: unknown,
    percentBase: number,
    percentOffset?: number
) => number;

variable number_d_quantile

const number_d_quantile: (ascArr: number[], p: number) => number;

variable number_d_quantity

const number_d_quantity: (val: number) => number;

variable number_d_quantityExponent

const number_d_quantityExponent: (val: number) => number;

variable number_d_reformIntervals

const number_d_reformIntervals: (list: IntervalItem[]) => IntervalItem[];

variable number_d_remRadian

const number_d_remRadian: (radian: number) => number;

variable parsePercent

const parsePercent: (
    option: unknown,
    percentBase: number,
    percentOffset?: number
) => number;

Preserve the name parsePercent for backward compatibility, and it's effectively published as echarts.number.parsePercent.

variable PENDING_UPDATE

const PENDING_UPDATE: string;

variable PRIMARY_STATES_KEYS

const PRIMARY_STATES_KEYS: [
    (
        | 'x'
        | 'y'
        | 'originX'
        | 'originY'
        | 'anchorX'
        | 'anchorY'
        | 'rotation'
        | 'scaleX'
        | 'scaleY'
        | 'skewX'
        | 'skewY'
    ),
    'ignore'
];

variable primaryTimeUnits

const primaryTimeUnits: readonly [
    'year',
    'month',
    'day',
    'hour',
    'minute',
    'second',
    'millisecond'
];

variable PRIORITY

const PRIORITY: {
    PROCESSOR: {
        SERIES_FILTER: number;
        AXIS_STATISTICS: number;
        FILTER: number;
        STATISTIC: number;
        STATISTICS: number;
    };
    VISUAL: {
        LAYOUT: number;
        PROGRESSIVE_LAYOUT: number;
        GLOBAL: number;
        CHART: number;
        POST_CHART_LAYOUT: number;
        COMPONENT: number;
        BRUSH: number;
        CHART_ITEM: number;
        ARIA: number;
        DECAL: number;
    };
};

variable RADIAN_TO_DEGREE

const RADIAN_TO_DEGREE: number;

variable registerTransform

const registerTransform: (
    externalTransform: ExternalDataTransform<DataTransformOption>
) => void;

variable SCALE_EXTENT_KIND_EFFECTIVE

const SCALE_EXTENT_KIND_EFFECTIVE: number;

variable SCALE_EXTENT_KIND_MAPPING

const SCALE_EXTENT_KIND_MAPPING: number;

variable SCALE_MAPPER_DEPTH_INNERMOST

const SCALE_MAPPER_DEPTH_INNERMOST: number;

variable SCALE_MAPPER_DEPTH_OUT_OF_BREAK

const SCALE_MAPPER_DEPTH_OUT_OF_BREAK: number;

variable SERIES_LAYOUT_BY_COLUMN

const SERIES_LAYOUT_BY_COLUMN: string;

variable SERIES_LAYOUT_BY_ROW

const SERIES_LAYOUT_BY_ROW: string;

variable SERIES_UNIVERSAL_TRANSITION_PROP

const SERIES_UNIVERSAL_TRANSITION_PROP: string;

variable SOURCE_FORMAT_ARRAY_ROWS

const SOURCE_FORMAT_ARRAY_ROWS: string;

variable SOURCE_FORMAT_KEYED_COLUMNS

const SOURCE_FORMAT_KEYED_COLUMNS: string;

variable SOURCE_FORMAT_OBJECT_ROWS

const SOURCE_FORMAT_OBJECT_ROWS: string;

variable SOURCE_FORMAT_ORIGINAL

const SOURCE_FORMAT_ORIGINAL: string;

variable SOURCE_FORMAT_TYPED_ARRAY

const SOURCE_FORMAT_TYPED_ARRAY: string;

variable SOURCE_FORMAT_UNKNOWN

const SOURCE_FORMAT_UNKNOWN: string;

variable STATUS_NEEDS_UPDATE_KEY

const STATUS_NEEDS_UPDATE_KEY: string;

variable STYLE_VISUAL_TYPE

const STYLE_VISUAL_TYPE: { readonly color: 'fill'; readonly borderColor: 'stroke' };

variable time_d_format

const time_d_format: (
    time: unknown,
    template: string,
    isUTC: boolean,
    lang?:
        | string
        | Model<{
              time: {
                  month: string[];
                  monthAbbr: string[];
                  dayOfWeek: string[];
                  dayOfWeekAbbr: string[];
              };
              legend: { selector: { all: string; inverse: string } };
              toolbox: {
                  brush: {
                      title: {
                          rect: string;
                          polygon: string;
                          lineX: string;
                          lineY: string;
                          keep: string;
                          clear: string;
                      };
                  };
                  dataView: { title: string; lang: string[] };
                  dataZoom: { title: { zoom: string; back: string } };
                  magicType: {
                      title: {
                          line: string;
                          bar: string;
                          stack: string;
                          tiled: string;
                      };
                  };
                  restore: { title: string };
                  saveAsImage: { title: string; lang: string[] };
              };
              series: {
                  typeNames: {
                      pie: string;
                      bar: string;
                      line: string;
                      scatter: string;
                      effectScatter: string;
                      radar: string;
                      tree: string;
                      treemap: string;
                      boxplot: string;
                      candlestick: string;
                      k: string;
                      heatmap: string;
                      map: string;
                      parallel: string;
                      lines: string;
                      graph: string;
                      sankey: string;
                      funnel: string;
                      gauge: string;
                      pictorialBar: string;
                      themeRiver: string;
                      sunburst: string;
                      custom: string;
                      chart: string;
                  };
              };
              aria: {
                  general: { withTitle: string; withoutTitle: string };
                  series: {
                      single: {
                          prefix: string;
                          withName: string;
                          withoutName: string;
                      };
                      multiple: {
                          prefix: string;
                          withName: string;
                          withoutName: string;
                          separator: { middle: string; end: string };
                      };
                  };
                  data: {
                      allData: string;
                      partialData: string;
                      withName: string;
                      withoutName: string;
                      separator: { middle: string; end: string };
                  };
              };
          }>
) => string;

variable time_d_roundTime

const time_d_roundTime: (
    date: Date,
    timeUnit:
        | 'year'
        | 'month'
        | 'day'
        | 'hour'
        | 'minute'
        | 'second'
        | 'millisecond',
    isUTC: boolean
) => Date;

variable TITLE_TYPES

const TITLE_TYPES: readonly ['line', 'bar', 'stack', 'tiled'];

variable TRANSFORMABLE_PROPS

const TRANSFORMABLE_PROPS: readonly [
    'x',
    'y',
    'originX',
    'originY',
    'anchorX',
    'anchorY',
    'rotation',
    'scaleX',
    'scaleY',
    'skewX',
    'skewY'
];

variable updateMethods

let updateMethods: {
    prepareAndUpdate: UpdateMethod;
    update: UpdateMethod;
    updateTransform: UpdateMethod;
    updateView: UpdateMethod;
    updateVisual: UpdateMethod;
    updateLayout: UpdateMethod;
};

variable util_d_assert

const util_d_assert: (condition: any, message?: string) => void;

variable util_d_assignProps

const util_d_assignProps: {
    <TSrc extends Dictionary<any>, TCommonKey extends keyof TSrc>(
        tar: null,
        src: TSrc,
        props: readonly TCommonKey[]
    ): Pick<TSrc, TCommonKey>;
    <
        TTar extends Dictionary<any>,
        TSrc extends Dictionary<any>,
        TCommonKey extends keyof TSrc & keyof TTar
    >(
        tar: TTar,
        src: TSrc & { [P in TCommonKey]: TTar[P] },
        props: readonly TCommonKey[]
    ): TTar;
};

variable util_d_bind

const util_d_bind: FunctionBind;

variable util_d_clone

const util_d_clone: <T extends unknown>(source: T) => T;

variable util_d_concatArray

const util_d_concatArray: <T, R>(
    a: ArrayLike$1<T>,
    b: ArrayLike$1<R>
) => ArrayLike$1<T | R>;

variable util_d_createCanvas

const util_d_createCanvas: () => HTMLCanvasElement;

variable util_d_createHashMap

const util_d_createHashMap: <T, KEY extends string | number = string | number>(
    obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]
) => HashMap<T, KEY>;

variable util_d_createObject

const util_d_createObject: <T>(proto?: object, properties?: T) => T;

variable util_d_curry

const util_d_curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

variable util_d_defaults

const util_d_defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

variable util_d_disableUserSelect

const util_d_disableUserSelect: (dom: HTMLElement) => void;

variable util_d_each

const util_d_each: <
    I extends any[] | readonly any[] | ArrayLike$1<any> | Dictionary<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike$1<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike$1<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

variable util_d_EPSILON

const util_d_EPSILON: number;

variable util_d_eqNaN

const util_d_eqNaN: (value: any) => boolean;

variable util_d_extend

const util_d_extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

variable util_d_filter

const util_d_filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

variable util_d_find

const util_d_find: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index?: number, arr?: readonly T[]) => boolean,
    context?: Context
) => T;

variable util_d_guid

const util_d_guid: () => number;

variable util_d_HashMap

const util_d_HashMap: typeof HashMap;

variable util_d_hasOwn

const util_d_hasOwn: (own: object, prop: string) => boolean;

variable util_d_indexOf

const util_d_indexOf: <T>(
    array: T[] | readonly T[] | ArrayLike$1<T>,
    value: T
) => number;

variable util_d_inherits

const util_d_inherits: (clazz: Function, baseClazz: Function) => void;

variable util_d_isArray

const util_d_isArray: (value: any) => value is any[];

variable util_d_isArrayLike

const util_d_isArrayLike: (data: any) => data is ArrayLike$1<any>;

variable util_d_isBuiltInObject

const util_d_isBuiltInObject: (value: any) => boolean;

variable util_d_isDom

const util_d_isDom: (value: any) => value is HTMLElement;

variable util_d_isFunction

const util_d_isFunction: (value: any) => value is Function;

variable util_d_isGradientObject

const util_d_isGradientObject: (value: any) => value is GradientObject;

variable util_d_isImagePatternObject

const util_d_isImagePatternObject: (value: any) => value is ImagePatternObject;

variable util_d_isNumber

const util_d_isNumber: (value: any) => value is number;

variable util_d_isObject

const util_d_isObject: <T = unknown>(value: T) => value is object & T;

variable util_d_isPrimitive

const util_d_isPrimitive: (obj: any) => boolean;

variable util_d_isRegExp

const util_d_isRegExp: (value: unknown) => value is RegExp;

variable util_d_isString

const util_d_isString: (value: any) => value is string;

variable util_d_isStringSafe

const util_d_isStringSafe: (value: any) => value is string;

variable util_d_isTypedArray

const util_d_isTypedArray: (value: any) => boolean;

variable util_d_keys

const util_d_keys: <T extends object>(obj: T) => (KeyOfDistributive<T> & string)[];

variable util_d_logError

const util_d_logError: (...args: any[]) => void;

variable util_d_map

const util_d_map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

variable util_d_merge

const util_d_merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

variable util_d_mergeAll

const util_d_mergeAll: (targetAndSources: any[], overwrite?: boolean) => any;

variable util_d_mixin

const util_d_mixin: <T, S>(
    target: Function | T,
    source: Function | S,
    override?: boolean
) => void;

variable util_d_noop

const util_d_noop: () => void;

variable util_d_normalizeCssArray

const util_d_normalizeCssArray: (val: number | number[]) => number[];

variable util_d_RADIAN_TO_DEGREE

const util_d_RADIAN_TO_DEGREE: number;

variable util_d_reduce

const util_d_reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

variable util_d_retrieve

const util_d_retrieve: <T>(...args: T[]) => T;

variable util_d_retrieve2

const util_d_retrieve2: <T, R>(value0: T, value1: R) => T | R;

variable util_d_retrieve3

const util_d_retrieve3: <T, R, W>(value0: T, value1: R, value2: W) => T | R | W;

variable util_d_setAsPrimitive

const util_d_setAsPrimitive: (obj: any) => void;

variable util_d_slice

const util_d_slice: <T>(arr: ArrayLike$1<T>, start?: number, end?: number) => T[];

variable util_d_trim

const util_d_trim: (str: string) => string;

variable util_d$1_bind

const util_d$1_bind: FunctionBind;

variable util_d$1_clone

const util_d$1_clone: <T extends unknown>(source: T) => T;

variable util_d$1_curry

const util_d$1_curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

variable util_d$1_defaults

const util_d$1_defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

variable util_d$1_each

const util_d$1_each: <
    I extends any[] | readonly any[] | ArrayLike$1<any> | Dictionary<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike$1<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike$1<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

variable util_d$1_extend

const util_d$1_extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

variable util_d$1_filter

const util_d$1_filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

variable util_d$1_indexOf

const util_d$1_indexOf: <T>(
    array: T[] | readonly T[] | ArrayLike$1<T>,
    value: T
) => number;

variable util_d$1_inherits

const util_d$1_inherits: (clazz: Function, baseClazz: Function) => void;

variable util_d$1_isArray

const util_d$1_isArray: (value: any) => value is any[];

variable util_d$1_isFunction

const util_d$1_isFunction: (value: any) => value is Function;

variable util_d$1_isObject

const util_d$1_isObject: <T = unknown>(value: T) => value is object & T;

variable util_d$1_isString

const util_d$1_isString: (value: any) => value is string;

variable util_d$1_map

const util_d$1_map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

variable util_d$1_merge

const util_d$1_merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

variable util_d$1_reduce

const util_d$1_reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

variable vector_d_add

const vector_d_add: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable vector_d_applyTransform

const vector_d_applyTransform: <T extends VectorArray>(
    out: T,
    v: VectorArray,
    m: MatrixArray
) => T;

variable vector_d_copy

const vector_d_copy: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable vector_d_create

const vector_d_create: (x?: number, y?: number) => VectorArray;

variable vector_d_dist

const vector_d_dist: (v1: VectorArray, v2: VectorArray) => number;

variable vector_d_distance

const vector_d_distance: (v1: VectorArray, v2: VectorArray) => number;

variable vector_d_distanceSquare

const vector_d_distanceSquare: (v1: VectorArray, v2: VectorArray) => number;

variable vector_d_distSquare

const vector_d_distSquare: (v1: VectorArray, v2: VectorArray) => number;

variable vector_d_div

const vector_d_div: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable vector_d_dot

const vector_d_dot: (v1: VectorArray, v2: VectorArray) => number;

variable vector_d_len

const vector_d_len: (v: VectorArray) => number;

variable vector_d_length

const vector_d_length: (v: VectorArray) => number;

variable vector_d_lengthSquare

const vector_d_lengthSquare: (v: VectorArray) => number;

variable vector_d_lenSquare

const vector_d_lenSquare: (v: VectorArray) => number;

variable vector_d_lerp

const vector_d_lerp: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    t: number
) => T;

variable vector_d_max

const vector_d_max: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable vector_d_min

const vector_d_min: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable vector_d_mul

const vector_d_mul: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable vector_d_negate

const vector_d_negate: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable vector_d_normalize

const vector_d_normalize: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable vector_d_scale

const vector_d_scale: <T extends VectorArray>(
    out: T,
    v: VectorArray,
    s: number
) => T;

variable vector_d_scaleAndAdd

const vector_d_scaleAndAdd: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    a: number
) => T;

variable vector_d_set

const vector_d_set: <T extends VectorArray>(out: T, a: number, b: number) => T;

variable vector_d_sub

const vector_d_sub: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray
) => T;

variable version

const version: string;

variable version

const version: string;

variable zrender_d_dispose

const zrender_d_dispose: (zr: ZRender) => void;

variable zrender_d_disposeAll

const zrender_d_disposeAll: () => void;

variable zrender_d_getElementSSRData

const zrender_d_getElementSSRData: (el: Element<ElementProps>) => ElementSSRData;

variable zrender_d_getInstance

const zrender_d_getInstance: (id: number) => ZRender;

variable zrender_d_init

const zrender_d_init: (dom?: HTMLElement, opts?: ZRenderInitOpt) => ZRender;

variable zrender_d_registerPainter

const zrender_d_registerPainter: (name: string, Ctor: PainterBaseCtor) => void;

variable zrender_d_registerSSRDataGetter

const zrender_d_registerSSRDataGetter: <T>(getter: ElementSSRDataGetter<T>) => void;

variable zrender_d_version

const zrender_d_version: string;

Functions

function add

add: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function addCommas

addCommas: (x: string | number) => string;

Add a comma each three digit.

function applyTransform

applyTransform: <T extends VectorArray>(
    out: T,
    v: VectorArray,
    m: MatrixArray
) => T;

function asc

asc: <T extends number[]>(arr: T) => T;

Inplacd asc sort arr. The input arr will be modified.

function assert

assert: (condition: any, message?: string) => void;

function assignProps

assignProps: {
    <TSrc extends Dictionary<any>, TCommonKey extends keyof TSrc>(
        tar: NullUndefined,
        src: TSrc,
        props: readonly TCommonKey[]
    ): Pick<TSrc, TCommonKey>;
    <
        TTar extends Dictionary<any>,
        TSrc extends Dictionary<any>,
        TCommonKey extends keyof TSrc & keyof TTar
    >(
        tar: TTar,
        src: TSrc & { [P in TCommonKey]: TTar[P] },
        props: readonly TCommonKey[]
    ): TTar;
};

function capitalFirst

capitalFirst: (str: string) => string;

Capital first
Parameter str
{string}

function clipPointsByRect

clipPointsByRect: (points: VectorArray[], rect: ZRRectLike) => number[][];

function clipRectByRect

clipRectByRect: (
    targetRect: ZRRectLike,
    rect: ZRRectLike
) => ZRRectLike | undefined;

Return a new clipped rect. If rect size are negative, return undefined.

function clone

clone: <T extends unknown>(source: T) => T;

function clone$1

clone$1: (v: VectorArray) => VectorArray;

function clone$2

clone$2: (a: MatrixArray) => MatrixArray;

function concatArray

concatArray: <T, R>(a: ArrayLike$1<T>, b: ArrayLike$1<R>) => ArrayLike$1<T | R>;

function connect

connect: (groupId: string | EChartsType[]) => string;

(A)

let chart1 = echarts.init(dom1);
let chart2 = echarts.init(dom2);
chart1.group = 'xxx';
chart2.group = 'xxx';
echarts.connect('xxx');

(B)

let chart1 = echarts.init(dom1);
let chart2 = echarts.init(dom2);
echarts.connect('xxx', [chart1, chart2]);

function copy

copy: <T extends VectorArray>(out: T, v: VectorArray) => T;

function copy$1

copy$1: (out: MatrixArray, m: MatrixArray) => MatrixArray;

function create

create: (x?: number, y?: number) => VectorArray;

function create$1

create$1: () => MatrixArray;

function createCanvas

createCanvas: () => HTMLCanvasElement;

function createDimensions

createDimensions: (
    source: Source | OptionSourceData,
    opt?: PrepareSeriesDataSchemaParams
) => SeriesDimensionDefine[];

For outside usage compat (like echarts-gl are using it).

function createHashMap

createHashMap: <T, KEY extends string | number = string | number>(
    obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]
) => HashMap<T, KEY>;

function createIcon

createIcon: (
    iconStr: string,
    opt?: Omit<DisplayableProps, 'style'>,
    rect?: ZRRectLike
) => SVGPath$1 | ZRImage;

function createList

createList: (
    seriesModel: SeriesModel
) => SeriesData<Model<any>, DefaultDataVisual>;

Create a multi dimension List structure from seriesModel.

function createObject

createObject: <T>(proto?: object, properties?: T) => T;

function createScale

createScale: (
    dataExtent: number[],
    option: object | AxisBaseModel
) => Scale<unknown>;

Externally used by echarts-gl. Create scale
Parameter dataExtent
Parameter option
If option.type is specified, it can only be 'value' currently.

function createSymbol

createSymbol: (
    symbolType: string,
    x: number,
    y: number,
    w: number,
    h: number,
    color?: ZRColor,
    keepAspect?: boolean
) => ECSymbol;

Create a symbol element with given symbol configuration: shape, x, y, width, height, color

function createTextStyle

createTextStyle: (
    textStyleModel: Model<TextCommonOption>,
    opts?: { state?: DisplayState }
) => TextStyleProps;

function curry

curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

function defaults

defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

function disableUserSelect

disableUserSelect: (dom: HTMLElement) => void;

function disconnect

disconnect: (groupId: string) => void;

function dispose

dispose: (chart: EChartsType | HTMLElement | string) => void;

Dispose a chart instance

function disposeAll

disposeAll: () => void;

function distance

distance: (v1: VectorArray, v2: VectorArray) => number;

function distanceSquare

distanceSquare: (v1: VectorArray, v2: VectorArray) => number;

function div

div: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function dot

dot: (v1: VectorArray, v2: VectorArray) => number;

function each

each: <
    I extends any[] | readonly any[] | ArrayLike$1<any> | Dictionary<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike$1<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike$1<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

function enableDataStack

enableDataStack: (
    seriesModel: SeriesModel<SeriesOption & SeriesStackOptionMixin>,
    dimensionsInput:
        | EnableDataStackDimensionsInput
        | EnableDataStackDimensionsInputLegacy,
    opt?: { stackedCoordDimension?: string; byIndex?: boolean }
) => Pick<
    DataCalculationInfo<unknown>,
    | 'stackedDimension'
    | 'stackedByDimension'
    | 'isStackedByIndex'
    | 'stackedOverDimension'
    | 'stackResultDimension'
>;

Note that it is too complicated to support 3d stack by value (have to create two-dimension inverted index), so in 3d case we just support that stacked by index.
Stack is calculated in src/processor/dataStack.ts.
Parameter seriesModel
Parameter dimensionsInput
The same as the input of <module:echarts/data/SeriesData>. The input will be modified.
Parameter opt
Parameter
opt.stackedCoordDimension Specify a coord dimension if needed.
Parameter
opt.byIndex=false calculationInfo { stackedDimension: string stackedByDimension: string isStackedByIndex: boolean stackedOverDimension: string stackResultDimension: string }

function enableHoverEmphasis

enableHoverEmphasis: (
    el: Element,
    focus?: InnerFocus,
    blurScope?: BlurScope
) => void;

Enable the function that mouseover will trigger the emphasis state.
NOTE: This function should be used on the element with dataIndex, seriesIndex.

function encodeHTML

encodeHTML: (source: string) => string;

function eqNaN

eqNaN: (value: any) => boolean;

function extend

extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

function extendChartView

extendChartView: (proto: object) => ChartView;

function extendComponentModel

extendComponentModel: (proto: object) => ComponentModel;

function extendComponentView

extendComponentView: (proto: object) => ChartView;

function extendFromString

extendFromString: (str: string, defaultOpts?: SVGPathOption) => typeof SVGPath;

function extendPath

extendPath: (pathData: string, opts: SVGPathOption$1) => SVGPathCtor;

Extend path

function extendSeriesModel

extendSeriesModel: (proto: object) => SeriesModel;

function extendShape

extendShape: (opts: ExtendShapeOpt) => ExtendShapeReturn;

Extend shape with parameters

function fastLerp

fastLerp: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

function filter

filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

function find

find: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index?: number, arr?: readonly T[]) => boolean,
    context?: Context
) => T;

function format

format: (
    time: unknown,
    template: string,
    isUTC: boolean,
    lang?: string | Model<LocaleOption>
) => string;

function formatTime

formatTime: (tpl: string, value: unknown, isUTC?: boolean) => string;

Parameter tpl
Parameter value
Parameter isUTC
Default in local time. see module:echarts/scale/Time and module:echarts/util/number#parseDate.
Deprecated
Use time/format instead. ISO Date format

function formatTpl

formatTpl: (
    tpl: string,
    paramsList: TplFormatterParam | TplFormatterParam[],
    encode?: boolean
) => string;

Template formatter
Parameter paramsList

function getCoordinateSystemDimensions

getCoordinateSystemDimensions: (type: string) => DimensionDefinitionLoose[];

Get dimensions of specified coordinate system.
Parameter type
{Array.<string|Object>}

function getECData

getECData: (hostObj: Element<ElementProps>) => ECData;

function getElementSSRData

getElementSSRData: (el: Element) => ElementSSRData;

function getInstance

getInstance: (id: number) => ZRender;

function getInstanceByDom

getInstanceByDom: (dom: HTMLElement) => EChartsType | undefined;

function getInstanceById

getInstanceById: (key: string) => EChartsType | undefined;

function getLayoutRect

getLayoutRect: (
    positionInfo: BoxLayoutOptionMixin & { aspect?: number },
    containerRect: GetLayoutRectInputContainerRect,
    margin?: number | number[]
) => LayoutRect;

Parse position info.

function getMap

getMap: (mapName: string) => any;

function getPercentWithPrecision

getPercentWithPrecision: (
    valueList: number[],
    idx: number,
    precision: number
) => number;

Get a data of given precision, assuring the sum of percentages in valueList is 1. The largest remainder method is used. https://en.wikipedia.org/wiki/Largest_remainder_method
Parameter valueList
a list of all data
Parameter idx
index of the data to be processed in valueList
Parameter precision
integer number showing digits of precision percent ranging from 0 to 100

function getPixelPrecision

getPixelPrecision: (
    dataExtent: [number, number],
    pixelExtent: [number, number]
) => number;

Deprecated
Use getAcceptableTickPrecision instead. See bad case in test/ut/spec/util/number.test.ts NOTE: originally introduced in commit ff93e3e7f9ff24902e10d4469fd3187393b05feb
Minimal discernible data precision according to a single pixel.

function getPrecision

getPrecision: (val: string | number) => number;

Get precision. e.g. getPrecisionSafe(100.123) return 3. e.g. getPrecisionSafe(100) return 0.

function getPrecisionSafe

getPrecisionSafe: (val: string | number) => number;

Get precision with slow but safe method e.g. getPrecisionSafe(100.123) return 3. e.g. getPrecisionSafe(100) return 0.

function getShapeClass

getShapeClass: (name: string) => { new (): Path };

Find shape class registered by registerShape. Usually used in fetching user defined shape.
[Caution]: (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared to use user registered shapes. Because the built-in shape (see getBuiltInShape) will be registered by registerShape by default. That enables users to get both built-in shapes as well as the shapes belonging to themsleves. But users can overwrite the built-in shapes by using names like 'circle', 'rect' via calling registerShape. So the echarts inner featrues should not fetch shapes from here in case that it is overwritten by users, except that some features, like custom series, graphic component, do it deliberately.
(2) In the features like custom series, graphic component, the user input {tpye: 'xxx'} does not only specify shapes but also specify other graphic elements like 'group', 'text', 'image' or event 'path'. Those names are reserved names, that is, if some user registers a shape named 'image', the shape will not be used. If we intending to add some more reserved names in feature, that might bring break changes (disable some existing user shape names). But that case probably rarely happens. So we don't make more mechanism to resolve this issue here.
Parameter name
The shape class. If not found, return nothing.

function getStackedDimension

getStackedDimension: (data: SeriesData, targetDim: string) => DimensionName;

function getTextRect

getTextRect: (
    text: TextStyleProps$1['text'],
    font?: TextStyleProps$1['font'],
    align?: TextStyleProps$1['align'],
    verticalAlign?: TextStyleProps$1['verticalAlign'],
    padding?: TextStyleProps$1['padding'],
    rich?: TextStyleProps$1['rich'],
    truncate?: boolean,
    lineHeight?: number
) => BoundingRect;

function getTooltipMarker

getTooltipMarker: {
    (color: ColorString, extraCssText?: string): TooltipMarker;
    (opt: GetTooltipMarkerOpt): TooltipMarker;
};

function getTransform

getTransform: (target: Transformable, ancestor?: Transformable) => MatrixArray;

Get transform matrix of target (param target), in coordinate of its ancestor (param ancestor)
Parameter target
Parameter ancestor

function guid

guid: () => number;

function hasOwn

hasOwn: (own: object, prop: string) => boolean;

function identity

identity: (out: MatrixArray) => MatrixArray;

function indexOf

indexOf: <T>(array: T[] | readonly T[] | ArrayLike$1<T>, value: T) => number;

function inherits

inherits: (clazz: Function, baseClazz: Function) => void;

function init

init: (
    dom?: HTMLElement | null,
    theme?: string | object | null,
    opts?: EChartsInitOpts
) => EChartsType;

Parameter
opts.devicePixelRatio Use window.devicePixelRatio by default
Parameter
opts.renderer Can choose 'canvas' or 'svg' to render the chart.
Parameter
opts.width Use clientWidth of the input dom by default. Can be 'auto' (the same as null/undefined)
Parameter
opts.height Use clientHeight of the input dom by default. Can be 'auto' (the same as null/undefined)
Parameter
opts.locale Specify the locale.
Parameter
opts.useDirtyRect Enable dirty rectangle rendering or not.

function initProps

initProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?:
        | AnimateOrSetPropsOption['dataIndex']
        | AnimateOrSetPropsOption['cb']
        | AnimateOrSetPropsOption,
    cb?: AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption['during'],
    during?: AnimateOrSetPropsOption['during']
) => void;

Init graphic element properties with or without animation according to the configuration in series.
Caution: this method will stop previous animation. So do not use this method to one element twice before animation starts, unless you know what you are doing.

function innerDrawElementOnCanvas

innerDrawElementOnCanvas: (
    ctx: CanvasRenderingContext2D,
    el: Displayable
) => void;

function invert

invert: (out: MatrixArray, a: MatrixArray) => MatrixArray | null;

function isArray

isArray: (value: any) => value is any[];

function isArrayLike

isArrayLike: (data: any) => data is ArrayLike$1<any>;

function isBuiltInObject

isBuiltInObject: (value: any) => boolean;

function isDimensionStacked

isDimensionStacked: (data: SeriesData, stackedDim: string) => boolean;

function isDom

isDom: (value: any) => value is HTMLElement;

function isFunction

isFunction: (value: any) => value is Function;

function isGradientObject

isGradientObject: (value: any) => value is GradientObject;

function isImagePatternObject

isImagePatternObject: (value: any) => value is ImagePatternObject;

function isNumber

isNumber: (value: any) => value is number;

function isNumeric

isNumeric: (val: unknown) => val is number;

Definition of "numeric": see numericToNumber.

function isObject

isObject: <T = unknown>(value: T) => value is object & T;

function isPrimitive

isPrimitive: (obj: any) => boolean;

function isRadianAroundZero

isRadianAroundZero: (val: number) => boolean;

Parameter radian
{boolean}

function isRegExp

isRegExp: (value: unknown) => value is RegExp;

function isString

isString: (value: any) => value is string;

function isStringSafe

isStringSafe: (value: any) => value is string;

function isTypedArray

isTypedArray: (value: any) => boolean;

function keys

keys: <T extends object>(obj: T) => (KeyOfDistributive<T> & string)[];

function len

len: (v: VectorArray) => number;

function lenSquare

lenSquare: (v: VectorArray) => number;

function lerp

lerp: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    t: number
) => T;

function lerp$1

lerp$1: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

function lift

lift: (color: string, level: number) => string;

function liftColor

liftColor: { (color: GradientObject): GradientObject; (color: string): string };

function linearMap

linearMap: (
    val: number,
    domain: number[],
    range: number[],
    clamp?: boolean
) => number;

Linear mapping a value from domain to range
Parameter val
Parameter domain
Domain extent domain[0] can be bigger than domain[1]
Parameter range
Range extent range[0] can be bigger than range[1]
Parameter clamp
Default to be false

function logError

logError: (...args: any[]) => void;

function lum

lum: (color: string, backgroundLum: number) => number;

function makeImage

makeImage: (
    imageUrl: string,
    rect: ZRRectLike,
    layout?: 'center' | 'cover'
) => ZRImage;

Create a image element from image url
Parameter imageUrl
image url
Parameter opts
options
Parameter rect
constrain rect
Parameter layout
'center' or 'cover'. Default to be 'cover'

function makePath

makePath: (
    pathData: string,
    opts: SVGPathOption$1,
    rect: ZRRectLike,
    layout?: 'center' | 'cover'
) => SVGPath$1;

Create a path element from path data string
Parameter pathData
Parameter opts
Parameter rect
Parameter layout
'center' or 'cover' default to be cover

function makeStyleMapper

makeStyleMapper: (
    properties: readonly string[][],
    ignoreParent?: boolean
) => (
    model: Model,
    excludes?: readonly string[],
    includes?: readonly string[]
) => PathStyleProps;

function map

map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

function max

max: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function merge

merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

function mergeAll

mergeAll: (targetAndSources: any[], overwrite?: boolean) => any;

function mergePath

mergePath: (pathEls: Path[], opts: PathProps) => Path<PathProps>;

function min

min: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function mixin

mixin: <T, S>(
    target: T | Function,
    source: S | Function,
    override?: boolean
) => void;

function mixinAxisModelCommonMethods

mixinAxisModelCommonMethods: (Model: Model<any>) => void;

Mixin common methods to axis model

function modifyAlpha

modifyAlpha: (color: string, alpha?: number) => string;

function modifyHSL

modifyHSL: (
    color: string,
    h?: number | ((h: number) => number),
    s?: string | number | ((s: number) => number),
    l?: string | number | ((l: number) => number)
) => string;

function mul

mul: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function mul$1

mul$1: (out: MatrixArray, m1: MatrixArray, m2: MatrixArray) => MatrixArray;

function nativeSlice

nativeSlice: (start?: number, end?: number) => any[];

function negate

negate: <T extends VectorArray>(out: T, v: VectorArray) => T;

function nice

nice: (
    val: number,
    mode?: boolean | typeof NICE_MODE_ROUND | typeof NICE_MODE_MIN
) => number;

find a “nice” number approximately equal to x. Round the number if 'round', take ceiling if 'round'. The primary observation is that the “nicest” numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
See "Nice Numbers for Graph Labels" of Graphic Gems.
Parameter val
Non-negative value. Niced number

function noop

noop: () => void;

function normalize

normalize: <T extends VectorArray>(out: T, v: VectorArray) => T;

function normalizeCssArray

normalizeCssArray: (val: number | number[]) => number[];

function numericToNumber

numericToNumber: (val: unknown) => number;

[Numeric is defined as]: parseFloat(val) == val For example: numeric: typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity, and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec) not-numeric: null, undefined, [], {}, true, false, 'NaN', NaN, '123ab', empty string, string with only white-spaces or line-terminal (see es spec), 0x12, '0x12', '-0x12', 012, '012', '-012', non-string, ...
See full test cases in test/ut/spec/util/number.js. Must be a typeof number. If not numeric, return NaN.

function parse

parse: (colorStr: string, rgbaArr?: number[]) => number[];

function parseCssFloat

parseCssFloat: (val: string | number) => number;

function parseCssInt

parseCssInt: (val: string | number) => number;

function parseDate

parseDate: (value: unknown) => Date;

Parameter value
valid type: number | string | Date, otherwise return new Date(NaN) These values can be accepted: + An instance of Date, represent a time in its own time zone. + Or string in a subset of ISO 8601, only including: + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06', + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123', + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00', all of which will be treated as local time if time zone is not specified (see <https://momentjs.com/>). + Or other string format, including (all of which will be treated as local time): '2012', '2012-3-1', '2012/3/1', '2012/03/01', '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123' + a timestamp, which represent a time in UTC. date Never be null/undefined. If invalid, return new Date(NaN).

function parseGeoJson

parseGeoJson: (
    geoJson: GeoJSON | GeoJSONCompressed,
    nameProperty: string
) => GeoJSONRegion[];

function parseGeoJSON

parseGeoJSON: (
    geoJson: GeoJSON | GeoJSONCompressed,
    nameProperty: string
) => GeoJSONRegion[];

function parsePositionOption

parsePositionOption: (
    option: unknown,
    percentBase: number,
    percentOffset?: number
) => number;

See Also
- {parsePositionSizeOption} and also accept a string preset.
- {PositionSizeOption}

function quantile

quantile: (ascArr: number[], p: number) => number;

This code was copied from "d3.js" <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>. See the license statement at the head of this file.
Parameter ascArr

function quantity

quantity: (val: number) => number;

Quantity of a number. e.g. 0.1, 1, 10, 100
Parameter val

function quantityExponent

quantityExponent: (val: number) => number;

Exponent of the quantity of a number e.g., 9876 equals to 9.876*10^3, so quantityExponent(9876) is 3 e.g., 0.09876 equals to 9.876*10^-2, so quantityExponent(0.09876) is -2
Parameter val
non-negative value

function random

random: () => string;

function reduce

reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

function reformIntervals

reformIntervals: (list: IntervalItem[]) => IntervalItem[];

Order intervals asc, and split them when overlap. expect(numberUtil.reformIntervals([ {interval: [18, 62], close: [1, 1]}, {interval: [-Infinity, -70], close: [0, 0]}, {interval: [-70, -26], close: [1, 1]}, {interval: [-26, 18], close: [1, 1]}, {interval: [62, 150], close: [1, 1]}, {interval: [106, 150], close: [1, 1]}, {interval: [150, Infinity], close: [0, 0]} ])).toEqual([ {interval: [-Infinity, -70], close: [0, 0]}, {interval: [-70, -26], close: [1, 1]}, {interval: [-26, 18], close: [0, 1]}, {interval: [18, 62], close: [0, 1]}, {interval: [62, 150], close: [0, 1]}, {interval: [150, Infinity], close: [0, 0]} ]);
Parameter list
, where close mean open or close of the interval, and Infinity can be used. The origin list, which has been reformed.

function registerAction

registerAction: {
    (type: string, eventType: string, action: ActionHandler): void;
    (type: string, action: ActionHandler): void;
    (actionInfo: ActionInfo, action?: ActionHandler): void;
};

registerAction('someAction', 'someEvent', function () { ... }); registerAction('someAction', function () { ... }); registerAction( {type: 'someAction', event: 'someEvent', update: 'updateView'}, function () { ... } ); registerAction({ type: 'someAction', event: 'someEvent', update: 'updateView' action: function () { ... } refineEvent: function () { ... } });
See Also
- {ActionInfo} for more details.

function registerCoordinateSystem

registerCoordinateSystem: (
    type: string,
    coordSysCreator: CoordinateSystemCreator
) => void;

function registerCustomSeries

registerCustomSeries: (
    seriesType: string,
    renderItem: CustomSeriesRenderItem
) => void;

function registerExternalTransform

registerExternalTransform: (externalTransform: ExternalDataTransform) => void;

function registerImpl

registerImpl: (name: string, impl: any) => void;

function registerLayout

registerLayout: {
    (priority: number, layoutTask: StageHandler | StageHandlerOverallReset): void;
    (layoutTask: StageHandler | StageHandlerOverallReset): void;
};

Layout is a special stage of visual encoding Most visual encoding like color are common for different chart But each chart has it's own layout algorithm

function registerLoading

registerLoading: (name: string, loadingFx: LoadingEffectCreator) => void;

function registerLocale

registerLocale: (locale: string, localeObj: LocaleOption) => void;

function registerMap

registerMap: (
    mapName: RegisterMapParams[0],
    geoJson: RegisterMapParams[1],
    specialAreas?: RegisterMapParams[2]
) => void;

The parameters and usage: see geoSourceManager.registerMap. Compatible with previous echarts.registerMap.

function registerPainter

registerPainter: (name: string, Ctor: PainterBaseCtor) => void;

function registerPostInit

registerPostInit: (postInitFunc: PostIniter) => void;

function registerPostUpdate

registerPostUpdate: (postUpdateFunc: PostUpdater) => void;

function registerPreprocessor

registerPreprocessor: (preprocessorFunc: OptionPreprocessor) => void;

function registerProcessor

registerProcessor: (
    priority: number | StageHandler | StageHandlerOverallReset,
    processor?: StageHandler | StageHandlerOverallReset
) => void;

NOTICE: Alway run in block way (no progessive is allowed).

function registerShape

registerShape: (name: string, ShapeClass: { new (): Path }) => void;

Register a user defined shape. The shape class can be fetched by getShapeClass This method will overwrite the registered shapes, including the registered built-in shapes, if using the same name. The shape can be used in custom series and graphic component by declaring {type: name}.
Parameter name
Parameter ShapeClass
Can be generated by extendShape.

function registerSSRDataGetter

registerSSRDataGetter: <T>(getter: ElementSSRDataGetter<T>) => void;

function registerTheme

registerTheme: (name: string, theme: ThemeOption) => void;

function registerUpdateLifecycle

registerUpdateLifecycle: <T extends keyof LifecycleEvents>(
    name: T,
    cb: (...args: LifecycleEvents[T]) => void
) => void;

function registerVisual

registerVisual: {
    (priority: number, layoutTask: StageHandler | StageHandlerOverallReset): void;
    (layoutTask: StageHandler | StageHandlerOverallReset): void;
};

function remRadian

remRadian: (radian: number) => number;

To 0 - 2 * PI, considering negative radian.

function resizePath

resizePath: (path: SVGPath$1, rect: ZRRectLike) => void;

Resize a path to fit the rect
Parameter path
Parameter rect

function retrieve

retrieve: <T>(...args: T[]) => T;

function retrieve2

retrieve2: <T, R>(value0: T, value1: R) => T | R;

function retrieve3

retrieve3: <T, R, W>(value0: T, value1: R, value2: W) => T | R | W;

function rotate

rotate: (
    out: MatrixArray,
    a: MatrixArray,
    rad: number,
    pivot?: VectorArray
) => MatrixArray;

function roundLegacy

roundLegacy: {
    (x: number | string, precision?: number): number;
    (x: string | number, precision: number, returnStr: false): number;
    (x: string | number, precision: number, returnStr: true): string;
};

function roundTime

roundTime: (date: Date, timeUnit: PrimaryTimeUnit, isUTC: boolean) => Date;

e.g., If timeUnit is 'year', return the Jan 1st 00:00:00 000 of that year. If timeUnit is 'day', return the 00:00:00 000 of that day.
The input date.

function scale

scale: <T extends VectorArray>(out: T, v: VectorArray, s: number) => T;

function scale$1

scale$1: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

function scaleAndAdd

scaleAndAdd: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    a: number
) => T;

function set

set: <T extends VectorArray>(out: T, a: number, b: number) => T;

function setAsPrimitive

setAsPrimitive: (obj: any) => void;

function setCanvasCreator

setCanvasCreator: (creator: () => HTMLCanvasElement) => void;

ZRender need a canvas context to do measureText. But in node environment canvas may be created by node-canvas. So we need to specify how to create a canvas instead of using document.createElement('canvas')
Example 1
let Canvas = require('canvas'); let echarts = require('echarts'); echarts.setCanvasCreator(function () { // Small size is enough. return new Canvas(32, 32); });
Deprecated
use setPlatformAPI({ createCanvas }) instead.

function setPlatformAPI

setPlatformAPI: (newPlatformApis: Partial<Platform>) => void;

function shapeCompareFunc

shapeCompareFunc: (a: Displayable, b: Displayable) => number;

function slice

slice: <T>(arr: ArrayLike$1<T>, start?: number, end?: number) => T[];

function stringify

stringify: (arrColor: number[], type: string) => string;

function sub

sub: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function throttle

throttle: <T extends ThrottleFunction>(
    fn: T,
    delay?: number,
    debounce?: boolean
) => T & ThrottleController;

Parameter fn
Parameter delay
Unit: ms.
Parameter debounce
true: If call interval less than delay, only the last call works. false: If call interval less than `delay, call works on fixed rate. {(Function)} throttled fn.
Modifiers
- @public

function toCamelCase

toCamelCase: (str: string, upperCaseFirst?: boolean) => string;

function toHex

toHex: (color: string) => string;

function translate

translate: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

function trim

trim: (str: string) => string;

function truncateText

truncateText: (
    text: string,
    containerWidth: number,
    font: string,
    ellipsis?: string,
    options?: InnerTruncateOption
) => string;

function updateProps

updateProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?:
        | AnimateOrSetPropsOption['dataIndex']
        | AnimateOrSetPropsOption['cb']
        | AnimateOrSetPropsOption,
    cb?: AnimateOrSetPropsOption['cb'] | AnimateOrSetPropsOption['during'],
    during?: AnimateOrSetPropsOption['during']
) => void;

Update graphic element properties with or without animation according to the configuration in series.
Caution: this method will stop previous animation. So do not use this method to one element twice before animation starts, unless you know what you are doing.
Example 1
graphic.updateProps(el, { position: [100, 100] }, seriesModel, dataIndex, function () { console.log('Animation done!'); }); // Or graphic.updateProps(el, { position: [100, 100] }, seriesModel, function () { console.log('Animation done!'); });

function use

use: (
    ext:
        | EChartsExtensionInstaller
        | EChartsExtension
        | (EChartsExtensionInstaller | EChartsExtension)[]
) => void;

Classes

class Axis

class Axis {}

Base class of Axis.
Lifetime: recreate for each main process. [NOTICE]: Some caches is stored on the axis instance (e.g., axisTickLabelBuilder.ts, scaleRawExtentInfo.ts), which is based on this lifetime.

constructor

constructor(dim: string, scale: Scale<unknown>, extent: [number, number]);

property dim

readonly dim: string;

property getRotate

getRotate: () => number;

Get axis rotate, by degree.

property inverse

inverse: boolean;

property model

model: AxisBaseModel<AxisBaseOptionCommon>;

property onBand

onBand: boolean;

property scale

scale: Scale<unknown>;

property type

type: 'value' | 'category' | 'time' | 'log';

Axis type - 'category' - 'value' - 'time' - 'log'

method calculateCategoryInterval

calculateCategoryInterval: (ctx?: AxisLabelsComputingContext) => number;

Only be called in category axis. Can be overridden, consider other axes like in 3D. Auto interval for category axis tick and label

method contain

contain: (coord: number) => boolean;

If axis extent contain given coord

method containData

containData: (data: ScaleDataValue) => boolean;

If axis extent contain given data

method coordToData

coordToData: (coord: number, clamp?: boolean) => number;

Convert coord to data. Data is the rank if it has an ordinal scale

method dataToCoord

dataToCoord: (data: ScaleDataValue, clamp?: boolean) => number;

Convert data to coord. Data is the rank if it has an ordinal scale

method getBandWidth

getBandWidth: () => number;

Deprecated
Use calcBandWidth instead.

method getExtent

getExtent: () => [number, number];

Get coord extent.

method getLabelModel

getLabelModel: () => Model<AxisBaseOption['axisLabel']>;

method getMinorTicksCoords

getMinorTicksCoords: () => AxisTickCoord[][];

method getTickModel

getTickModel: () => Model<AxisTickOptionUnion>;

Notice here we only get the default tick model. For splitLine or splitArea, we should pass the splitLineModel or splitAreaModel manually when calling getTicksCoords. In GL, this method may be overridden to: axisModel.getModel('axisTick', grid3DModel.getModel('axisTick'));

method getTicksCoords

getTicksCoords: (opt?: {
    tickModel?: Model<CategoryTickLabelSplitBuildingOption>;
    breakTicks?: ScaleGetTicksOpt['breakTicks'];
    pruneByBreak?: ScaleGetTicksOpt['pruneByBreak'];
}) => AxisTickCoord[];

Different from zrUtil.map(axis.getTicks(), axis.dataToCoord, axis), axis.getTicksCoords considers onBand, which is used by boundaryGap:true of category axis and splitLine and splitArea.
Parameter
opt.tickModel default: axis.model.getModel('axisTick')

method getViewLabels

getViewLabels: (ctx?: AxisLabelsComputingContext) => AxisLabelInfoDetermined[];

method pointToData

pointToData: (point: number[], clamp?: boolean) => number;

Convert pixel point to data in axis

method setExtent

setExtent: (start: number, end: number) => void;

Set coord extent

class ChartView

class ChartView {}

constructor

constructor();

property group

readonly group: ViewRootGroup;

property ignoreLabelLineUpdate

ignoreLabelLineUpdate: boolean;

Ignore label line update in global stage. Will handle it in chart itself. Used in pie / funnel

property protoInitialize

static protoInitialize: void;

property registerClass

static registerClass: (clz: Constructor) => Constructor;

property renderTask

readonly renderTask: SeriesTask;

property type

type: string;

property uid

readonly uid: string;

method dispose

dispose: (ecModel: GlobalModel, api: ExtensionAPI) => void;

Dispose self.

method downplay

downplay: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

Downplay series or specified data item.

method eachRendered

eachRendered: (cb: (el: Element) => boolean | void) => void;

Traverse the new rendered elements.
It will traverse the new added element in progressive rendering. And traverse all in normal rendering.

method highlight

highlight: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

Highlight series or specified data item.

method init

init: (ecModel: GlobalModel, api: ExtensionAPI) => void;

method markUpdateMethod

static markUpdateMethod: (payload: Payload, methodName: keyof ChartView) => void;

method remove

remove: (ecModel: GlobalModel, api: ExtensionAPI) => void;

remove only occurs when series is filtered out, typically by legend. And theirafter the view can only be rendered again via ChartView['render'] or ChartView['incrementalPrepareRender'].

method render

render: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

method updateView

updateView: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

method updateVisual

updateVisual: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

class ComponentModel

class ComponentModel<
    Opt extends ComponentOption = ComponentOption
> extends Model<Opt> {}

constructor

constructor(
    option: ComponentOption,
    parentModel: Model<any>,
    ecModel: GlobalModel
);

property boxCoordinateSystem

boxCoordinateSystem?: CoordinateSystem;

property componentIndex

componentIndex: number;

Modifiers
- @readOnly

property defaultOption

protected defaultOption: ComponentOption;

Modifiers
- @readOnly

property dependencies

static dependencies: string[];

Modifiers
- @readOnly

property ecModel

ecModel: GlobalModel;

Modifiers
- @readOnly

property hasClass

static hasClass: (componentType: string) => boolean;

property id

id: string;

Modifiers
- @readonly

property layoutMode

static layoutMode: ComponentLayoutMode | 'box';

Support merge layout params. Only support 'box' now (left/right/top/bottom/width/height).

property mainType

mainType: string;

Modifiers
- @readOnly

property name

name: string;

Because simplified concept is probably better, series.name (or component.name) has been having too many responsibilities: (1) Generating id (which requires name in option should not be modified). (2) As an index to mapping series when merging option or calling API (a name can refer to more than one component, which is convenient is some cases). (3) Display. But injected
Modifiers
- @readOnly

property preventAutoZ

preventAutoZ: boolean;

Prevent from auto set z, zlevel, z2 by the framework.

property protoInitialize

static protoInitialize: void;

property registerClass

static registerClass: (clz: Constructor) => Constructor;

property registerSubTypeDefaulter

static registerSubTypeDefaulter: (
    componentType: string,
    defaulter: SubTypeDefaulter
) => void;

property subType

subType: string;

Modifiers
- @readOnly

property type

type: string;

Modifiers
- @readonly

property uid

readonly uid: string;

method getBoxLayoutParams

getBoxLayoutParams: () => {
    left: PositionSizeOption;
    top: PositionSizeOption;
    right: PositionSizeOption;
    bottom: PositionSizeOption;
    width: PositionSizeOption;
    height: PositionSizeOption;
};

method getDefaultOption

getDefaultOption: () => Opt;

[How to declare defaultOption]:

(A) If using class declaration in typescript (since echarts 5):

import {ComponentOption} from '../model/option.js';
export interface XxxOption extends ComponentOption {
    aaa: number
}
export class XxxModel extends Component {
    static type = 'xxx';
    static defaultOption: XxxOption = {
        aaa: 123
    }
}
Component.registerClass(XxxModel);

import {inheritDefaultOption} from '../util/component.js';
import {XxxModel, XxxOption} from './XxxModel.js';
export interface XxxSubOption extends XxxOption {
    bbb: number
}
class XxxSubModel extends XxxModel {
    static defaultOption: XxxSubOption = inheritDefaultOption(XxxModel.defaultOption, {
        bbb: 456
    })
    fn() {
        let opt = this.getDefaultOption();
        // opt is {aaa: 123, bbb: 456}
    }
}

(B) If using class extend (previous approach in echarts 3 & 4):

let XxxComponent = Component.extend({
    defaultOption: {
        xx: 123
    }
})

let XxxSubComponent = XxxComponent.extend({
    defaultOption: {
        yy: 456
    },
    fn: function () {
        let opt = this.getDefaultOption();
        // opt is {xx: 123, yy: 456}
    }
})

method getReferringComponents

getReferringComponents: (
    mainType: ComponentMainType,
    opt: QueryReferringOpt
) => { models: ComponentModel[]; specified: boolean };

Notice: always force to input param useDefault in case that forget to consider it. The same behavior as modelUtil.parseFinder.
Parameter useDefault
In many cases like series refer axis and axis refer grid, If axis index / axis id not specified, use the first target as default. In other cases like dataZoom refer axis, if not specified, measn no refer.

method getZLevelKey

getZLevelKey: () => string;

If developers don't configure zlevel. We will assign zlevel to series based on the key, if provided. For example, lines with trail effect is expected to be in an individual zlevel.
[GET_ZLEVEL_KEY_FOR_PROGRESSIVE] Regarding "progressive rendering", zrender can automatically assign a dedicated "incremental layer" for el.incremental per zlevel. But there is a trade-off: - If we do not provide different zlevelKey for different series here, all incremental elements from different series will be assigned to one incremental layer, which causes them to cover each other in an order depending on progressive steps. i.e., seriesA_el1 -covered_by-> seriesB_el1 -covered_by-> seriesC_el1 -> seriesA_el2 -> seriesB_el2 ... This order may causes an unexpected visual result: series with small data are likely to be completely covered by series with large data. (like in test/scatter-weibo.html) - If we assign a different zlevelKey to each series, the "covering issue" above can be resolved, but having one HTML Canvas per series may be excessively memory-consuming. Therefore, we only automatically assign zlevelKey on ScatterSeries and LinesSeries for backward compatibility, and not to other series. Users can explicitly assign zlevel if they encouter above "covering issue".

method init

init: (option: Opt, parentModel: Model, ecModel: GlobalModel) => void;

method mergeDefaultAndTheme

mergeDefaultAndTheme: (option: Opt, ecModel: GlobalModel) => void;

method mergeOption

mergeOption: (option: Opt, ecModel: GlobalModel) => void;

method optionUpdated

optionUpdated: (newCptOption: Opt, isInit: boolean) => void;

Called immediately after init or mergeOption of this instance called.

method setZLevel

setZLevel: (zlevel: number) => void;

class ComponentView

class ComponentView {}

constructor

constructor();

property group

readonly group: ViewRootGroup;

property registerClass

static registerClass: (clz: Constructor) => Constructor;

property uid

readonly uid: string;

method dispose

dispose: (ecModel: GlobalModel, api: ExtensionAPI) => void;

method eachRendered

eachRendered: (cb: (el: Element) => boolean | void) => void;

Traverse the new rendered elements.
It will traverse the new added element in progressive rendering. And traverse all in normal rendering.

method init

init: (ecModel: GlobalModel, api: ExtensionAPI) => void;

method render

render: (
    model: ComponentModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

method toggleBlurSeries

toggleBlurSeries: (
    seriesModels: SeriesModel[],
    isBlur: boolean,
    ecModel: GlobalModel
) => void;

Hook for toggle blur target series. Can be used in marker for blur or leave blur the markers

method updateLayout

updateLayout: (
    model: ComponentModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

method updateView

updateView: (
    model: ComponentModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

method updateVisual

updateVisual: (
    model: ComponentModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

class List

class SeriesData<
    HostModel extends Model = Model,
    Visual extends DefaultDataVisual = DefaultDataVisual
> {}

constructor

constructor(
    dimensionsInput: SeriesDataSchema | SeriesDimensionDefineLoose[],
    hostModel: Model<any>
);

Parameter
dimensionsInput.dimensions For example, ['someDimName', {name: 'someDimName', type: 'someDimType'}, ...]. Dimensions should be concrete names like x, y, z, lng, lat, angle, radius

property CHANGABLE_METHODS

CHANGABLE_METHODS: readonly ['filterSelf', 'selectRange'];

property dataType

dataType: SeriesDataType;

Modifiers
- @readonly

property dimensions

readonly dimensions: string[];

Name of dimensions list of SeriesData.
Carefully use the index of this array. Because when DataStore is an extra high dimension(>30) dataset. We will only pick the used dimensions from DataStore to avoid performance issue.

property DOWNSAMPLE_METHODS

DOWNSAMPLE_METHODS: readonly [
    'downSample',
    'minmaxDownSample',
    'lttbDownSample'
];

property graph

graph?: Graph;

Host graph if List is used to store graph nodes / edges.
Modifiers
- @readonly

property hasItemOption

hasItemOption: boolean;

property hostModel

readonly hostModel: Model<any>;

property TRANSFERABLE_METHODS

TRANSFERABLE_METHODS: readonly [
    'cloneShallow',
    'downSample',
    'minmaxDownSample',
    'lttbDownSample',
    'map'
];

property tree

tree?: Tree<Model<any>, any>;

Host tree if List is used to store tree nodes.
Modifiers
- @readonly

property type

readonly type: string;

property userOutput

userOutput: DimensionUserOuput;

method appendData

appendData: (data: ArrayLike$1<any>) => void;

Caution: Can be only called on raw data (before this._indices created).

method appendValues

appendValues: (values: any[][], names?: string[]) => void;

Caution: Can be only called on raw data (before this._indices created). This method does not modify rawData (dataProvider), but only add values to store.
The final count will be increased by Math.max(values.length, names.length).
Parameter values
That is the SourceType: 'arrayRows', like [ [12, 33, 44], [NaN, 43, 1], ['-', 'asdf', 0] ] Each item is exactly corresponding to a dimension.

method clearAllVisual

clearAllVisual: () => void;

Clear itemVisuals and list visual.

method clearItemLayouts

clearItemLayouts: () => void;

Clear all layout of single data item

method cloneShallow

cloneShallow: (list?: SeriesData<HostModel>) => SeriesData<HostModel>;

Shallow clone a new list except visual and layout properties, and graph elements. New list only change the indices.

method count

count: () => number;

method diff

diff: (otherList: SeriesData) => DataDiffer;

Create a data differ

method downSample

downSample: (
    dimension: DimensionLoose,
    rate: number,
    sampleValue: (frameValues: ArrayLike$1<ParsedValue>) => ParsedValueNumeric,
    sampleIndex: (
        frameValues: ArrayLike$1<ParsedValue>,
        value: ParsedValueNumeric
    ) => number
) => SeriesData<HostModel>;

Large data down sampling on given dimension
Parameter sampleIndex
Sample index for name and id

method each

each: {
    <Ctx>(cb: EachCb0<Ctx>, ctx?: Ctx, ctxCompat?: Ctx): void;
    <Ctx>(dims: DimensionLoose, cb: EachCb1<Ctx>, ctx?: Ctx): void;
    <Ctx>(dims: [DimensionLoose], cb: EachCb1<Ctx>, ctx?: Ctx): void;
    <Ctx>(
        dims: [DimensionLoose, DimensionLoose],
        cb: EachCb2<Ctx>,
        ctx?: Ctx
    ): void;
    <Ctx>(dims: ItrParamDims, cb: EachCb$1<Ctx>, ctx?: Ctx): void;
};

Data iteration
Parameter ctx
default this
Example 1
list.each('x', function (x, idx) {}); list.each(['x', 'y'], function (x, y, idx) {}); list.each(0, function (x, idx) {}); list.each([0, 1], function (x, y, idx) {}); list.each(function (idx) {})

method eachItemGraphicEl

eachItemGraphicEl: <Ctx = unknown>(
    cb: (this: Ctx, el: Element, idx: number) => void,
    context?: Ctx
) => void;

method ensureUniqueItemVisual

ensureUniqueItemVisual: <K extends keyof Visual>(
    idx: number,
    key: K
) => Visual[K];

Make sure itemVisual property is unique

method filterSelf

filterSelf: {
    <Ctx>(cb: FilterCb0<Ctx>, ctx?: Ctx, ctxCompat?: Ctx): this;
    <Ctx>(dims: DimensionLoose, cb: FilterCb1<Ctx>, ctx?: Ctx): this;
    <Ctx>(dims: [DimensionLoose], cb: FilterCb1<Ctx>, ctx?: Ctx): this;
    <Ctx>(
        dims: [DimensionLoose, DimensionLoose],
        cb: FilterCb2<Ctx>,
        ctx?: Ctx
    ): this;
    <Ctx>(dims: ItrParamDims, cb: FilterCb$1<Ctx>, ctx?: Ctx): this;
};

Data filter

method get

get: (dim: SeriesDimensionName, idx: number) => ParsedValue;

Get value. Return NaN if idx is out of range.
Should better to use data.getStore().get(dimIndex, dataIdx) instead.

method getApproximateExtent

getApproximateExtent: (
    dim: SeriesDimensionLoose,
    filter: DataSanitizationFilter | NullUndefined
) => [number, number];

Optimize for the scenario that data is filtered by a given extent. Consider that if data amount is more than hundreds of thousand, extent calculation will cost more than 10ms and the cache will be erased because of the filtering.

method getByRawIndex

getByRawIndex: (dim: SeriesDimensionName, rawIdx: number) => ParsedValue;

Should better to use data.getStore().getByRawIndex(dimIndex, dataIdx) instead.

method getCalculationInfo

getCalculationInfo: <CALC_INFO_KEY extends keyof DataCalculationInfo<HostModel>>(
    key: CALC_INFO_KEY
) => DataCalculationInfo<HostModel>[CALC_INFO_KEY];

method getDataExtent

getDataExtent: (dim: DimensionLoose) => [number, number];

method getDimension

getDimension: (dim: SeriesDimensionLoose) => DimensionName;

Get concrete dimension name by dimension name or dimension index. If input a dimension name, do not validate whether the dimension name exits.
Parameter dim
Must make sure the dimension is SeriesDimensionLoose. Because only those dimensions will have auto-generated dimension names if not have a user-specified name, and other dimensions will get a return of null/undefined.
Because of this reason, should better use getDimensionIndex instead, for examples:
const val = data.getStore().get(data.getDimensionIndex(dim), dataIdx);
Concrete dim name.

method getDimensionIndex

getDimensionIndex: (dim: DimensionLoose) => DimensionIndex;

Get dimension index in data store. Return -1 if not found. Can be used to index value from getRawValue.

method getDimensionInfo

getDimensionInfo: (dim: SeriesDimensionLoose) => SeriesDimensionDefine;

Get type and calculation info of particular dimension
Parameter dim
Dimension can be concrete names like x, y, z, lng, lat, angle, radius Or a ordinal number. For example getDimensionInfo(0) will return 'x' or 'lng' or 'radius'

method getDimensionsOnCoord

getDimensionsOnCoord: () => SeriesDimensionName[];

concrete dimension name list on coord.

method getId

getId: (idx: number) => string;

Never null/undefined. number will be converted to string. Because: In all cases having encountered at present, id is used in making diff comparison, which are usually based on hash map. We can keep the rule that the internal id are always string (treat 2 is the same as '2') to make the related logic simple.

method getIndices

getIndices: () => globalThis.ArrayLike<number>;

method getItemGraphicEl

getItemGraphicEl: (idx: number) => Element;

method getItemLayout

getItemLayout: (idx: number) => any;

Get layout of single data item

method getItemModel

getItemModel: <ItemOpts extends unknown = unknown>(
    idx: number
) => Model<ItemOpts>;

Get model of one data item.

method getItemVisual

getItemVisual: <K extends keyof Visual>(idx: number, key: K) => Visual[K];

Get visual property of single data item

method getLayout

getLayout: (key: string) => any;

Get layout property.

method getMedian

getMedian: (dim: DimensionLoose) => number;

method getName

getName: (idx: number) => string;

Never be null/undefined. number will be converted to string. Because: In most cases, name is used in display, where returning a string is more convenient. In other cases, name is used in query (see indexOfName), where we can keep the rule that name 2 equals to name '2'.

method getRawDataItem

getRawDataItem: (idx: number) => OptionDataItem;

method getRawIndex

getRawIndex: (idx: number) => number;

method getStore

getStore: () => DataStore;

method getSum

getSum: (dim: DimensionLoose) => number;

method getValues

getValues: {
    (idx: number): ParsedValue[];
    (dimensions: readonly string[], idx: number): ParsedValue[];
};

Get value for multi dimensions.
Parameter dimensions
If ignored, using all dimensions.

method getVisual

getVisual: <K extends keyof Visual>(key: K) => Visual[K];

Get visual property.

method hasItemVisual

hasItemVisual: () => boolean;

If exists visual property of single data item

method hasValue

hasValue: (idx: number) => boolean;

If value is NaN. Including '-' Only check the coord dimensions.

method indexOfName

indexOfName: (name: string) => number;

Retrieve the index with given name

method indexOfRawIndex

indexOfRawIndex: (rawIndex: number) => number;

method initData

initData: (
    data: Source | OptionSourceData | DataStore | DataProvider,
    nameList?: string[],
    dimValueGetter?: DimValueGetter
) => void;

Initialize from data
Parameter data
source or data or data store.
Parameter nameList
The name of a datum is used on data diff and default label/tooltip. A name can be specified in encode.itemName, or dataItem.name (only for series option data), or provided in nameList from outside.

method lttbDownSample

lttbDownSample: (
    valueDimension: DimensionLoose,
    rate: number
) => SeriesData<HostModel>;

Large data down sampling using largest-triangle-three-buckets
Parameter valueDimension
Parameter targetCount

method map

map: {
    <Ctx>(
        dims: DimensionLoose,
        cb: MapCb1<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): SeriesData<HostModel>;
    <Ctx>(
        dims: [DimensionLoose],
        cb: MapCb1<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): SeriesData<HostModel, DefaultDataVisual>;
    <Ctx>(
        dims: [DimensionLoose, DimensionLoose],
        cb: MapCb2<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): SeriesData<HostModel, DefaultDataVisual>;
};

Data mapping to a new List with given dimensions

method mapArray

mapArray: {
    <Ctx, Cb extends MapArrayCb0<Ctx>>(
        cb: Cb,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): ReturnType<Cb>[];
    <Ctx, Cb extends MapArrayCb1<Ctx>>(
        dims: DimensionLoose,
        cb: Cb,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): ReturnType<Cb>[];
    <Ctx, Cb extends MapArrayCb1<Ctx>>(
        dims: [DimensionLoose],
        cb: Cb,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): ReturnType<Cb>[];
    <Ctx, Cb extends MapArrayCb2<Ctx>>(
        dims: [DimensionLoose, DimensionLoose],
        cb: Cb,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): ReturnType<Cb>[];
    <Ctx, Cb extends MapArrayCb<Ctx>>(
        dims: ItrParamDims,
        cb: Cb,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): ReturnType<Cb>[];
};

Data mapping to a plain array

method mapDimension

mapDimension: {
    (coordDim: SeriesDimensionName): SeriesDimensionName;
    (coordDim: string, idx: number): string;
};

Parameter coordDim
Parameter idx
A coordDim may map to more than one data dim. If not specified, return the first dim not extra. concrete data dim. If not found, return null/undefined

method mapDimensionsAll

mapDimensionsAll: (coordDim: SeriesDimensionName) => SeriesDimensionName[];

method minmaxDownSample

minmaxDownSample: (
    valueDimension: DimensionLoose,
    rate: number
) => SeriesData<HostModel>;

Large data down sampling using min-max
Parameter valueDimension
Parameter rate

method modify

modify: {
    <Ctx>(
        dims: DimensionLoose,
        cb: MapCb1<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): void;
    <Ctx>(
        dims: [DimensionLoose],
        cb: MapCb1<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): void;
    <Ctx>(
        dims: [DimensionLoose, DimensionLoose],
        cb: MapCb2<Ctx>,
        ctx?: Ctx,
        ctxCompat?: Ctx
    ): void;
};

!!Danger: used on stack dimension only.

method rawIndexOf

rawIndexOf: (dim: SeriesDimensionName, value: OrdinalNumber) => number;

Only support the dimension which inverted index created. Do not support other cases until required.
Parameter dim
concrete dim
Parameter value
ordinal index rawIndex

method selectRange

selectRange: (range: Record<string, [number, number]>) => SeriesData;

Select data in range. (For optimization of filter) (Manually inline code, support 5 million data filtering in data zoom.)

method setApproximateExtent

setApproximateExtent: (
    extent: [number, number],
    dim: SeriesDimensionLoose
) => void;

NOTICE: _approximateExtent does not support filter. Callers must ensure the input extent to be handled by scale.sanitizeExtent.
Calculate extent on a filtered data might be time consuming. Approximate extent is only used for: calculate extent of filtered data outside.

method setCalculationInfo

setCalculationInfo: {
    (key: DataCalculationInfo<HostModel>): void;
    <CALC_INFO_KEY extends keyof DataCalculationInfo<HostModel>>(
        key: CALC_INFO_KEY,
        value: DataCalculationInfo<HostModel>[CALC_INFO_KEY]
    ): void;
};

Parameter key
or k-v object

method setItemGraphicEl

setItemGraphicEl: (idx: number, el: Element) => void;

Set graphic element relative to data. It can be set as null

method setItemLayout

setItemLayout: <M = false>(
    idx: number,
    layout: M extends true ? Dictionary<any> : any,
    merge?: M
) => void;

Set layout of single data item

method setItemVisual

setItemVisual: {
    <K extends keyof Visual>(idx: number, key: K, value: Visual[K]): void;
    (idx: number, kvObject: Partial<Visual>): void;
};

Set visual property of single data item
Parameter idx
Parameter key
Parameter value
Example 1
setItemVisual(0, 'color', color); setItemVisual(0, { 'color': color });

method setLayout

setLayout: { (key: string, val: any): void; (kvObj: Dictionary<any>): void };

Set layout property.

method setVisual

setVisual: {
    <K extends keyof Visual>(key: K, val: Visual[K]): void;
    (kvObj: Partial<Visual>): void;
};

Set visual property
Example 1
setVisual('color', color); setVisual({ 'color': color });

method wrapMethod

wrapMethod: (
    methodName: FunctionPropertyNames<SeriesData>,
    injectFunction: (...args: any) => any
) => void;

Wrap some method to add more feature

class Model

class Model<Opt = ModelOption> {}

constructor

constructor(option?: {}, parentModel?: Model<any>, ecModel?: GlobalModel);

property ecModel

ecModel: GlobalModel;

property option

option: {};

property parentModel

parentModel: Model<any>;

method clone

clone: () => Model<Opt>;

method get

get: {
    <R extends keyof Opt>(path: R, ignoreParent?: boolean): Opt[R];
    <R extends keyof Opt>(path: readonly [R], ignoreParent?: boolean): Opt[R];
    <R extends keyof Opt, S extends keyof Opt[R]>(
        path: readonly [R, S],
        ignoreParent?: boolean
    ): Opt[R][S];
    <R extends keyof Opt, S extends keyof Opt[R], T extends keyof Opt[R][S]>(
        path: readonly [R, S, T],
        ignoreParent?: boolean
    ): Opt[R][S][T];
};

method getModel

getModel: {
    <R extends keyof Opt>(path: R, parentModel?: Model): Model<Opt[R]>;
    <R extends keyof Opt>(path: readonly [R], parentModel?: Model<any>): Model<
        Opt[R]
    >;
    <R extends keyof Opt, S extends keyof Opt[R]>(
        path: readonly [R, S],
        parentModel?: Model<any>
    ): Model<Opt[R][S]>;
    <Ra extends keyof Opt, Rb extends keyof Opt, S extends keyof Opt[Rb]>(
        path: readonly [Ra] | readonly [Rb, S],
        parentModel?: Model<any>
    ): Model<Opt[Ra]> | Model<Opt[Rb][S]>;
    <R extends keyof Opt, S extends keyof Opt[R], T extends keyof Opt[R][S]>(
        path: readonly [R, S, T],
        parentModel?: Model<any>
    ): Model<Opt[R][S][T]>;
};

method getShallow

getShallow: <R extends keyof Opt>(key: R, ignoreParent?: boolean) => Opt[R];

method init

init: (
    option: Opt,
    parentModel?: Model,
    ecModel?: GlobalModel,
    ...rest: any
) => void;

method isAnimationEnabled

isAnimationEnabled: () => boolean;

method isEmpty

isEmpty: () => boolean;

If model has option

method mergeOption

mergeOption: (option: Opt, ecModel?: GlobalModel) => void;

Merge the input option to me.

method parsePath

parsePath: (path: string | readonly string[]) => readonly string[];

method resolveParentPath

resolveParentPath: (path: readonly string[]) => string[];

method restoreData

restoreData: () => void;

class SeriesModel

class SeriesModel<
    Opt extends SeriesOption = SeriesOption
> extends ComponentModel<Opt> {}

property [SERIES_UNIVERSAL_TRANSITION_PROP]

[SERIES_UNIVERSAL_TRANSITION_PROP]: boolean;

property coordinateSystem

coordinateSystem: CoordinateSystem;

property dataTask

dataTask: SeriesTask;

property defaultOption

defaultOption: SeriesOption<unknown, DefaultStatesMixin>;

property defaultSymbol

defaultSymbol: string;

property hasSymbolVisual

hasSymbolVisual: boolean;

property ignoreStyleOnData

ignoreStyleOnData: boolean;

property legendIcon

legendIcon: string;

property legendVisualProvider

legendVisualProvider: LegendVisualProvider;

property pipelineContext

pipelineContext: PipelineContext;

property preventUsingHoverLayer

readonly preventUsingHoverLayer: boolean;

property protoInitialize

static protoInitialize: void;

property seriesIndex

seriesIndex: number;

property type

type: string;

property visualDrawType

visualDrawType: 'fill' | 'stroke';

property visualStyleAccessPath

visualStyleAccessPath: string;

property visualStyleMapper

visualStyleMapper: (
    model: Model<any>,
    excludes?: readonly string[],
    includes?: readonly string[]
) => PathStyleProps;

method appendData

appendData: (params: { data: ArrayLike<any> }) => void;

Append data to list

method coordDimToDataDim

coordDimToDataDim: (coordDim: DimensionName) => DimensionName[];

Use data.mapDimensionsAll(coordDim) instead.
Deprecated

method fillDataTextStyle

fillDataTextStyle: (data: ArrayLike<any>) => void;

method formatTooltip

formatTooltip: (
    dataIndex: number,
    multipleSeries?: boolean,
    dataType?: SeriesDataType
) => ReturnType<DataFormatMixin['formatTooltip']>;

Default tooltip formatter
Parameter dataIndex
Parameter multipleSeries
Parameter dataType
Parameter renderMode
valid values: 'html'(by default) and 'richText'. 'html' is used for rendering tooltip in extra DOM form, and the result string is used as DOM HTML content. 'richText' is used for rendering tooltip in rich text form, for those where DOM operation is not supported. formatted tooltip with html and markers Notice: The override method can also return string

method getAllData

getAllData: () => { data: SeriesData; type?: SeriesDataType }[];

method getBaseAxis

getBaseAxis: () => Axis;

Get base axis if has coordinate system and has axis. By default use coordSys.getBaseAxis(); Can be overridden for some chart. {type} description

method getColorBy

getColorBy: () => ColorBy;

method getColorFromPalette

getColorFromPalette: (
    name: string,
    scope: any,
    requestColorNum?: number
) => ZRColor;

method getData

getData: (dataType?: SeriesDataType) => SeriesData<this>;

Consider some method like filter, map need make new data, We should make sure that seriesModel.getData() get correct data in the stream procedure. So we fetch data from upstream each time task.perform called.

method getEncode

getEncode: () => HashMap<OptionEncodeValue, string>;

method getInitialData

getInitialData: (option: Opt, ecModel: GlobalModel) => SeriesData;

Init a data structure from data related option in series Must be overridden.

method getProgressive

getProgressive: () => number | false;

Get progressive rendering count each step

method getProgressiveThreshold

getProgressiveThreshold: () => number;

Get progressive rendering count each step

method getRawData

getRawData: () => SeriesData;

Get data before processed

method getSelectedDataIndices

getSelectedDataIndices: () => number[];

method getSource

getSource: () => Source;

method getSourceManager

getSourceManager: () => SourceManager;

method indicesOfNearest

indicesOfNearest: (
    axisDim: DimensionName,
    dim: DimensionLoose,
    value: number,
    maxDistance?: number
) => number[];

Retrieve the index of nearest value in the view coordinate. Data position is compared with each axis's dataToCoord.
Parameter axisDim
axis dimension
Parameter dim
data dimension
Parameter value
Parameter maxDistance
The maximum distance in view coordinate space If and only if multiple indices has the same value, they are put to the result.

method init

init: (option: Opt, parentModel: Model, ecModel: GlobalModel) => void;

method isAnimationEnabled

isAnimationEnabled: () => boolean;

method isColorBySeries

isColorBySeries: () => boolean;

method isSelected

isSelected: (dataIndex: number, dataType?: SeriesDataType) => boolean;

method isUniversalTransitionEnabled

isUniversalTransitionEnabled: () => boolean;

method mergeDefaultAndTheme

mergeDefaultAndTheme: (option: Opt, ecModel: GlobalModel) => void;

Util for merge default and theme to option

method mergeOption

mergeOption: (newSeriesOption: Opt, ecModel: GlobalModel) => void;

method registerClass

static registerClass: (clz: Constructor) => Constructor;

method restoreData

restoreData: () => void;

method select

select: (innerDataIndices: number[], dataType?: SeriesDataType) => void;

method setData

setData: (data: SeriesData) => void;

method toggleSelect

toggleSelect: (innerDataIndices: number[], dataType?: SeriesDataType) => void;

method unselect

unselect: (innerDataIndices: number[], dataType?: SeriesDataType) => void;

Interfaces

interface AriaComponentOption

interface AriaOption extends AriaLabelOption {}

property decal

decal?: {
    show?: boolean;
    decals?: DecalObject | DecalObject[];
};

property enabled

enabled?: boolean;

property label

label?: AriaLabelOption;

property mainType

mainType?: 'aria';

interface AxisBreakChangedEvent

interface AxisBreakChangedEvent extends ECActionRefinedEvent {}

property breaks

breaks: AxisBreakChangedEventBreak[];

property fromAction

fromAction:
    | typeof AXIS_BREAK_EXPAND_ACTION_TYPE
    | typeof AXIS_BREAK_COLLAPSE_ACTION_TYPE
    | typeof AXIS_BREAK_TOGGLE_ACTION_TYPE;

property fromActionPayload

fromActionPayload:
    | ExpandAxisBreakPayload
    | CollapseAxisBreakPayload
    | ToggleAxisBreakPayload;

property type

type: typeof AXIS_BREAK_CHANGED_EVENT_TYPE;

interface AxisPointerComponentOption

interface AxisPointerOption
    extends ComponentOption,
        Omit<CommonAxisPointerOption, 'type'> {}

property link

link?: AxisPointerLink[];

property mainType

mainType?: 'axisPointer';

property type

type?: 'line' | 'shadow' | 'cross' | 'none';

interface BrushComponentOption

interface BrushOption extends ComponentOption, ModelFinderObject {}

property brushLink

brushLink?: number[] | 'all' | 'none';

property brushMode

brushMode?: BrushMode;

property brushStyle

brushStyle?: {
    borderWidth?: number;
    color?: ZRColor;
    borderColor?: ZRColor;
};

property brushType

brushType?: BrushTypeUncertain;

property defaultOutOfBrushColor

defaultOutOfBrushColor?: ColorString;

property inBrush

inBrush?: VisualOptionFixed;

property mainType

mainType?: 'brush';

property outOfBrush

outOfBrush?: VisualOptionFixed;

property removeOnClick

removeOnClick?: boolean;

property throttleDelay

throttleDelay?: number;

property throttleType

throttleType?: 'fixRate' | 'debounce';

property toolbox

toolbox?: BrushToolboxIconType[];

property transformable

transformable?: boolean;

interface CalendarComponentOption

interface CalendarOption extends ComponentOption, BoxLayoutOptionMixin {}

property cellSize

cellSize?: number | 'auto' | (number | 'auto')[];

property dayLabel

dayLabel?: Omit<LabelOption, 'position'> & {
    /**
     * First day of week.
     */
    firstDay?: number;
    /**
     * Margin between day label and axis line.
     * Can be percent string of cell size.
     */
    margin?: number | string;
    /**
     * Position of week, at the beginning or end of the range.
     */
    position?: 'start' | 'end';
    /**
     * Week text content
     *
     * defaults to auto-detected locale by the browser or the specified locale by `echarts.init` function.
     * It supports any registered locale name (case-sensitive) or customized array.
     * index 0 always means Sunday.
     */
    nameMap?: string | string[];
};

property itemStyle

itemStyle?: ItemStyleOption;

property mainType

mainType?: 'calendar';

property monthLabel

monthLabel?: Omit<LabelOption, 'position'> & {
    /**
     * Margin between month label and axis line.
     */
    margin?: number;
    /**
     * Position of month label, at the beginning or end of the range.
     */
    position?: 'start' | 'end';
    /**
     * Month text content
     *
     * defaults to auto-detected locale by the browser or the specified locale by `echarts.init` function.
     * It supports any registered locale name (case-sensitive) or customized array.
     * index 0 always means Jan.
     */
    nameMap?: string | string[];
    formatter?:
        | string
        | ((params: CalendarMonthLabelFormatterCallbackParams) => string);
};

property orient

orient?: LayoutOrient;

property range

range?: OptionDataValueDate | OptionDataValueDate[];

// one year range: 2017 // one month range: '2017-02' // a range range: ['2017-01-02', '2017-02-23'] // note: they will be identified as ['2017-01-01', '2017-02-01'] range: ['2017-01', '2017-02']

property splitLine

splitLine?: {
    show?: boolean;
    lineStyle?: LineStyleOption;
};

property yearLabel

yearLabel?: Omit<LabelOption, 'position'> & {
    /**
     * Margin between year label and axis line.
     */
    margin?: number;
    /**
     * Position of year label, at the beginning or end of the range.
     */
    position?: 'top' | 'bottom' | 'left' | 'right';
    formatter?:
        | string
        | ((params: CalendarYearLabelFormatterCallbackParams) => string);
};

interface ChartView

interface ChartView {}

method containPoint

containPoint: (point: number[], seriesModel: SeriesModel) => boolean;

The view contains the given point. Implement it if needed.

method filterForExposedEvent

filterForExposedEvent: (
    eventType: string,
    query: EventQueryItem,
    targetEl: Element,
    packedEvent: ECActionEvent | ECElementEvent
) => boolean;

Pass only when return true. Implement it if needed.

method incrementalPrepareRender

incrementalPrepareRender: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

Rendering preparation in progressive mode. Implement it if needed.

method incrementalRender

incrementalRender: (
    params: StageHandlerProgressParams,
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void;

Render in progressive mode. Implement it if needed.
Parameter params
See taskParams in stream/task.js

method updateTransform

updateTransform: (
    seriesModel: SeriesModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void | { update: true };

Update transform directly. Implement it if needed.

interface CollapseAxisBreakPayload

interface CollapseAxisBreakPayload extends BaseAxisBreakPayload {}

property type

type: typeof AXIS_BREAK_COLLAPSE_ACTION_TYPE;

interface ComponentView

interface ComponentView {}

property focusBlurEnabled

focusBlurEnabled?: boolean;

method filterForExposedEvent

filterForExposedEvent: (
    eventType: string,
    query: EventQueryItem,
    targetEl: Element,
    packedEvent: ECActionEvent | ECElementEvent
) => boolean;

Pass only when return true. Implement it if needed.

method findHighDownDispatchers

findHighDownDispatchers: (name: string) => Element[];

Find dispatchers for highlight/downplay by name. If this methods provided, hover link (within the same name) is enabled in component. That is, in component, a name can correspond to multiple dispatchers. Those dispatchers can have no common ancestor. The highlight/downplay state change will be applied on the dispatchers and their descendents.
Must return an array but not null/undefined.

method updateTransform

updateTransform: (
    model: ComponentModel,
    ecModel: GlobalModel,
    api: ExtensionAPI,
    payload: Payload
) => void | { update: true };

Implement it if needed.

interface ContinuousVisualMapComponentOption

interface ContinuousVisualMapOption extends VisualMapOption {}

property align

align?: 'auto' | 'left' | 'right' | 'top' | 'bottom';

property calculable

calculable?: boolean;

This prop effect default component type determine
See Also
- echarts/component/visualMap/typeDefaulter.

property emphasis

emphasis?: {
    handleStyle?: ItemStyleOption;
};

property handleIcon

handleIcon?: string;

property handleSize

handleSize?: string | number;

property handleStyle

handleStyle?: ItemStyleOption;

property hoverLink

hoverLink?: boolean;

Whether to enable hover highlight.

property hoverLinkDataSize

hoverLinkDataSize?: number;

The extent of hovered data.

property hoverLinkOnHandle

hoverLinkOnHandle?: boolean;

Whether trigger hoverLink when hover handle. If not specified, follow the value of realtime.

property indicatorIcon

indicatorIcon?: string;

property indicatorSize

indicatorSize?: string | number;

property indicatorStyle

indicatorStyle?: ItemStyleOption;

property range

range?: number[];

selected range. In default case range is [min, max] and can auto change along with user interaction or action "selectDataRange", until user specified a range.
See Also
- unboundedRange for the special case when range[0] or range[1] touch min or max.

property unboundedRange

unboundedRange?: boolean;

Whether to treat the range as unbounded when range touches min or max. - true: when range[0] <= min, the actual range becomes [-Infinity, range[1]]; when range[1] >= max, the actual range becomes [range[0], Infinity]. NOTE: - This provides a way to ensure all data can be considered in-range when min/max are not precisely known. - Default is true for backward compatibility. - Piecewise VisualMap does not need it, since it can define unbounded range in each piece, such as "< 12", ">= 300". - false: Disable the unbounded range behavior. Use case: min/max reflect the normal data range, and some outlier data should always be treated as out of range.

interface CustomSeriesRenderItemAPI

interface CustomSeriesRenderItemAPI
    extends CustomSeriesRenderItemCoordinateSystemAPI {}

method barLayout

barLayout: (
    opt: BarGridLayoutOptionForCustomSeries
) => BarGridLayoutResultItem[];

method currentSeriesIndices

currentSeriesIndices: () => number[];

method font

font: (
    opt: Pick<
        TextCommonOption,
        'fontStyle' | 'fontWeight' | 'fontSize' | 'fontFamily'
    >
) => string;

method getDevicePixelRatio

getDevicePixelRatio: () => number;

method getHeight

getHeight: () => number;

method getWidth

getWidth: () => number;

method getZr

getZr: () => ZRenderType;

method ordinalRawValue

ordinalRawValue: (
    dim: DimensionLoose,
    dataIndexInside?: number
) => ParsedValue | OrdinalRawValue;

method style

style: (userProps?: ZRStyleProps, dataIndexInside?: number) => ZRStyleProps;

Deprecated

method styleEmphasis

styleEmphasis: (
    userProps?: ZRStyleProps,
    dataIndexInside?: number
) => ZRStyleProps;

Deprecated

method value

value: (dim: DimensionLoose, dataIndexInside?: number) => ParsedValue;

method visual

visual: <
    VT extends
        | 'symbol'
        | 'color'
        | 'borderColor'
        | 'symbolSize'
        | 'symbolKeepAspect'
        | 'legendIcon'
        | 'visualMeta'
        | 'liftZ'
        | 'decal'
>(
    visualType: VT,
    dataIndexInside?: number
) => VT extends NonStyleVisualProps
    ? DefaultDataVisual[VT]
    : VT extends StyleVisualProps
    ? PathStyleProps[(typeof STYLE_VISUAL_TYPE)[VT]]
    : void;

interface CustomSeriesRenderItemParams

interface CustomSeriesRenderItemParams {}

property actionType

actionType?: string;

property context

context: Dictionary<unknown>;

property coordSys

coordSys: CustomSeriesRenderItemParamsCoordSys;

property dataIndex

dataIndex: number;

property dataIndexInside

dataIndexInside: number;

property dataInsideLength

dataInsideLength: number;

property encode

encode: WrapEncodeDefRet;

property itemPayload

itemPayload: Dictionary<unknown>;

property seriesId

seriesId: string;

property seriesIndex

seriesIndex: number;

property seriesName

seriesName: string;

interface DatasetComponentOption

interface DatasetOption
    extends Pick<ComponentOption, 'type' | 'id' | 'name'>,
        Pick<SeriesEncodeOptionMixin, 'dimensions'> {}

This module is imported by echarts directly.
Notice: Always keep this file exists for backward compatibility. Because before 4.1.0, dataset is an optional component, some users may import this module manually.

property fromDatasetId

fromDatasetId?: string;

property fromDatasetIndex

fromDatasetIndex?: number;

property fromTransformResult

fromTransformResult?: number;

property mainType

mainType?: 'dataset';

property seriesLayoutBy

seriesLayoutBy?: SeriesLayoutBy;

property source

source?: OptionSourceData;

property sourceHeader

sourceHeader?: OptionSourceHeader;

property transform

transform?: DataTransformOption | PipedDataTransformOption;

interface DefaultLabelFormatterCallbackParams

interface CallbackDataParams {}

property $vars

$vars: string[];

property borderColor

borderColor?: string;

property color

color?: ZRColor;

property componentIndex

componentIndex: number;

property componentSubType

componentSubType: string;

property componentType

componentType: string;

property data

data: OptionDataItem;

property dataIndex

dataIndex: number;

property dataType

dataType?: SeriesDataType;

property dimensionIndex

dimensionIndex?: number;

property dimensionNames

dimensionNames?: DimensionName[];

property encode

encode?: DimensionUserOuputEncode;

property marker

marker?: TooltipMarker;

property name

name: string;

property percent

percent?: number;

property seriesId

seriesId?: string;

property seriesIndex

seriesIndex?: number;

property seriesName

seriesName?: string;

property seriesType

seriesType?: string;

property status

status?: DisplayState;

property value

value: OptionDataItem | OptionDataValue;

interface DownplayPayload

interface DownplayPayload extends Payload {}

property notBlur

notBlur?: boolean;

property type

type: 'downplay';

interface ECElementEvent

interface ECElementEvent extends ECEventData, CallbackDataParams {}

property event

event?: ElementEvent;

property type

type: ZRElementEventName;

interface ECharts

interface EChartsType extends ECharts {}

interface EChartsCoreOption

interface ECBasicOption extends ECUnitOption {}

[ECOption]: An object input to echarts.setOption(option). May be an 'option: ECUnitOption', or may be an object contains multi-options. For example:

let option: ECOption = {
    baseOption: {
        title: {...},
        legend: {...},
        series: [
            {data: [...]},
            {data: [...]},
            ...
        ]
    },
    timeline: {...},
    options: [
        {title: {...}, series: {data: [...]}},
        {title: {...}, series: {data: [...]}},
        ...
    ],
    media: [
        {
            query: {maxWidth: 320},
            option: {series: {x: 20}, visualMap: {show: false}}
        },
        {
            query: {minWidth: 320, maxWidth: 720},
            option: {series: {x: 500}, visualMap: {show: true}}
        },
        {
            option: {series: {x: 1200}, visualMap: {show: true}}
        }
    ]
};

property baseOption

baseOption?: ECUnitOption;

property media

media?: MediaUnit[];

property options

options?: ECUnitOption[];

property timeline

timeline?: ComponentOption | ComponentOption[];

interface EChartsOption

interface EChartsOption extends ECBasicOption {}

property angleAxis

angleAxis?: AngleAxisOption | AngleAxisOption[];

property aria

aria?: AriaOption;

property axisPointer

axisPointer?: AxisPointerOption | AxisPointerOption[];

property baseOption

baseOption?: EChartsOption;

property brush

brush?: BrushOption | BrushOption[];

property calendar

calendar?: CalendarOption | CalendarOption[];

property dataset

dataset?: DatasetOption | DatasetOption[];

property dataZoom

dataZoom?: DataZoomComponentOption | DataZoomComponentOption[];

property geo

geo?: GeoOption | GeoOption[];

property graphic

graphic?: GraphicComponentLooseOption | GraphicComponentLooseOption[];

property grid

grid?: GridOption | GridOption[];

property legend

legend?: LegendComponentOption | LegendComponentOption[];

property matrix

matrix?: MatrixOption | MatrixOption[];

property options

options?: EChartsOption[];

property parallel

parallel?: ParallelCoordinateSystemOption | ParallelCoordinateSystemOption[];

property parallelAxis

parallelAxis?: ParallelAxisOption | ParallelAxisOption[];

property polar

polar?: PolarOption | PolarOption[];

property radar

radar?: RadarOption | RadarOption[];

property radiusAxis

radiusAxis?: RadiusAxisOption | RadiusAxisOption[];

property series

series?: SeriesOption$1 | SeriesOption$1[];

property singleAxis

singleAxis?: SingleAxisOption | SingleAxisOption[];

property thumbnail

thumbnail?: ThumbnailOption | ThumbnailOption[];

property timeline

timeline?: TimelineOption | SliderTimelineOption;

property title

title?: TitleOption | TitleOption[];

property toolbox

toolbox?: ToolboxComponentOption | ToolboxComponentOption[];

property tooltip

tooltip?: TooltipOption | TooltipOption[];

property visualMap

visualMap?: VisualMapComponentOption | VisualMapComponentOption[];

property xAxis

xAxis?: XAXisOption | XAXisOption[];

property yAxis

yAxis?: YAXisOption | YAXisOption[];

interface EChartsType

interface EChartsType extends ECharts {}

interface ElementEvent

interface ElementEvent {}

property cancelBubble

cancelBubble: boolean;

property event

event: ZRRawEvent;

property gestureEvent

gestureEvent: string;

property offsetX

offsetX: number;

property offsetY

offsetY: number;

property pinchScale

pinchScale: number;

property pinchX

pinchX: number;

property pinchY

pinchY: number;

property stop

stop: (this: ElementEvent) => void;

property target

target: Element;

property topTarget

topTarget: Element;

property type

type: ElementEventName;

property wheelDelta

wheelDelta: number;

property which

which: number;

property zrByTouch

zrByTouch: boolean;

interface ExpandAxisBreakPayload

interface ExpandAxisBreakPayload extends BaseAxisBreakPayload {}

property type

type: typeof AXIS_BREAK_EXPAND_ACTION_TYPE;

interface GeoComponentOption

interface GeoOption
    extends ComponentOption,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin,
        BoxLayoutOptionMixin,
        AnimationOptionMixin,
        GeoCommonOptionMixin,
        StatesOptionMixin<GeoStateOption, StatesMixinBase>,
        GeoStateOption {}

property defaultItemStyleColor

defaultItemStyleColor?: ZRColor;

property mainType

mainType?: 'geo';

property regions

regions?: RegionOption[];

property selectedMap

selectedMap?: Dictionary<boolean>;

property selectedMode

selectedMode?: 'single' | 'multiple' | boolean;

property show

show?: boolean;

property silent

silent?: boolean;

property stateAnimation

stateAnimation?: AnimationOptionMixin;

property tooltip

tooltip?: CommonTooltipOption<GeoTooltipFormatterParams>;

interface GridComponentOption

interface GridOption
    extends ComponentOption,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin,
        BoxLayoutOptionMixin,
        ShadowOptionMixin {}

property backgroundColor

backgroundColor?: ZRColor;

property borderColor

borderColor?: ZRColor;

property borderWidth

borderWidth?: number;

property containLabel

containLabel?: boolean;

Deprecated
Use grid.outerBounds instead. Whether grid size contains axis labels. This approach estimates the size by sample labels. It works for most case but it does not strictly contain all labels in some cases.

property mainType

mainType?: 'grid';

property outerBounds

outerBounds?: BoxLayoutOptionMixin;

{left, right, top, bottom, width, height}: Define a outerBounds rect, based on: - the canvas by default. - or the dataToLayout result if a boxCoordinateSystem is specified.

property outerBoundsClampHeight

outerBoundsClampHeight?: number | string;

property outerBoundsClampWidth

outerBoundsClampWidth?: number | string;

Available only when outerBoundsMode is not 'none'. Offer a constraint to not to shrink the grid rect causing smaller that width/height. A string means percent, like '30%', based on the original rect size determined by grid.top/right/bottom/left/width/height.

property outerBoundsContain

outerBoundsContain?: 'all' | 'axisLabel' | 'auto' | NullUndefined$1;

- 'all': Default. Contains the cartesian rect and axis labels and axis name. - 'axisLabel': Contains the cartesian rect and axis labels. This effect differs slightly from the previous option containLabel but more precise. - 'auto'/null/undefined: Default. be 'axisLabel' if containLabel:true, otherwise 'all'.

property outerBoundsMode

outerBoundsMode?: 'auto' | NullUndefined$1 | 'same' | 'none';

Define a constrains rect. Axis lines is firstly laid out based on the rect defined by grid.left/right/top/bottom/width/height. (for axis line alignment requirements between multiple grids) But if axisLabel and/or axisName overflow the outerBounds, shrink the layout to avoid that overflow.
Options: - 'none': outerBounds is infinity. - 'same': outerBounds is the same as the layout rect defined by grid.left/right/top/bottom/width/height. - 'auto'/null/undefined: Default. Use outerBounds, or 'same' if containLabel:true.
Note: grid.containLabel is equivalent to {outerBoundsMode: 'same', outerBoundsContain: 'axisLabel'}.

property show

show?: boolean;

property tooltip

tooltip?: any;

interface HighlightPayload

interface HighlightPayload extends Payload {}

property notBlur

notBlur?: boolean;

property type

type: 'highlight';

interface ImagePatternObject

interface ImagePatternObject extends PatternObjectBase {}

property image

image: ImageLike | string;

property imageHeight

imageHeight?: number;

property imageWidth

imageWidth?: number;

property repeat

repeat?: ImagePatternRepeat;

interface InsideDataZoomComponentOption

interface InsideDataZoomOption extends DataZoomOption {}

property cursorGrab

cursorGrab?: string;

Mouse cursor styles on states "can grab" and "grabbing".

property cursorGrabbing

cursorGrabbing?: string;

property disabled

disabled?: boolean;

Whether disable this inside zoom.

property moveOnMouseMove

moveOnMouseMove?: boolean | 'shift' | 'ctrl' | 'alt';

property moveOnMouseWheel

moveOnMouseWheel?: boolean | 'shift' | 'ctrl' | 'alt';

property preventDefaultMouseMove

preventDefaultMouseMove?: boolean;

property textStyle

textStyle?: never;

Inside dataZoom don't support textStyle

property zoomLock

zoomLock?: boolean;

Whether disable zoom but only pan.

property zoomOnMouseWheel

zoomOnMouseWheel?: boolean | 'shift' | 'ctrl' | 'alt';

interface LabelFormatterCallback

interface LabelFormatterCallback<T = CallbackDataParams> {}

call signature

(params: T): string;

interface LabelLayoutOptionCallbackParams

interface LabelLayoutOptionCallbackParams {}

property align

align: ZRTextAlign;

property dataIndex

dataIndex?: number;

Index of data which the label represents. It can be null if label doesn't represent any data.

property dataType

dataType?: SeriesDataType;

Type of data which the label represents. It can be null if label doesn't represent any data.

property labelLinePoints

labelLinePoints?: number[][];

property labelRect

labelRect: RectLike;

property rect

rect: RectLike;

property seriesIndex

seriesIndex: number;

property text

text: string;

property verticalAlign

verticalAlign: ZRTextVerticalAlign;

interface LinearGradientObject

interface LinearGradientObject extends GradientObject {}

property type

type: 'linear';

property x

x: number;

property x2

x2: number;

property y

y: number;

property y2

y2: number;

interface List

interface SeriesData {}

method getLinkedData

getLinkedData: (dataType?: SeriesDataType) => SeriesData;

method getLinkedDataAll

getLinkedDataAll: () => { data: SeriesData; type?: SeriesDataType }[];

interface MarkAreaComponentOption

interface MarkAreaOption
    extends MarkerOption,
        MarkAreaStateOption,
        StatesOptionMixin<MarkAreaStateOption, StatesMixinBase> {}

property data

data?: (MarkArea1DDataItemOption | MarkArea2DDataItemOption)[];

property mainType

mainType?: 'markArea';

property precision

precision?: number;

interface MarkLineComponentOption

interface MarkLineOption
    extends MarkerOption,
        MarkLineStateOption,
        StatesOptionMixin<MarkLineStateOption, StatesMixinBase> {}

property data

data?: (MarkLine1DDataItemOption | MarkLine2DDataItemOption)[];

property mainType

mainType?: 'markLine';

property precision

precision?: number;

Precision used on statistic method

property symbol

symbol?: string[] | string;

property symbolOffset

symbolOffset?: number | string | (number | string)[] | (number | string)[][];

property symbolRotate

symbolRotate?: number[] | number;

property symbolSize

symbolSize?: number[] | number;

interface MarkPointComponentOption

interface MarkPointOption
    extends MarkerOption,
        SymbolOptionMixin<CallbackDataParams>,
        StatesOptionMixin<MarkPointStateOption, StatesMixinBase>,
        MarkPointStateOption {}

property data

data?: MarkPointDataItemOption[];

property mainType

mainType?: 'markPoint';

property precision

precision?: number;

interface MatrixComponentOption

interface MatrixOption extends ComponentOption, BoxLayoutOptionMixin {}

property backgroundStyle

backgroundStyle?: ItemStyleOption;

property body

body?: MatrixBodyOption;

property borderZ2

borderZ2?: number;

property corner

corner?: MatrixCornerOption;

property mainType

mainType?: 'matrix';

property tooltip

tooltip?: CommonTooltipOption<MatrixTooltipFormatterParams>;

property triggerEvent

triggerEvent?: boolean;

property x

x?: MatrixDimensionOption;

property y

y?: MatrixDimensionOption;

interface Model

interface Model<Opt = ModelOption>
    extends LineStyleMixin,
        ItemStyleMixin,
        TextStyleMixin,
        AreaStyleMixin {}

interface ParallelComponentOption

interface ParallelCoordinateSystemOption
    extends ComponentOption,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin,
        BoxLayoutOptionMixin {}

property axisExpandable

axisExpandable?: boolean;

property axisExpandCenter

axisExpandCenter?: number;

property axisExpandCount

axisExpandCount?: number;

property axisExpandDebounce

axisExpandDebounce?: number;

property axisExpandRate

axisExpandRate?: number;

property axisExpandSlideTriggerArea

axisExpandSlideTriggerArea?: [number, number, number];

property axisExpandTriggerOn

axisExpandTriggerOn?: 'click' | 'mousemove';

property axisExpandWidth

axisExpandWidth?: number;

property axisExpandWindow

axisExpandWindow?: number[];

property layout

layout?: ParallelLayoutDirection;

property mainType

mainType?: 'parallel';

property parallelAxisDefault

parallelAxisDefault?: ParallelAxisOption;

interface Payload

interface Payload extends PayloadItem {}

property batch

batch?: PayloadItem[];

property escapeConnect

escapeConnect?: boolean;

property type

type: string;

interface PiecewiseVisualMapComponentOption

interface PiecewiseVisualMapOption extends VisualMapOption {}

Order Rule:
option.categories / option.pieces / option.text / option.selected: If !option.inverse, Order when vertical: ['top', ..., 'bottom']. Order when horizontal: ['left', ..., 'right']. If option.inverse, the meaning of the order should be reversed.
this._pieceList: The order is always [low, ..., high].
Mapping from location to low-high: If !option.inverse When vertical, top is high. When horizontal, right is high. If option.inverse, reverse.

property align

align?: 'auto' | 'left' | 'right';

property categories

categories?: string[];

category names, like: ['some1', 'some2', 'some3']. Attr min/max are ignored when categories set. See "Order Rule"

property hoverLink

hoverLink?: boolean;

property itemGap

itemGap?: number;

property itemHeight

itemHeight?: number;

property itemSymbol

itemSymbol?: string;

property itemWidth

itemWidth?: number;

When put the controller vertically, it is the length of horizontal side of each item. Otherwise, vertical side. When put the controller vertically, it is the length of vertical side of each item. Otherwise, horizontal side.

property maxOpen

maxOpen?: boolean;

property minOpen

minOpen?: boolean;

property pieces

pieces?: VisualPiece[];

property selected

selected?: Dictionary<boolean>;

Object. If not specified, means selected. When pieces and splitNumber: {'0': true, '5': true} When categories: {'cate1': false, 'cate3': true} When selected === false, means all unselected.

property selectedMode

selectedMode?: 'multiple' | 'single' | boolean;

property showLabel

showLabel?: boolean;

By default, when text is used, label will hide (the logic is remained for compatibility reason)

property splitNumber

splitNumber?: number;

If set to 5, auto split five pieces equally. If set to 0 and component type not set, component type will be determined as "continuous". (It is less reasonable but for ec2 compatibility, see echarts/component/visualMap/typeDefaulter)

interface PlainLegendComponentOption

interface LegendOption
    extends ComponentOption,
        LegendStyleOption,
        BoxLayoutOptionMixin,
        BorderOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

property align

align?: 'auto' | 'left' | 'right';

property backgroundColor

backgroundColor?: ColorString;

property borderRadius

borderRadius?: number | number[];

Border radius of background rect 0

property data

data?: (string | DataItem)[];

property emphasis

emphasis?: {
    selectorLabel?: LabelOption;
};

property itemGap

itemGap?: number;

Gap between each legend item. 10

property itemHeight

itemHeight?: number;

Height of legend symbol

property itemWidth

itemWidth?: number;

Width of legend symbol

property mainType

mainType?: 'legend';

property orient

orient?: LayoutOrient;

property padding

padding?: number | number[];

Padding between legend item and border. Support to be a single number or an array. 5

property selected

selected?: Dictionary<boolean>;

selected map of each item. Default to be selected if item is not in the map

property selectedMode

selectedMode?: boolean | 'single' | 'multiple';

property selector

selector?: (LegendSelectorButtonOption | SelectorType)[] | boolean;

Buttons for all select or inverse select.
Example 1
selector: [{type: 'all or inverse', title: xxx}] selector: true selector: ['all', 'inverse']

property selectorButtonGap

selectorButtonGap?: number;

Gap between selector buttons group and legend main items.

property selectorItemGap

selectorItemGap?: number;

Gap between each selector button

property selectorLabel

selectorLabel?: LabelOption;

property selectorPosition

selectorPosition?: 'auto' | 'start' | 'end';

Position of selector buttons.

property show

show?: boolean;

property tooltip

tooltip?: CommonTooltipOption<LegendTooltipFormatterParams>;

Tooltip option

property triggerEvent

triggerEvent?: boolean;

interface PolarComponentOption

interface PolarOption
    extends ComponentOption,
        CircleLayoutOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

property mainType

mainType?: 'polar';

interface RadarComponentOption

interface RadarOption
    extends ComponentOption,
        CircleLayoutOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

property axisLabel

axisLabel?: AxisBaseOption['axisLabel'];

property axisLine

axisLine?: AxisBaseOption['axisLine'];

property axisName

axisName?: {
    show?: boolean;
    formatter?:
        | string
        | ((name?: string, indicatorOpt?: InnerIndicatorAxisOption) => string);
} & LabelOption;

property axisNameGap

axisNameGap?: number;

property axisTick

axisTick?: AxisBaseOption['axisTick'];

property boundaryGap

boundaryGap?:
    | CategoryAxisBaseOption['boundaryGap']
    | ValueAxisBaseOption['boundaryGap'];

property clockwise

clockwise?: boolean;

property indicator

indicator?: RadarIndicatorOption[];

property mainType

mainType?: 'radar';

property scale

scale?: boolean;

property shape

shape?: 'polygon' | 'circle';

property splitArea

splitArea?: AxisBaseOption['splitArea'];

property splitLine

splitLine?: AxisBaseOption['splitLine'];

property splitNumber

splitNumber?: number;

property startAngle

startAngle?: number;

property triggerEvent

triggerEvent?: boolean;

interface RadialGradientObject

interface RadialGradientObject extends GradientObject {}

property r

r: number;

property type

type: 'radial';

property x

x: number;

property y

y: number;

interface RegisteredSeriesOption

interface RegisteredSeriesOption {}

A map from series 'type' to series option It's used for declaration merging in echarts extensions. For example:

import echarts from 'echarts';
declare module 'echarts/types/dist/echarts' {
  interface RegisteredSeriesOption {
    wordCloud: WordCloudSeriesOption
  }
}

property bar

bar: BarSeriesOption$1;

property boxplot

boxplot: BoxplotSeriesOption$1;

property candlestick

candlestick: CandlestickSeriesOption$1;

property chord

chord: ChordSeriesOption$1;

property custom

custom: CustomSeriesOption$1;

property effectScatter

effectScatter: EffectScatterSeriesOption$1;

property funnel

funnel: FunnelSeriesOption$1;

property gauge

gauge: GaugeSeriesOption$1;

property graph

graph: GraphSeriesOption$1;

property heatmap

heatmap: HeatmapSeriesOption$1;

property line

line: LineSeriesOption$1;

property lines

lines: LinesSeriesOption$1;

property map

map: MapSeriesOption$1;

property parallel

parallel: ParallelSeriesOption$1;

property pictorialBar

pictorialBar: PictorialBarSeriesOption$1;

property pie

pie: PieSeriesOption$1;

property radar

radar: RadarSeriesOption$1;

property sankey

sankey: SankeySeriesOption$1;

property scatter

scatter: ScatterSeriesOption$1;

property sunburst

sunburst: SunburstSeriesOption$1;

property themeRiver

themeRiver: ThemeRiverSeriesOption$1;

property tree

tree: TreeSeriesOption$1;

property treemap

treemap: TreemapSeriesOption$1;

interface ResizeOpts

interface ResizeOpts {}

property animation

animation?: AnimationOption$1;

property height

height?: number | 'auto';

property silent

silent?: boolean;

property width

width?: number | 'auto';

interface ScrollableLegendComponentOption

interface ScrollableLegendOption extends LegendOption {}

property animationDurationUpdate

animationDurationUpdate?: number;

property pageButtonGap

pageButtonGap?: number;

Gap between page buttons group and legend items.

property pageButtonItemGap

pageButtonItemGap?: number;

Gap between each page button

property pageButtonPosition

pageButtonPosition?: 'start' | 'end';

property pageFormatter

pageFormatter?: string | ((param: { current: number; total: number }) => string);

property pageIconColor

pageIconColor?: ZRColor;

property pageIconInactiveColor

pageIconInactiveColor?: ZRColor;

property pageIcons

pageIcons?: {
    horizontal?: string[];
    vertical?: string[];
};

property pageIconSize

pageIconSize?: number;

property pageTextStyle

pageTextStyle?: LabelOption;

property scrollDataIndex

scrollDataIndex?: number;

interface SelectChangedEvent

interface SelectChangedEvent extends ECActionRefinedEvent {}

property fromAction

fromAction: 'select' | 'unselect' | 'toggleSelected';

property fromActionPayload

fromActionPayload: Payload;

property isFromClick

isFromClick: boolean;

property selected

selected: {
    seriesIndex: number;
    dataType?: SeriesDataType;
    dataIndex: number[];
}[];

property type

type: 'selectchanged';

interface SelectChangedPayload

interface SelectChangedPayload extends Payload {}

Deprecated
Backward compat.

property fromAction

fromAction: 'select' | 'unselect' | 'toggleSelected';

property fromActionPayload

fromActionPayload: Payload;

property isFromClick

isFromClick: boolean;

property selected

selected: {
    seriesIndex: number;
    dataType?: SeriesDataType;
    dataIndex: number[];
}[];

property type

type: 'selectchanged';

interface SeriesModel

interface SeriesModel {}

NOTICE: - prefix __ can be used to avoid conflicts with possible outside subclasses. - All of these methods are optional - null-check is needed.

method brushSelector

brushSelector: (
    dataIndex: number,
    data: SeriesData,
    selectors: BrushCommonSelectorsForSeries,
    area: BrushSelectableArea
) => boolean;

See component/brush/selector.js Defined the brush selector for this series.

method enableAriaDecal

enableAriaDecal: () => void;

method getAxisTooltipData

getAxisTooltipData: (
    dim: DimensionName[],
    value: ScaleDataValue,
    baseAxis: Axis
) => { dataIndices: number[]; nestestValue: any };

Get data indices for show tooltip content. See tooltip. Implement it if needed.

method getLegendIcon

getLegendIcon: (opt: LegendIconParams) => ECSymbol | Group;

Get legend icon symbol according to each series type

method getMarkerPosition

getMarkerPosition: (
    value: ScaleDataValue[],
    dims?: (typeof dimPermutations)[number],
    startingAtTick?: boolean
) => number[];

Get position for marker

method getTooltipPosition

getTooltipPosition: (dataIndex: number) => number[];

See tooltip. Implement it if needed. Point of tooltip. null/undefined can be returned.

method preventIncremental

preventIncremental: () => boolean;

interface SeriesModel

interface SeriesModel<Opt extends SeriesOption = SeriesOption>
    extends DataFormatMixin,
        PaletteMixin<Opt>,
        DataHost {}

method getShadowDim

getShadowDim: () => string;

Get dimension to render shadow in dataZoom component

interface SetOptionOpts

interface SetOptionOpts {}

property lazyUpdate

lazyUpdate?: boolean;

property notMerge

notMerge?: boolean;

property replaceMerge

replaceMerge?: GlobalModelSetOptionOpts['replaceMerge'];

property silent

silent?: boolean;

property transition

transition?: SetOptionTransitionOpt;

interface SetThemeOpts

interface SetThemeOpts {}

property silent

silent?: boolean;

interface SliderDataZoomComponentOption

interface SliderDataZoomOption
    extends DataZoomOption,
        BoxLayoutOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

property backgroundColor

backgroundColor?: ZRColor;

Background of slider zoom component

property borderColor

borderColor?: ZRColor;

border color of the box. For compatibility, if dataBackgroundColor is set, borderColor is ignored.

property borderRadius

borderRadius?: number | number[];

Border radius of the box.

property brushSelect

brushSelect?: boolean;

If eable select by brushing

property brushStyle

brushStyle?: ItemStyleOption;

property dataBackground

dataBackground?: {
    lineStyle?: LineStyleOption;
    areaStyle?: AreaStyleOption;
};

property defaultLocationEdgeGap

defaultLocationEdgeGap?: number;

Distance between the slider and the edge of the chart.

property emphasis

emphasis?: {
    handleLabel?: SliderHandleLabelOption;
    handleStyle?: ItemStyleOption;
    moveHandleStyle?: ItemStyleOption;
};

property fillerColor

fillerColor?: ZRColor;

Color of selected area.

property handleIcon

handleIcon?: string;

Deprecated
Use handleStyle instead

property handleLabel

handleLabel?: SliderHandleLabelOption;

property handleSize

handleSize?: string | number;

number: height of icon. width will be calculated according to the aspect of icon. string: percent of the slider height. width will be calculated according to the aspect of icon.

property handleStyle

handleStyle?: ItemStyleOption;

property labelFormatter

labelFormatter?: string | ((value: number, valueStr: string) => string);

property labelPrecision

labelPrecision?: number | 'auto';

The precision only used on displayed labels. NOTICE: Specifying the "value precision" or "roaming step" is not allowed. getAcceptableTickPrecision is used for that. See AxisProxy for reasons.

property moveHandleIcon

moveHandleIcon?: string;

Icon to indicate it is a draggable panel.

property moveHandleSize

moveHandleSize?: number;

Height of handle rect. Can be a percent string relative to the slider height.

property moveHandleStyle

moveHandleStyle?: ItemStyleOption;

property selectedDataBackground

selectedDataBackground?: {
    lineStyle?: LineStyleOption;
    areaStyle?: AreaStyleOption;
};

property show

show?: boolean;

property showDataShadow

showDataShadow?: 'auto' | boolean;

property showDetail

showDetail?: boolean;

property textStyle

textStyle?: LabelOption;

property zoomLock

zoomLock?: boolean;

interface SVGPatternObject

interface SVGPatternObject extends PatternObjectBase {}

property svgElement

svgElement?: SVGVNode;

property svgHeight

svgHeight?: number;

property svgWidth

svgWidth?: number;

interface ThumbnailComponentOption

interface ThumbnailOption
    extends ComponentOption,
        BoxLayoutOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

[NOTE]: thumbnail is implemented as a component, rather than internal data strucutrue, due to the possibility of serveing geo and related series with a single thumbnail, and enable to apply some common layout feature, such as matrix coord sys.

property itemStyle

itemStyle?: ItemStyleOption;

property mainType

mainType?: 'thumbnail';

property seriesId

seriesId?: string | string[];

property seriesIndex

seriesIndex?: number | number[];

property show

show?: boolean;

property windowStyle

windowStyle?: ItemStyleOption;

interface TimelineComponentOption

interface TimelineOption
    extends ComponentOption,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin,
        BoxLayoutOptionMixin,
        SymbolOptionMixin {}

property autoPlay

autoPlay?: boolean;

property axisType

axisType?: 'category' | 'time' | 'value';

property backgroundColor

backgroundColor?: ZRColor;

property borderColor

borderColor?: ColorString;

property borderWidth

borderWidth?: number;

property checkpointStyle

checkpointStyle?: TimelineCheckpointStyle;

property controlPosition

controlPosition?: 'left' | 'right' | 'top' | 'bottom';

property controlStyle

controlStyle?: TimelineControlStyle;

property currentIndex

currentIndex?: number;

property data

data?: (OptionDataValue | TimelineDataItemOption)[];

property emphasis

emphasis?: {
    lineStyle?: TimelineLineStyleOption;
    itemStyle?: ItemStyleOption;
    checkpointStyle?: TimelineCheckpointStyle;
    controlStyle?: TimelineControlStyle;
    label?: TimelineLabelOption;
};

property inverse

inverse?: boolean;

property itemStyle

itemStyle?: ItemStyleOption;

property label

label?: TimelineLabelOption;

property lineStyle

lineStyle?: TimelineLineStyleOption;

property loop

loop?: boolean;

property mainType

mainType?: 'timeline';

property orient

orient?: LayoutOrient;

property padding

padding?: number | number[];

property playInterval

playInterval?: number;

property progress

progress?: {
    lineStyle?: TimelineLineStyleOption;
    itemStyle?: ItemStyleOption;
    label?: TimelineLabelOption;
};

property realtime

realtime?: boolean;

property replaceMerge

replaceMerge?: GlobalModelSetOptionOpts['replaceMerge'];

property rewind

rewind?: boolean;

property show

show?: boolean;

property tooltip

tooltip?: CommonTooltipOption<CallbackDataParams> & {
    trigger?: 'item';
};

interface TitleComponentOption

interface TitleOption
    extends ComponentOption,
        BoxLayoutOptionMixin,
        BorderOptionMixin,
        ComponentOnCalendarOptionMixin,
        ComponentOnMatrixOptionMixin {}

property backgroundColor

backgroundColor?: ZRColor;

property borderRadius

borderRadius?: number | number[];

Radius of background border.

property itemGap

itemGap?: number;

Gap between text and subtext

property link

link?: string;

Link to url

property mainType

mainType?: 'title';

property padding

padding?: number | number[];

Padding between text and border. Support to be a single number or an array.

property show

show?: boolean;

property sublink

sublink?: string;

property subtarget

subtarget?: 'self' | 'blank';

property subtext

subtext?: string;

property subtextStyle

subtextStyle?: TitleTextStyleOption;

property target

target?: 'self' | 'blank';

property text

text?: string;

property textAlign

textAlign?: ZRTextAlign;

property textBaseline

textBaseline?: ZRTextVerticalAlign;

Deprecated
Use textVerticalAlign instead

property textStyle

textStyle?: TitleTextStyleOption;

property textVerticalAlign

textVerticalAlign?: ZRTextVerticalAlign;

property triggerEvent

triggerEvent?: boolean;

If trigger mouse or touch event

interface ToggleAxisBreakPayload

interface ToggleAxisBreakPayload extends BaseAxisBreakPayload {}

property type

type: typeof AXIS_BREAK_TOGGLE_ACTION_TYPE;

interface ToolboxComponentOption

interface ToolboxComponentOption extends ToolboxOption {}

property feature

feature?: {
    brush?: ToolboxBrushFeatureOption;
    dataView?: ToolboxDataViewFeatureOption;
    dataZoom?: ToolboxDataZoomFeatureOption;
    magicType?: ToolboxMagicTypeFeatureOption;
    restore?: ToolboxRestoreFeatureOption;
    saveAsImage?: ToolboxSaveAsImageFeatureOption;
    [key: string]:
        | ToolboxFeatureOption
        | {
              [key: string]: any;
          }
        | undefined;
};

interface TooltipComponentFormatterCallback

interface TooltipFormatterCallback<T> {}

call signature

(params: T, asyncTicket: string): string | HTMLElement | HTMLElement[];

For sync callback params will be an array on axis trigger.

call signature

(
    params: T,
    asyncTicket: string,
    callback: (
        cbTicket: string,
        htmlOrDomNodes: string | HTMLElement | HTMLElement[]
    ) => void
): string | HTMLElement | HTMLElement[];

For async callback. Returned html string will be a placeholder when callback is not invoked.

interface TooltipComponentOption

interface TooltipOption
    extends CommonTooltipOption<TopLevelFormatterParams>,
        ComponentOption {}

property appendTo

appendTo?:
    | ((chartContainer: HTMLElement) => HTMLElement | undefined | null)
    | string
    | HTMLElement;

If append the tooltip element to another DOM element. Only available when renderMode is html

property appendToBody

appendToBody?: boolean;

Deprecated
use appendTo: 'body' instead

property axisPointer

axisPointer?: AxisPointerOption & {
    axis?: 'auto' | 'x' | 'y' | 'angle' | 'radius';
    crossStyle?: LineStyleOption & {
        textStyle?: LabelOption;
    };
};

property className

className?: string;

Specify the class name of tooltip element Only available when renderMode is html

property defaultBorderColor

defaultBorderColor?: string;

Default border color to use when there are multiple series

property mainType

mainType?: 'tooltip';

property order

order?: TooltipOrderMode;

property renderMode

renderMode?: 'auto' | TooltipRenderMode;

'auto': use html by default, and use non-html if document is not defined 'html': use html for tooltip 'richText': use canvas, svg, and etc. for tooltip

property showContent

showContent?: boolean;

If show popup content

property trigger

trigger?: 'item' | 'axis' | 'none';

Trigger only works on coordinate system.

interface TooltipComponentPositionCallback

interface TooltipPositionCallback {}

Position relative to the hoverred element. Only available when trigger is item.

call signature

(
    point: [number, number],
    /**
     * params will be an array on axis trigger.
     */
    params: TooltipPositionCallbackParams,
    /**
     * Will be HTMLDivElement when renderMode is html
     * Otherwise it's graphic.Text
     */
    el: HTMLDivElement | ZRText | null,
    /**
     * Rect of hover elements. Will be null if not hovered
     */
    rect: RectLike | null,
    size: {
        /**
         * Size of popup content
         */
        contentSize: [number, number];
        /**
         * Size of the chart view
         */
        viewSize: [number, number];
    }
): Array<number | string> | TooltipBuiltinPosition | TooltipBoxLayoutOption;

Type Aliases

type AngleAxisComponentOption

type AngleAxisOption = AxisBaseOption & {
    mainType?: 'angleAxis';
    /**
     * Index of host polar component
     */
    polarIndex?: number;
    /**
     * Id of host polar component
     */
    polarId?: string;
    startAngle?: number;
    endAngle?: number;
    clockwise?: boolean;
    axisLabel?: AxisBaseOption['axisLabel'];
};

type AnimationDelayCallback

type AnimationDelayCallback = (
    idx: number,
    params?: AnimationDelayCallbackParam
) => number;

type AnimationDelayCallbackParams

type AnimationDelayCallbackParam = {
    count: number;
    index: number;
};

type AnimationDurationCallback

type AnimationDurationCallback = (idx: number) => number;

type BarSeriesOption

type BarSeriesOption$1 = BarSeriesOption & SeriesInjectedOption;

type BoxplotSeriesOption

type BoxplotSeriesOption$1 = BoxplotSeriesOption & SeriesInjectedOption;

type CandlestickSeriesOption

type CandlestickSeriesOption$1 = CandlestickSeriesOption & SeriesInjectedOption;

type ChordSeriesOption

type ChordSeriesOption$1 = ChordSeriesOption & SeriesInjectedOption;

type Color

type ZRColor =
    | ColorString
    | LinearGradientObject
    | RadialGradientObject
    | PatternObject;

type ComposeOption

type ComposeOption<OptionUnion extends ComponentOption> =
    ComposeUnitOption<OptionUnion> & {
        baseOption?: ComposeUnitOption<OptionUnion>;
        options?: ComposeUnitOption<OptionUnion>[];
    };

type ContinousVisualMapComponentOption

type ContinousVisualMapComponentOption = ContinuousVisualMapOption;

Deprecated
Use ContinuousVisualMapComponentOption instead.

type CustomSeriesOption

type CustomSeriesOption$1 = CustomSeriesOption & SeriesInjectedOption;

type CustomSeriesRenderItem

type CustomSeriesRenderItem = (
    params: CustomSeriesRenderItemParams,
    api: CustomSeriesRenderItemAPI
) => CustomSeriesRenderItemReturn;

type CustomSeriesRenderItemReturn

type CustomSeriesRenderItemReturn = CustomRootElementOption | undefined | null;

type DataZoomComponentOption

type DataZoomComponentOption = SliderDataZoomOption | InsideDataZoomOption;

type EChartsInitOpts

type EChartsInitOpts = {
    locale?: string | LocaleOption;
    renderer?: RendererType;
    devicePixelRatio?: number;
    useDirtyRect?: boolean;
    useCoarsePointer?: boolean;
    pointerSize?: number;
    ssr?: boolean;
    width?: number | string;
    height?: number | string;
};

type ECUpdateMethodName

type ECUpdateMethodName = keyof typeof updateMethods | 'none';

type EffectScatterSeriesOption

type EffectScatterSeriesOption$1 = EffectScatterSeriesOption & SeriesInjectedOption;

type FunnelSeriesOption

type FunnelSeriesOption$1 = FunnelSeriesOption & SeriesInjectedOption;

type GaugeSeriesOption

type GaugeSeriesOption$1 = GaugeSeriesOption & SeriesInjectedOption;

type GraphicComponentOption

type GraphicComponentLooseOption = (
    | GraphicComponentOption
    | GraphicComponentElementOption
) & {
    mainType?: 'graphic';
};

type GraphSeriesOption

type GraphSeriesOption$1 = GraphSeriesOption & SeriesInjectedOption;

type HeatmapSeriesOption

type HeatmapSeriesOption$1 = HeatmapSeriesOption & SeriesInjectedOption;

type LabelLayoutOptionCallback

type LabelLayoutOptionCallback = (
    params: LabelLayoutOptionCallbackParams
) => LabelLayoutOption;

type LegendComponentOption

type LegendComponentOption = LegendOption | ScrollableLegendOption;

type LineSeriesOption

type LineSeriesOption$1 = LineSeriesOption & SeriesInjectedOption;

type LinesSeriesOption

type LinesSeriesOption$1 = LinesSeriesOption & SeriesInjectedOption;

type MapSeriesOption

type MapSeriesOption$1 = MapSeriesOption & SeriesInjectedOption;

type ParallelSeriesOption

type ParallelSeriesOption$1 = ParallelSeriesOption & SeriesInjectedOption;

type PatternObject

type PatternObject = ImagePatternObject | SVGPatternObject;

type PictorialBarSeriesOption

type PictorialBarSeriesOption$1 = PictorialBarSeriesOption & SeriesInjectedOption;

type PieSeriesOption

type PieSeriesOption$1 = PieSeriesOption & SeriesInjectedOption;

type RadarSeriesOption

type RadarSeriesOption$1 = RadarSeriesOption & SeriesInjectedOption;

type RadiusAxisComponentOption

type RadiusAxisOption = AxisBaseOption & {
    mainType?: 'radiusAxis';
    /**
     * Index of host polar component
     */
    polarIndex?: number;
    /**
     * Id of host polar component
     */
    polarId?: string;
};

type SankeySeriesOption

type SankeySeriesOption$1 = SankeySeriesOption & SeriesInjectedOption;

type ScatterSeriesOption

type ScatterSeriesOption$1 = ScatterSeriesOption & SeriesInjectedOption;

type SeriesOption

type SeriesOption$1 = Values<RegisteredSeriesOption>;

type SetOptionTransitionOpt

type SetOptionTransitionOpt = UpdateLifecycleTransitionOpt;

type SetOptionTransitionOptItem

type SetOptionTransitionOptItem = UpdateLifecycleTransitionItem;

type SingleAxisComponentOption

type SingleAxisOption = AxisBaseOption &
    BoxLayoutOptionMixin & {
        mainType?: 'singleAxis';
        position?: SingleAxisPosition;
        orient?: LayoutOrient;
    } & ComponentOnCalendarOptionMixin &
    ComponentOnMatrixOptionMixin;

type SunburstSeriesOption

type SunburstSeriesOption$1 = SunburstSeriesOption & SeriesInjectedOption;

type ThemeRiverSeriesOption

type ThemeRiverSeriesOption$1 = ThemeRiverSeriesOption & SeriesInjectedOption;

type TooltipComponentFormatterCallbackParams

type TopLevelFormatterParams = CallbackDataParams | CallbackDataParams[];

type TooltipComponentPositionCallbackParams

type TooltipPositionCallbackParams = CallbackDataParams | CallbackDataParams[];

type TreemapSeriesOption

type TreemapSeriesOption$1 = TreemapSeriesOption & SeriesInjectedOption;

type TreeSeriesOption

type TreeSeriesOption$1 = TreeSeriesOption & SeriesInjectedOption;

type VisualMapComponentOption

type VisualMapComponentOption = ContinuousVisualMapOption | PiecewiseVisualMapOption;

type XAxisComponentOption

type XAXisOption = CartesianAxisOption & {
    mainType?: 'xAxis';
};

type XAXisComponentOption

type XAXisOption = CartesianAxisOption & {
    mainType?: 'xAxis';
};

type YAxisComponentOption

type YAXisOption = CartesianAxisOption & {
    mainType?: 'yAxis';
};

type YAXisComponentOption

type YAXisOption = CartesianAxisOption & {
    mainType?: 'yAxis';
};

Namespaces

namespace color

namespace color {}

variable fastLerp

const fastLerp: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable fastMapToColor

const fastMapToColor: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable lift

const lift: (color: string, level: number) => string;

variable liftColor

const liftColor: {
    (color: GradientObject): GradientObject;
    (color: string): string;
};

variable lum

const lum: (color: string, backgroundLum: number) => number;

variable mapToColor

const mapToColor: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

variable modifyAlpha

const modifyAlpha: (color: string, alpha?: number) => string;

variable modifyHSL

const modifyHSL: (
    color: string,
    h?: number | ((h: number) => number),
    s?: string | number | ((s: number) => number),
    l?: string | number | ((l: number) => number)
) => string;

variable parse

const parse: (colorStr: string, rgbaArr?: number[]) => number[];

variable parseCssFloat

const parseCssFloat: (val: string | number) => number;

variable parseCssInt

const parseCssInt: (val: string | number) => number;

variable random

const random: () => string;

variable stringify

const stringify: (arrColor: number[], type: string) => string;

variable toHex

const toHex: (color: string) => string;

function lerp

lerp: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

namespace format

namespace format {}

variable addCommas

const addCommas: (x: string | number) => string;

variable capitalFirst

const capitalFirst: (str: string) => string;

variable encodeHTML

const encodeHTML: (source: string) => string;

variable formatTime

const formatTime: (tpl: string, value: unknown, isUTC?: boolean) => string;

variable formatTpl

const formatTpl: (
    tpl: string,
    paramsList: TplFormatterParam | TplFormatterParam[],
    encode?: boolean
) => string;

variable getTextRect

const getTextRect: (
    text: string,
    font?: string,
    align?: TextAlign,
    verticalAlign?: TextVerticalAlign,
    padding?: number | number[],
    rich?: Dictionary<TextStylePropsPart>,
    truncate?: boolean,
    lineHeight?: number
) => BoundingRect;

variable getTooltipMarker

const getTooltipMarker: {
    (color: string, extraCssText?: string): TooltipMarker;
    (opt: GetTooltipMarkerOpt): TooltipMarker;
};

variable normalizeCssArray

const normalizeCssArray: (val: number | number[]) => number[];

variable toCamelCase

const toCamelCase: (str: string, upperCaseFirst?: boolean) => string;

variable truncateText

const truncateText: (
    text: string,
    containerWidth: number,
    font: string,
    ellipsis?: string,
    options?: InnerTruncateOption
) => string;

namespace graphic

namespace graphic {}

variable Arc

const Arc: typeof Arc;

variable BezierCurve

const BezierCurve: typeof BezierCurve;

variable BoundingRect

const BoundingRect: typeof BoundingRect;

variable Circle

const Circle: typeof Circle;

variable clipPointsByRect

const clipPointsByRect: (points: VectorArray[], rect: RectLike) => number[][];

variable clipRectByRect

const clipRectByRect: (targetRect: RectLike, rect: RectLike) => RectLike;

variable CompoundPath

const CompoundPath: typeof CompoundPath;

variable createIcon

const createIcon: (
    iconStr: string,
    opt?: Omit<DisplayableProps, 'style'>,
    rect?: RectLike
) => SVGPath | ZRImage;

variable Ellipse

const Ellipse: typeof Ellipse;

variable extendPath

const extendPath: (pathData: string, opts: SVGPathOption) => typeof SVGPath;

variable extendShape

const extendShape: (opts: {
    type?: string;
    shape?: Dictionary<any>;
    style?: PathStyleProps;
    beforeBrush?: (param: BeforeBrushParam) => void;
    afterBrush?: () => void;
    getBoundingRect?: () => BoundingRect;
    calculateTextPosition?: ElementCalculateTextPosition;
    buildPath(
        this: Path<PathProps>,
        ctx: CanvasRenderingContext2D | PathProxy,
        shape: Dictionary<any>,
        inBatch?: boolean
    ): void;
    init?(this: Path<PathProps>, opts: PathProps): void;
}) => new (opts?: PathProps & { shape: Dictionary<any> }) => Path<PathProps>;

variable getShapeClass

const getShapeClass: (name: string) => new () => Path<PathProps>;

variable getTransform

const getTransform: (target: Transformable, ancestor?: Transformable) => MatrixArray;

variable Group

const Group: typeof Group;

variable IncrementalDisplayable

const IncrementalDisplayable: typeof IncrementalDisplayable;

variable initProps

const initProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?: number | AnimateOrSetPropsOption | (() => void),
    cb?: (() => void) | ((percent: number) => void),
    during?: (percent: number) => void
) => void;

variable Line

const Line: typeof Line;

variable LinearGradient

const LinearGradient: typeof LinearGradient;

variable makeImage

const makeImage: (
    imageUrl: string,
    rect: RectLike,
    layout?: 'center' | 'cover'
) => ZRImage;

variable makePath

const makePath: (
    pathData: string,
    opts: SVGPathOption,
    rect: RectLike,
    layout?: 'center' | 'cover'
) => SVGPath;

variable mergePath

const mergePath: (pathEls: Path<PathProps>[], opts: PathProps) => Path<PathProps>;

variable Polygon

const Polygon: typeof Polygon;

variable Polyline

const Polyline: typeof Polyline;

variable RadialGradient

const RadialGradient: typeof RadialGradient;

variable Rect

const Rect: typeof Rect;

variable registerShape

const registerShape: (name: string, ShapeClass: new () => Path<PathProps>) => void;

variable resizePath

const resizePath: (path: SVGPath, rect: RectLike) => void;

variable Ring

const Ring: typeof Ring;

variable Sector

const Sector: typeof Sector;

variable updateProps

const updateProps: <Props extends ElementProps>(
    el: Element<Props>,
    props: Props,
    animatableModel?: Model<AnimationOptionMixin>,
    dataIndex?: number | AnimateOrSetPropsOption | (() => void),
    cb?: (() => void) | ((percent: number) => void),
    during?: (percent: number) => void
) => void;

class Image

class ZRImage extends Displayable<ImageProps> {}

property onload

onload: (image: ImageLike) => void;

property style

style: ImageStyleProps;

method createStyle

createStyle: (obj?: ImageStyleProps) => ImageStyleProps;

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<ImageProps, boolean>;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getHeight

getHeight: () => number;

method getWidth

getWidth: () => number;

class Text

class ZRText extends Displayable<TextProps> implements GroupLike {}

constructor

constructor(opts?: TextProps);

property innerTransformable

innerTransformable: Transformable;

property isTruncated

isTruncated: boolean;

property overlap

overlap: 'show' | 'blur' | 'hidden';

property style

style: TextStyleProps;

property type

type: string;

method addSelfToZr

addSelfToZr: (zr: ZRenderType) => void;

method childrenRef

childrenRef: () => (ZRImage | Rect | TSpan)[];

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<TextProps, boolean>;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getComputedTransform

getComputedTransform: () => MatrixArray;

method getLocalTransform

getLocalTransform: (m?: MatrixArray) => MatrixArray;

method makeFont

static makeFont: (style: TextStylePropsPart) => string;

method removeSelfFromZr

removeSelfFromZr: (zr: ZRenderType) => void;

method setDefaultTextStyle

setDefaultTextStyle: (defaultTextStyle: DefaultTextStyle) => void;

method setTextContent

setTextContent: (textContent: never) => void;

method update

update: () => void;

method updateTransform

updateTransform: () => void;

interface Text

interface ZRText {}

property stateProxy

stateProxy: (stateName: string) => TextState;

property states

states: Dictionary<TextState>;

method animate

animate: {
    (key?: '', loop?: boolean): Animator<this>;
    (key: 'style', loop?: boolean): Animator<this['style']>;
};

method ensureState

ensureState: (stateName: string) => TextState;

method getState

getState: (stateName: string) => TextState;

type Arc

type graphic_d_Arc = Arc;

type BezierCurve

type graphic_d_BezierCurve = BezierCurve;

type BoundingRect

type graphic_d_BoundingRect = BoundingRect;

type Circle

type graphic_d_Circle = Circle;

type CompoundPath

type graphic_d_CompoundPath = CompoundPath;

type Ellipse

type graphic_d_Ellipse = Ellipse;

type Group

type graphic_d_Group = Group;

type IncrementalDisplayable

type graphic_d_IncrementalDisplayable = IncrementalDisplayable;

type Line

type graphic_d_Line = Line;

type LinearGradient

type graphic_d_LinearGradient = LinearGradient;

type Polygon

type graphic_d_Polygon = Polygon;

type Polyline

type graphic_d_Polyline = Polyline;

type RadialGradient

type graphic_d_RadialGradient = RadialGradient;

type Rect

type graphic_d_Rect = Rect;

type Ring

type graphic_d_Ring = Ring;

type Sector

type graphic_d_Sector = Sector;

namespace helper

namespace helper {}

variable createDimensions

const createDimensions: (
    source:
        | OptionSourceData<OptionDataValue, OptionDataItemOriginal<OptionDataValue>>
        | Source,
    opt?: PrepareSeriesDataSchemaParams
) => SeriesDimensionDefine[];

variable createList

const createList: (
    seriesModel: SeriesModel<SeriesOption<unknown, DefaultStatesMixin>>
) => SeriesData<Model<any>, DefaultDataVisual>;

variable createScale

const createScale: (
    dataExtent: number[],
    option: object | AxisBaseModel<AxisBaseOptionCommon>
) => Scale<unknown>;

variable createSymbol

const createSymbol: (
    symbolType: string,
    x: number,
    y: number,
    w: number,
    h: number,
    color?: ZRColor,
    keepAspect?: boolean
) => ECSymbol;

variable createTextStyle

const createTextStyle: (
    textStyleModel: Model<TextCommonOption<TextCommonOptionNuanceDefault>>,
    opts?: { state?: DisplayState }
) => TextStyleProps;

variable dataStack

const dataStack: {
    isDimensionStacked: (
        data: SeriesData<Model<any>, DefaultDataVisual>,
        stackedDim: string
    ) => boolean;
    enableDataStack: (
        seriesModel: SeriesModel<
            SeriesOption<unknown, DefaultStatesMixin> & SeriesStackOptionMixin
        >,
        dimensionsInput:
            | EnableDataStackDimensionsInput
            | EnableDataStackDimensionsInputLegacy,
        opt?: { stackedCoordDimension?: string; byIndex?: boolean }
    ) => Pick<
        DataCalculationInfo<unknown>,
        | 'stackedDimension'
        | 'stackedByDimension'
        | 'isStackedByIndex'
        | 'stackedOverDimension'
        | 'stackResultDimension'
    >;
    getStackedDimension: (
        data: SeriesData<Model<any>, DefaultDataVisual>,
        targetDim: string
    ) => string;
};

variable enableHoverEmphasis

const enableHoverEmphasis: (
    el: Element<ElementProps>,
    focus?: InnerFocus,
    blurScope?: BlurScope
) => void;

variable getECData

const getECData: (hostObj: Element<ElementProps>) => ECData;

variable getLayoutRect

const getLayoutRect: (
    positionInfo: BoxLayoutOptionMixin & { aspect?: number },
    containerRect: GetLayoutRectInputContainerRect,
    margin?: number | number[]
) => LayoutRect;

variable mixinAxisModelCommonMethods

const mixinAxisModelCommonMethods: (Model: Model<any>) => void;

namespace matrix

namespace matrix {}

variable identity

const identity: (out: MatrixArray) => MatrixArray;

variable invert

const invert: (out: MatrixArray, a: MatrixArray) => MatrixArray;

variable rotate

const rotate: (
    out: MatrixArray,
    a: MatrixArray,
    rad: number,
    pivot?: VectorArray
) => MatrixArray;

variable translate

const translate: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

function clone

clone: (a: MatrixArray) => MatrixArray;

function copy

copy: (out: MatrixArray, m: MatrixArray) => MatrixArray;

function create

create: () => MatrixArray;

function mul

mul: (out: MatrixArray, m1: MatrixArray, m2: MatrixArray) => MatrixArray;

function scale

scale: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

type MatrixArray

type matrix_d_MatrixArray = MatrixArray;

namespace number

namespace number {}

variable asc

const asc: <T extends number[]>(arr: T) => T;

variable getPercentWithPrecision

const getPercentWithPrecision: (
    valueList: number[],
    idx: number,
    precision: number
) => number;

variable getPixelPrecision

const getPixelPrecision: (
    dataExtent: [number, number],
    pixelExtent: [number, number]
) => number;

variable getPrecision

const getPrecision: (val: string | number) => number;

variable getPrecisionSafe

const getPrecisionSafe: (val: string | number) => number;

variable isNumeric

const isNumeric: (val: unknown) => val is number;

variable isRadianAroundZero

const isRadianAroundZero: (val: number) => boolean;

variable linearMap

const linearMap: (
    val: number,
    domain: number[],
    range: number[],
    clamp?: boolean
) => number;

variable MAX_SAFE_INTEGER

const MAX_SAFE_INTEGER: number;

variable nice

const nice: (val: number, mode?: boolean | 2 | 1) => number;

variable numericToNumber

const numericToNumber: (val: unknown) => number;

variable parseDate

const parseDate: (value: unknown) => Date;

variable parsePercent

const parsePercent: (
    option: unknown,
    percentBase: number,
    percentOffset?: number
) => number;

variable quantile

const quantile: (ascArr: number[], p: number) => number;

variable quantity

const quantity: (val: number) => number;

variable quantityExponent

const quantityExponent: (val: number) => number;

variable reformIntervals

const reformIntervals: (list: IntervalItem[]) => IntervalItem[];

variable remRadian

const remRadian: (radian: number) => number;

function round

round: {
    (x: number | string, precision?: number): number;
    (x: string | number, precision: number, returnStr: false): number;
    (x: string | number, precision: number, returnStr: true): string;
};

namespace time

namespace time {}

variable format

const format: (
    time: unknown,
    template: string,
    isUTC: boolean,
    lang?:
        | string
        | Model<{
              time: {
                  month: string[];
                  monthAbbr: string[];
                  dayOfWeek: string[];
                  dayOfWeekAbbr: string[];
              };
              legend: { selector: { all: string; inverse: string } };
              toolbox: {
                  brush: {
                      title: {
                          rect: string;
                          polygon: string;
                          lineX: string;
                          lineY: string;
                          keep: string;
                          clear: string;
                      };
                  };
                  dataView: { title: string; lang: string[] };
                  dataZoom: { title: { zoom: string; back: string } };
                  magicType: {
                      title: {
                          line: string;
                          bar: string;
                          stack: string;
                          tiled: string;
                      };
                  };
                  restore: { title: string };
                  saveAsImage: { title: string; lang: string[] };
              };
              series: {
                  typeNames: {
                      pie: string;
                      bar: string;
                      line: string;
                      scatter: string;
                      effectScatter: string;
                      radar: string;
                      tree: string;
                      treemap: string;
                      boxplot: string;
                      candlestick: string;
                      k: string;
                      heatmap: string;
                      map: string;
                      parallel: string;
                      lines: string;
                      graph: string;
                      sankey: string;
                      funnel: string;
                      gauge: string;
                      pictorialBar: string;
                      themeRiver: string;
                      sunburst: string;
                      custom: string;
                      chart: string;
                  };
              };
              aria: {
                  general: { withTitle: string; withoutTitle: string };
                  series: {
                      single: {
                          prefix: string;
                          withName: string;
                          withoutName: string;
                      };
                      multiple: {
                          prefix: string;
                          withName: string;
                          withoutName: string;
                          separator: { middle: string; end: string };
                      };
                  };
                  data: {
                      allData: string;
                      partialData: string;
                      withName: string;
                      withoutName: string;
                      separator: { middle: string; end: string };
                  };
              };
          }>
) => string;

variable roundTime

const roundTime: (
    date: Date,
    timeUnit:
        | 'year'
        | 'month'
        | 'day'
        | 'hour'
        | 'minute'
        | 'second'
        | 'millisecond',
    isUTC: boolean
) => Date;

function parse

parse: (value: unknown) => Date;

Parameter value
valid type: number | string | Date, otherwise return new Date(NaN) These values can be accepted: + An instance of Date, represent a time in its own time zone. + Or string in a subset of ISO 8601, only including: + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06', + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123', + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00', all of which will be treated as local time if time zone is not specified (see <https://momentjs.com/>). + Or other string format, including (all of which will be treated as local time): '2012', '2012-3-1', '2012/3/1', '2012/03/01', '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123' + a timestamp, which represent a time in UTC. date Never be null/undefined. If invalid, return new Date(NaN).

namespace util

namespace util {}

variable bind

const bind: FunctionBind;

variable clone

const clone: <T extends unknown>(source: T) => T;

variable curry

const curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

variable defaults

const defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

variable each

const each: <
    I extends any[] | readonly any[] | ArrayLike$1<any> | Dictionary<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike$1<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike$1<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

variable extend

const extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

variable filter

const filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

variable indexOf

const indexOf: <T>(array: T[] | readonly T[] | ArrayLike$1<T>, value: T) => number;

variable inherits

const inherits: (clazz: Function, baseClazz: Function) => void;

variable isArray

const isArray: (value: any) => value is any[];

variable isFunction

const isFunction: (value: any) => value is Function;

variable isObject

const isObject: <T = unknown>(value: T) => value is object & T;

variable isString

const isString: (value: any) => value is string;

variable map

const map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

variable merge

const merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

variable reduce

const reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

namespace vector

namespace vector {}

variable add

const add: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

variable applyTransform

const applyTransform: <T extends VectorArray>(
    out: T,
    v: VectorArray,
    m: MatrixArray
) => T;

variable copy

const copy: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable create

const create: (x?: number, y?: number) => VectorArray;

variable dist

const dist: (v1: VectorArray, v2: VectorArray) => number;

variable distance

const distance: (v1: VectorArray, v2: VectorArray) => number;

variable distanceSquare

const distanceSquare: (v1: VectorArray, v2: VectorArray) => number;

variable distSquare

const distSquare: (v1: VectorArray, v2: VectorArray) => number;

variable div

const div: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

variable dot

const dot: (v1: VectorArray, v2: VectorArray) => number;

variable len

const len: (v: VectorArray) => number;

variable length

const length: (v: VectorArray) => number;

variable lengthSquare

const lengthSquare: (v: VectorArray) => number;

variable lenSquare

const lenSquare: (v: VectorArray) => number;

variable lerp

const lerp: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    t: number
) => T;

variable max

const max: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

variable min

const min: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

variable mul

const mul: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

variable negate

const negate: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable normalize

const normalize: <T extends VectorArray>(out: T, v: VectorArray) => T;

variable scale

const scale: <T extends VectorArray>(out: T, v: VectorArray, s: number) => T;

variable scaleAndAdd

const scaleAndAdd: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    a: number
) => T;

variable set

const set: <T extends VectorArray>(out: T, a: number, b: number) => T;

variable sub

const sub: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function clone

clone: (v: VectorArray) => VectorArray;

type VectorArray

type vector_d_VectorArray = VectorArray;

namespace zrender

namespace zrender {}

variable dispose

const dispose: (zr: ZRender) => void;

variable disposeAll

const disposeAll: () => void;

variable getElementSSRData

const getElementSSRData: (el: Element<ElementProps>) => ElementSSRData;

variable getInstance

const getInstance: (id: number) => ZRender;

variable init

const init: (dom?: HTMLElement, opts?: ZRenderInitOpt) => ZRender;

variable registerPainter

const registerPainter: (name: string, Ctor: PainterBaseCtor) => void;

variable registerSSRDataGetter

const registerSSRDataGetter: <T>(getter: ElementSSRDataGetter<T>) => void;

variable version

const version: string;

type ElementSSRData

type zrender_d_ElementSSRData = ElementSSRData;

type ElementSSRDataGetter

type zrender_d_ElementSSRDataGetter<T> = ElementSSRDataGetter<T>;

type ZRenderInitOpt

type zrender_d_ZRenderInitOpt = ZRenderInitOpt;

type ZRenderType

type zrender_d_ZRenderType = ZRenderType;

namespace zrUtil

namespace zrUtil {}

variable assert

const assert: (condition: any, message?: string) => void;

variable assignProps

const assignProps: {
    <TSrc extends Dictionary<any>, TCommonKey extends keyof TSrc>(
        tar: null,
        src: TSrc,
        props: readonly TCommonKey[]
    ): Pick<TSrc, TCommonKey>;
    <
        TTar extends Dictionary<any>,
        TSrc extends Dictionary<any>,
        TCommonKey extends keyof TSrc & keyof TTar
    >(
        tar: TTar,
        src: TSrc & { [P in TCommonKey]: TTar[P] },
        props: readonly TCommonKey[]
    ): TTar;
};

variable bind

const bind: FunctionBind;

variable clone

const clone: <T extends unknown>(source: T) => T;

variable concatArray

const concatArray: <T, R>(
    a: ArrayLike$1<T>,
    b: ArrayLike$1<R>
) => ArrayLike$1<T | R>;

variable createCanvas

const createCanvas: () => HTMLCanvasElement;

variable createHashMap

const createHashMap: <T, KEY extends string | number = string | number>(
    obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]
) => HashMap<T, KEY>;

variable createObject

const createObject: <T>(proto?: object, properties?: T) => T;

variable curry

const curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

variable defaults

const defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

variable disableUserSelect

const disableUserSelect: (dom: HTMLElement) => void;

variable each

const each: <
    I extends any[] | readonly any[] | ArrayLike$1<any> | Dictionary<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike$1<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike$1<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

variable EPSILON

const EPSILON: number;

variable eqNaN

const eqNaN: (value: any) => boolean;

variable extend

const extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

variable filter

const filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

variable find

const find: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index?: number, arr?: readonly T[]) => boolean,
    context?: Context
) => T;

variable guid

const guid: () => number;

variable HashMap

const HashMap: typeof HashMap;

variable hasOwn

const hasOwn: (own: object, prop: string) => boolean;

variable indexOf

const indexOf: <T>(array: T[] | readonly T[] | ArrayLike$1<T>, value: T) => number;

variable inherits

const inherits: (clazz: Function, baseClazz: Function) => void;

variable isArray

const isArray: (value: any) => value is any[];

variable isArrayLike

const isArrayLike: (data: any) => data is ArrayLike$1<any>;

variable isBuiltInObject

const isBuiltInObject: (value: any) => boolean;

variable isDom

const isDom: (value: any) => value is HTMLElement;

variable isFunction

const isFunction: (value: any) => value is Function;

variable isGradientObject

const isGradientObject: (value: any) => value is GradientObject;

variable isImagePatternObject

const isImagePatternObject: (value: any) => value is ImagePatternObject;

variable isNumber

const isNumber: (value: any) => value is number;

variable isObject

const isObject: <T = unknown>(value: T) => value is object & T;

variable isPrimitive

const isPrimitive: (obj: any) => boolean;

variable isRegExp

const isRegExp: (value: unknown) => value is RegExp;

variable isString

const isString: (value: any) => value is string;

variable isStringSafe

const isStringSafe: (value: any) => value is string;

variable isTypedArray

const isTypedArray: (value: any) => boolean;

variable keys

const keys: <T extends object>(obj: T) => (KeyOfDistributive<T> & string)[];

variable logError

const logError: (...args: any[]) => void;

variable map

const map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

variable merge

const merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

variable mergeAll

const mergeAll: (targetAndSources: any[], overwrite?: boolean) => any;

variable mixin

const mixin: <T, S>(
    target: Function | T,
    source: Function | S,
    override?: boolean
) => void;

variable noop

const noop: () => void;

variable normalizeCssArray

const normalizeCssArray: (val: number | number[]) => number[];

variable RADIAN_TO_DEGREE

const RADIAN_TO_DEGREE: number;

variable reduce

const reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

variable retrieve

const retrieve: <T>(...args: T[]) => T;

variable retrieve2

const retrieve2: <T, R>(value0: T, value1: R) => T | R;

variable retrieve3

const retrieve3: <T, R, W>(value0: T, value1: R, value2: W) => T | R | W;

variable setAsPrimitive

const setAsPrimitive: (obj: any) => void;

variable slice

const slice: <T>(arr: ArrayLike$1<T>, start?: number, end?: number) => T[];

variable trim

const trim: (str: string) => string;

type Bind1

type util_d_Bind1<F, Ctx> = Bind1<F, Ctx>;

type Bind2

type util_d_Bind2<F, Ctx, T1> = Bind2<F, Ctx, T1>;

type Bind3

type util_d_Bind3<F, Ctx, T1, T2> = Bind3<F, Ctx, T1, T2>;

type Bind4

type util_d_Bind4<F, Ctx, T1, T2, T3> = Bind4<F, Ctx, T1, T2, T3>;

type Bind5

type util_d_Bind5<F, Ctx, T1, T2, T3, T4> = Bind5<F, Ctx, T1, T2, T3, T4>;

type Curry1

type util_d_Curry1<F, T1> = Curry1<F, T1>;

type Curry2

type util_d_Curry2<F, T1, T2> = Curry2<F, T1, T2>;

type Curry3

type util_d_Curry3<F, T1, T2, T3> = Curry3<F, T1, T2, T3>;

type Curry4

type util_d_Curry4<F, T1, T2, T3, T4> = Curry4<F, T1, T2, T3, T4>;

type HashMap

type util_d_HashMap<T, KEY extends string | number = string | number> = HashMap<
    T,
    KEY
>;

Package Files (1)

types/dist/echarts.d.ts

Dependencies (2)

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/echarts.

Markdown

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

HTML

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

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

echarts

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable availableMethods

variable AXIS_BREAK_CHANGED_EVENT_TYPE

variable AXIS_BREAK_COLLAPSE_ACTION_TYPE

variable AXIS_BREAK_EXPAND_ACTION_TYPE

variable AXIS_BREAK_TOGGLE_ACTION_TYPE

variable AXIS_EXTENT_INFO_BUILD_FROM_COORD_SYS_UPDATE

variable AXIS_EXTENT_INFO_BUILD_FROM_DATA_ZOOM

variable AXIS_EXTENT_INFO_BUILD_FROM_EMPTY

variable AXIS_TYPES

variable AxisTickLabelComputingKind

variable bind

variable color_d_fastLerp

variable color_d_fastMapToColor

variable color_d_lift

variable color_d_liftColor

variable color_d_lum

variable color_d_mapToColor

variable color_d_modifyAlpha

variable color_d_modifyHSL

variable color_d_parse

variable color_d_parseCssFloat

variable color_d_parseCssInt

variable color_d_random

variable color_d_stringify

variable color_d_toHex

variable CONNECT_STATUS_KEY

variable dataCtors

variable dataStack

variable dataTool

variable dependencies

variable dimPermutations

variable disConnect

Deprecated

variable dist

variable distSquare

variable easingFuncs

variable EC_UPDATE_CYCLE_VERSION_KEY

variable env

variable EPSILON

variable extendPathFromString

variable extensionRegisters

variable fastMapToColor

variable format_d_addCommas

variable format_d_capitalFirst

variable format_d_encodeHTML

variable format_d_formatTime

variable format_d_formatTpl

variable format_d_getTextRect

variable format_d_getTooltipMarker

variable format_d_toCamelCase

variable format_d_truncateText

variable graphic_d_Arc

variable graphic_d_BezierCurve

variable graphic_d_BoundingRect

variable graphic_d_Circle

variable graphic_d_clipPointsByRect

variable graphic_d_clipRectByRect

variable graphic_d_CompoundPath

variable graphic_d_createIcon

variable graphic_d_Ellipse

variable graphic_d_extendPath

variable graphic_d_extendShape

variable graphic_d_getShapeClass

variable graphic_d_getTransform

variable graphic_d_Group

variable graphic_d_IncrementalDisplayable

variable graphic_d_initProps

variable graphic_d_Line

variable graphic_d_LinearGradient