echarts

  • Version 5.2.1
  • Published
  • 41 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;

                        function getInstanceById

                        getInstanceById: (key: string) => EChartsType;

                          function getMap

                          getMap: (
                          mapName: string
                          ) => {
                          geoJson: GeoJSON | GeoJSONCompressed;
                          geoJSON: GeoJSON | GeoJSONCompressed;
                          specialAreas: GeoSpecialAreas;
                          };

                            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: Parameters<typeof _default$1.registerMap>[0],
                                        geoJson: Parameters<typeof _default$1.registerMap>[1],
                                        specialAreas?: Parameters<typeof _default$1.registerMap>[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')

                                                Be careful of using it in the browser.

                                                Example 1

                                                let Canvas = require('canvas'); let echarts = require('echarts'); echarts.setCanvasCreator(function () { // Small size is enough. return new Canvas(32, 32); });

                                              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 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';
                                                                                                                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';
                                                                                                                import {XxxModel, XxxOption} from './XxxModel';
                                                                                                                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 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.

                                                                                                                    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 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 'en'; It supports Chinese, English, and custom; index 0 always means Sunday
                                                                                                                                                                                                                                                                                                                                            * en: shortcut to English ['S', 'M', 'T', 'W', 'T', 'F', 'S']
                                                                                                                                                                                                                                                                                                                                            * cn: shortcut to Chinese ['日', '一', '二', '三', '四', '五', '六']
                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                            nameMap?: 'en' | 'cn' | 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 'en'; It supports Chinese, English, and custom; Index 0 always means Jan;
                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                  nameMap?: 'en' | 'cn' | 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 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property labelLinePoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        labelLinePoints?: number[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property labelRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          labelRect: RectLike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property rect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rect: RectLike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property seriesIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              seriesIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property verticalAlign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  verticalAlign: ZRTextVerticalAlign;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LinearGradientObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LinearGradientObject extends GradientObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'linear';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property x2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x2: number;