echarts

  • Version 5.3.0
  • Published
  • 41.3 MB
  • 2 dependencies
  • Apache-2.0 license

Install

npm i echarts
yarn add echarts
pnpm add echarts

Overview

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

Index

Variables

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

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

              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,
                            theme?: string | object,
                            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 overrided, 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 overrided 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 resposibilities: (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 then one components, which is convinient is some case). (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 blurSeries

                                                                                                                                  blurSeries: (seriesModels: SeriesModel[], ecModel: GlobalModel) => void;
                                                                                                                                  • Hook for blur target series. Can be used in marker for blur the markers

                                                                                                                                  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 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. Becuase 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 ndoes.

                                                                                                                                                            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 exaclty cooresponding 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.

                                                                                                                                                                        Becuause 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. Becuase: 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. Becuase: 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. Inlcuding '-' Only check the coord dimensions.

                                                                                                                                                                                    method indexOfName

                                                                                                                                                                                    indexOfName: (name: string) => number;
                                                                                                                                                                                    • Retreive the index with given name

                                                                                                                                                                                    method indexOfRawIndex

                                                                                                                                                                                    indexOfRawIndex: (rawIndex: number) => number;

                                                                                                                                                                                      method indicesOfNearest

                                                                                                                                                                                      indicesOfNearest: (
                                                                                                                                                                                      dim: DimensionLoose,
                                                                                                                                                                                      value: number,
                                                                                                                                                                                      maxDistance?: number
                                                                                                                                                                                      ) => number[];
                                                                                                                                                                                      • Retreive 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: calculte 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 overrided 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 overriden.

                                                                                                                                                                                                                                                                  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, util user specifid 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 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 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 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dataIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Index of data which the label represents. It can be null if label does't represent any data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dataType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dataType?: SeriesDataType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Type of data which the label represents. It can be null if label does't represent any data.