echarts

  • Version 5.5.0
  • Published
  • 52.8 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

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable dataTool

const dataTool: {};

    variable dependencies

    const dependencies: { zrender: string };

      variable disConnect

      const disConnect: (groupId: string) => void;
      • Alias and backward compatibility

        Deprecated

      variable env

      const env: Env;

        variable PRIORITY

        const PRIORITY: {
        PROCESSOR: { FILTER: number; SERIES_FILTER: number; STATISTIC: 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 registerTransform

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

            variable version

            const version: string;

              Functions

              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 disconnect

              disconnect: (groupId: string) => void;

                function dispose

                dispose: (chart: EChartsType | HTMLElement | string) => void;
                • Dispose a chart instance

                function extendChartView

                extendChartView: (proto: object) => ChartView;

                  function extendComponentModel

                  extendComponentModel: (proto: object) => ComponentModel;

                    function extendComponentView

                    extendComponentView: (proto: object) => ChartView;

                      function extendSeriesModel

                      extendSeriesModel: (proto: object) => SeriesModel;

                        function getCoordinateSystemDimensions

                        getCoordinateSystemDimensions: (type: string) => DimensionDefinitionLoose[];
                        • Get dimensions of specified coordinate system.

                          Parameter type

                          {Array.<string|Object>}

                        function getInstanceByDom

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

                          function getInstanceById

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

                            function getMap

                            getMap: (mapName: string) => any;

                              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 innerDrawElementOnCanvas

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

                                function parseGeoJson

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

                                  function parseGeoJSON

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

                                    function registerAction

                                    registerAction: {
                                    (type: string, eventName: 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 () { ... } );

                                      Parameter actionInfo

                                      Parameter

                                      {string} actionInfo.type

                                      Parameter

                                      {string} [actionInfo.event]

                                      Parameter

                                      {string} [actionInfo.update]

                                      Parameter eventName

                                      Parameter action

                                    function registerCoordinateSystem

                                    registerCoordinateSystem: (
                                    type: string,
                                    coordSysCreator: CoordinateSystemCreator
                                    ) => 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 registerPostInit

                                          registerPostInit: (postInitFunc: PostIniter) => void;
                                          • Register postIniter

                                            Parameter postInitFunc

                                          function registerPostUpdate

                                          registerPostUpdate: (postUpdateFunc: PostUpdater) => void;
                                          • Register postUpdater

                                            Parameter postUpdateFunc

                                          function registerPreprocessor

                                          registerPreprocessor: (preprocessorFunc: OptionPreprocessor) => void;
                                          • Register option preprocessor

                                          function registerProcessor

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

                                            function registerTheme

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

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

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

                                                    Classes

                                                    class Axis

                                                    class Axis {}
                                                    • Base class of Axis.

                                                    constructor

                                                    constructor(
                                                    dim: string,
                                                    scale: Scale<Dictionary<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<Dictionary<unknown>>;

                                                                property type

                                                                type: 'value' | 'category' | 'time' | 'log';
                                                                • Axis type - 'category' - 'value' - 'time' - 'log'

                                                                method calculateCategoryInterval

                                                                calculateCategoryInterval: () => ReturnType<typeof calculateCategoryInterval>;
                                                                • Only be called in category axis. Can be overridden, consider other axes like in 3D. Auto interval for cateogry 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;
                                                                • Get width of band

                                                                method getExtent

                                                                getExtent: () => [number, number];
                                                                • Get coord extent.

                                                                method getLabelModel

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

                                                                  method getMinorTicksCoords

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

                                                                    method getPixelPrecision

                                                                    getPixelPrecision: (dataExtent?: [number, number]) => number;
                                                                    • Get precision used for formatting

                                                                    method getTickModel

                                                                    getTickModel: () => Model;
                                                                    • 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; clamp?: boolean }) => TickCoord[];
                                                                    • 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')

                                                                      Parameter

                                                                      opt.clamp If true, the first and the last tick must be at the axis end points. Otherwise, clip ticks that outside the axis extent.

                                                                    method getViewLabels

                                                                    getViewLabels: () => ReturnType<typeof createAxisLabels>['labels'];

                                                                      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 self.

                                                                                          method render

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

                                                                                            method updateLayout

                                                                                            updateLayout: (
                                                                                            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 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: string | number;
                                                                                                                top: string | number;
                                                                                                                right: string | number;
                                                                                                                bottom: string | number;
                                                                                                                width: string | number;
                                                                                                                height: string | number;
                                                                                                                };

                                                                                                                  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;
                                                                                                                  • Get key for zlevel. If developers don't configure zlevel. We will assign zlevel to series based on the key. For example, lines with trail effect and progressive series will in an individual zlevel.

                                                                                                                  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', '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',
                                                                                                                                                          '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(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) => [number, number];
                                                                                                                                                                    • PENDING: In fact currently this function is only used to short-circuit the calling of scale.unionExtentFromData when data have been filtered by modules like "dataZoom". scale.unionExtentFromData is used to calculate data extent for series on an axis, but if a "axis related data filter module" is used, the extent of the axis have been fixed and no need to calling scale.unionExtentFromData actually. But if we add "custom data filter" in future, which is not "axis related", this method may be still needed.

                                                                                                                                                                      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 indicesOfNearest

                                                                                                                                                                                        indicesOfNearest: (
                                                                                                                                                                                        dim: DimensionLoose,
                                                                                                                                                                                        value: number,
                                                                                                                                                                                        maxDistance?: number
                                                                                                                                                                                        ) => number[];
                                                                                                                                                                                        • Retrieve the index of nearest value

                                                                                                                                                                                          Parameter dim

                                                                                                                                                                                          Parameter value

                                                                                                                                                                                          Parameter maxDistance

                                                                                                                                                                                          If and only if multiple indices has the same value, they are put to the result.

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

                                                                                                                                                                                                                                                                                                            interface AxisPointerOption
                                                                                                                                                                                                                                                                                                            extends ComponentOption,
                                                                                                                                                                                                                                                                                                            Omit<CommonAxisPointerOption, 'type'> {}
                                                                                                                                                                                                                                                                                                              link?: AxisPointerLink[];

                                                                                                                                                                                                                                                                                                                property mainType

                                                                                                                                                                                                                                                                                                                mainType?: 'axisPointer';

                                                                                                                                                                                                                                                                                                                  property type

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

                                                                                                                                                                                                                                                                                                                    interface BrushComponentOption

                                                                                                                                                                                                                                                                                                                    interface BrushOption extends ComponentOption, ModelFinderObject {}
                                                                                                                                                                                                                                                                                                                      brushLink?: number[] | 'all' | 'none';

                                                                                                                                                                                                                                                                                                                        property brushMode

                                                                                                                                                                                                                                                                                                                        brushMode?: BrushMode;

                                                                                                                                                                                                                                                                                                                          property brushStyle

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

                                                                                                                                                                                                                                                                                                                            property brushType

                                                                                                                                                                                                                                                                                                                            brushType?: BrushTypeUncertain;

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

                                                                                                                                                                                                                                                                                                                                                                      interface ContinousVisualMapOption 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;
                                                                                                                                                                                                                                                                                                                                                                                  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 modification of min max, until user specified a range.

                                                                                                                                                                                                                                                                                                                                                                                        interface CustomSeriesRenderItemAPI

                                                                                                                                                                                                                                                                                                                                                                                        interface CustomSeriesRenderItemAPI
                                                                                                                                                                                                                                                                                                                                                                                        extends CustomSeriesRenderItemCoordinateSystemAPI {}

                                                                                                                                                                                                                                                                                                                                                                                          method barLayout

                                                                                                                                                                                                                                                                                                                                                                                          barLayout: (opt: BarGridLayoutOptionForCustomSeries) => BarGridLayoutResult;

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mainType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mainType?: 'geo';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property regions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    regions?: RegoinOption[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BoxLayoutOptionMixin,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ShadowOptionMixin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property backgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    backgroundColor?: ZRColor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property borderColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      borderColor?: ZRColor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property borderWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        borderWidth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property containLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          containLabel?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mainType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mainType?: 'grid';

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