ngx-echarts

  • Version 14.0.0
  • Published
  • 152 kB
  • 1 dependency
  • MIT license

Install

npm i ngx-echarts
yarn add ngx-echarts
pnpm add ngx-echarts

Overview

<!-- Badges section here. -->

Index

Variables

variable NGX_ECHARTS_CONFIG

const NGX_ECHARTS_CONFIG: InjectionToken<NgxEchartsConfig>;

    Classes

    class NgxEchartsDirective

    class NgxEchartsDirective implements OnChanges, OnDestroy, OnInit, AfterViewInit {}

      constructor

      constructor(config: NgxEchartsConfig, el: ElementRef, ngZone: NgZone);

        property animationFrameID

        animationFrameID: any;

          property autoResize

          autoResize: boolean;

            property chartAxisAreaSelected

            chartAxisAreaSelected: EventEmitter<unknown>;

              property chartBrush

              chartBrush: EventEmitter<unknown>;

                property chartBrushEnd

                chartBrushEnd: EventEmitter<unknown>;

                  property chartBrushSelected

                  chartBrushSelected: EventEmitter<unknown>;

                    property chartClick

                    chartClick: EventEmitter<unknown>;

                      property chartContextMenu

                      chartContextMenu: EventEmitter<unknown>;

                        property chartDataRangeSelected

                        chartDataRangeSelected: EventEmitter<unknown>;

                          property chartDataViewChanged

                          chartDataViewChanged: EventEmitter<unknown>;

                            property chartDataZoom

                            chartDataZoom: EventEmitter<unknown>;

                              property chartDblClick

                              chartDblClick: EventEmitter<unknown>;

                                property chartFinished

                                chartFinished: EventEmitter<unknown>;

                                  property chartFocusNodeAdjacency

                                  chartFocusNodeAdjacency: EventEmitter<unknown>;

                                    property chartGlobalOut

                                    chartGlobalOut: EventEmitter<unknown>;

                                      property chartInit

                                      chartInit: EventEmitter<any>;

                                        property chartLegendScroll

                                        chartLegendScroll: EventEmitter<unknown>;

                                          property chartLegendSelectChanged

                                          chartLegendSelectChanged: EventEmitter<unknown>;

                                            property chartLegendSelected

                                            chartLegendSelected: EventEmitter<unknown>;

                                              property chartLegendUnselected

                                              chartLegendUnselected: EventEmitter<unknown>;

                                                property chartMagicTypeChanged

                                                chartMagicTypeChanged: EventEmitter<unknown>;

                                                  property chartMapSelectChanged

                                                  chartMapSelectChanged: EventEmitter<unknown>;

                                                    property chartMapSelected

                                                    chartMapSelected: EventEmitter<unknown>;

                                                      property chartMapUnselected

                                                      chartMapUnselected: EventEmitter<unknown>;

                                                        property chartMouseDown

                                                        chartMouseDown: EventEmitter<unknown>;

                                                          property chartMouseMove

                                                          chartMouseMove: EventEmitter<unknown>;

                                                            property chartMouseOut

                                                            chartMouseOut: EventEmitter<unknown>;

                                                              property chartMouseOver

                                                              chartMouseOver: EventEmitter<unknown>;

                                                                property chartMouseUp

                                                                chartMouseUp: EventEmitter<unknown>;

                                                                  property chartPieSelectChanged

                                                                  chartPieSelectChanged: EventEmitter<unknown>;

                                                                    property chartPieSelected

                                                                    chartPieSelected: EventEmitter<unknown>;

                                                                      property chartPieUnselected

                                                                      chartPieUnselected: EventEmitter<unknown>;

                                                                        property chartRendered

                                                                        chartRendered: EventEmitter<unknown>;

                                                                          property chartRestore

                                                                          chartRestore: EventEmitter<unknown>;

                                                                            property chartTimelineChanged

                                                                            chartTimelineChanged: EventEmitter<unknown>;

                                                                              property chartTimelinePlayChanged

                                                                              chartTimelinePlayChanged: EventEmitter<unknown>;

                                                                                property chartUnfocusNodeAdjacency

                                                                                chartUnfocusNodeAdjacency: EventEmitter<unknown>;

                                                                                  property initOpts

                                                                                  initOpts: {
                                                                                  devicePixelRatio?: number;
                                                                                  renderer?: string;
                                                                                  width?: number | string;
                                                                                  height?: number | string;
                                                                                  locale?: string;
                                                                                  };

                                                                                    property loading

                                                                                    loading: boolean;

                                                                                      property loadingOpts

                                                                                      loadingOpts: {};

                                                                                        property loadingType

                                                                                        loadingType: string;

                                                                                          property merge

                                                                                          merge: EChartsOption;

                                                                                            property options

                                                                                            options: EChartsOption;

                                                                                              property optionsError

                                                                                              optionsError: EventEmitter<Error>;

                                                                                                property ɵdir

                                                                                                static ɵdir: i0.ɵɵDirectiveDeclaration<
                                                                                                NgxEchartsDirective,
                                                                                                'echarts, [echarts]',
                                                                                                ['echarts'],
                                                                                                {
                                                                                                options: 'options';
                                                                                                theme: 'theme';
                                                                                                loading: 'loading';
                                                                                                initOpts: 'initOpts';
                                                                                                merge: 'merge';
                                                                                                autoResize: 'autoResize';
                                                                                                loadingType: 'loadingType';
                                                                                                loadingOpts: 'loadingOpts';
                                                                                                },
                                                                                                {
                                                                                                chartInit: 'chartInit';
                                                                                                optionsError: 'optionsError';
                                                                                                chartClick: 'chartClick';
                                                                                                chartDblClick: 'chartDblClick';
                                                                                                chartMouseDown: 'chartMouseDown';
                                                                                                chartMouseMove: 'chartMouseMove';
                                                                                                chartMouseUp: 'chartMouseUp';
                                                                                                chartMouseOver: 'chartMouseOver';
                                                                                                chartMouseOut: 'chartMouseOut';
                                                                                                chartGlobalOut: 'chartGlobalOut';
                                                                                                chartContextMenu: 'chartContextMenu';
                                                                                                chartLegendSelectChanged: 'chartLegendSelectChanged';
                                                                                                chartLegendSelected: 'chartLegendSelected';
                                                                                                chartLegendUnselected: 'chartLegendUnselected';
                                                                                                chartLegendScroll: 'chartLegendScroll';
                                                                                                chartDataZoom: 'chartDataZoom';
                                                                                                chartDataRangeSelected: 'chartDataRangeSelected';
                                                                                                chartTimelineChanged: 'chartTimelineChanged';
                                                                                                chartTimelinePlayChanged: 'chartTimelinePlayChanged';
                                                                                                chartRestore: 'chartRestore';
                                                                                                chartDataViewChanged: 'chartDataViewChanged';
                                                                                                chartMagicTypeChanged: 'chartMagicTypeChanged';
                                                                                                chartPieSelectChanged: 'chartPieSelectChanged';
                                                                                                chartPieSelected: 'chartPieSelected';
                                                                                                chartPieUnselected: 'chartPieUnselected';
                                                                                                chartMapSelectChanged: 'chartMapSelectChanged';
                                                                                                chartMapSelected: 'chartMapSelected';
                                                                                                chartMapUnselected: 'chartMapUnselected';
                                                                                                chartAxisAreaSelected: 'chartAxisAreaSelected';
                                                                                                chartFocusNodeAdjacency: 'chartFocusNodeAdjacency';
                                                                                                chartUnfocusNodeAdjacency: 'chartUnfocusNodeAdjacency';
                                                                                                chartBrush: 'chartBrush';
                                                                                                chartBrushEnd: 'chartBrushEnd';
                                                                                                chartBrushSelected: 'chartBrushSelected';
                                                                                                chartRendered: 'chartRendered';
                                                                                                chartFinished: 'chartFinished';
                                                                                                },
                                                                                                never,
                                                                                                never,
                                                                                                false
                                                                                                >;

                                                                                                  property ɵfac

                                                                                                  static ɵfac: i0.ɵɵFactoryDeclaration<NgxEchartsDirective, never>;

                                                                                                    property theme

                                                                                                    theme: string | ThemeOption;

                                                                                                      method ngAfterViewInit

                                                                                                      ngAfterViewInit: () => void;

                                                                                                        method ngOnChanges

                                                                                                        ngOnChanges: (changes: SimpleChanges) => void;

                                                                                                          method ngOnDestroy

                                                                                                          ngOnDestroy: () => void;

                                                                                                            method ngOnInit

                                                                                                            ngOnInit: () => void;

                                                                                                              method refreshChart

                                                                                                              refreshChart: () => Promise<void>;
                                                                                                              • dispose old chart and create a new one.

                                                                                                              method resize

                                                                                                              resize: () => void;
                                                                                                              • resize chart

                                                                                                              class NgxEchartsModule

                                                                                                              class NgxEchartsModule {}

                                                                                                                property ɵfac

                                                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<NgxEchartsModule, never>;

                                                                                                                  property ɵinj

                                                                                                                  static ɵinj: i0.ɵɵInjectorDeclaration<NgxEchartsModule>;

                                                                                                                    property ɵmod

                                                                                                                    static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                    NgxEchartsModule,
                                                                                                                    [typeof NgxEchartsDirective],
                                                                                                                    never,
                                                                                                                    [typeof NgxEchartsDirective]
                                                                                                                    >;

                                                                                                                      method forChild

                                                                                                                      static forChild: () => ModuleWithProviders<NgxEchartsModule>;

                                                                                                                        method forRoot

                                                                                                                        static forRoot: (
                                                                                                                        config: NgxEchartsConfig
                                                                                                                        ) => ModuleWithProviders<NgxEchartsModule>;

                                                                                                                          Type Aliases

                                                                                                                          type ThemeOption

                                                                                                                          type ThemeOption = Record<string, any>;

                                                                                                                            Package Files (3)

                                                                                                                            Dependencies (1)

                                                                                                                            Dev Dependencies (0)

                                                                                                                            No dev dependencies.

                                                                                                                            Peer Dependencies (1)

                                                                                                                            Badge

                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ngx-echarts.

                                                                                                                            • Markdown
                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ngx-echarts)
                                                                                                                            • HTML
                                                                                                                              <a href="https://www.jsdocs.io/package/ngx-echarts"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>