@covalent/echarts 4.0.0-alpha.0 → 4.0.0-beta.4

package/esm2020/base/axis/x-axis.component.mjs

@@ -0,0 +1,55 @@
+import { Component, ChangeDetectionStrategy, Input } from '@angular/core';
+import { TdChartOptionsService } from '../chart-options.service';
+import { TdChartAxisDirective } from './axis.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../chart-options.service";
+export class TdChartXAxisComponent extends TdChartAxisDirective {
+    constructor(_optionsService) {
+        super('xAxis', _optionsService);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdChartXAxisComponent.ɵfac = function TdChartXAxisComponent_Factory(t) { return new (t || TdChartXAxisComponent)(i0.ɵɵdirectiveInject(i1.TdChartOptionsService)); };
+/** @nocollapse */ /** @nocollapse */ TdChartXAxisComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdChartXAxisComponent, selectors: [["td-chart-x-axis"]], inputs: { config: "config", id: "id", show: "show", gridIndex: "gridIndex", offset: "offset", type: "type", name: "name", nameLocation: "nameLocation", nameTextStyle: "nameTextStyle", nameGap: "nameGap", nameRotate: "nameRotate", inverse: "inverse", boundaryGap: "boundaryGap", min: "min", max: "max", scale: "scale", minInterval: "minInterval", interval: "interval", logBase: "logBase", silent: "silent", triggerEvent: "triggerEvent", axisLine: "axisLine", axisTick: "axisTick", axisLabel: "axisLabel", splitLine: "splitLine", splitArea: "splitArea", data: "data", axisPointer: "axisPointer", zlevel: "zlevel", z: "z", position: "position" }, features: [i0.ɵɵInheritDefinitionFeature], decls: 0, vars: 0, template: function TdChartXAxisComponent_Template(rf, ctx) { }, encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdChartXAxisComponent, [{
+        type: Component,
+        args: [{
+                selector: 'td-chart-x-axis',
+                template: '',
+                inputs: [
+                    'config',
+                    'id',
+                    'show',
+                    'gridIndex',
+                    'offset',
+                    'type',
+                    'name',
+                    'nameLocation',
+                    'nameTextStyle',
+                    'nameGap',
+                    'nameRotate',
+                    'inverse',
+                    'boundaryGap',
+                    'min',
+                    'max',
+                    'scale',
+                    'minInterval',
+                    'interval',
+                    'logBase',
+                    'silent',
+                    'triggerEvent',
+                    'axisLine',
+                    'axisTick',
+                    'axisLabel',
+                    'splitLine',
+                    'splitArea',
+                    'data',
+                    'axisPointer',
+                    'zlevel',
+                    'z',
+                ],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.TdChartOptionsService }]; }, { position: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/axis/y-axis.component.mjs

@@ -0,0 +1,55 @@
+import { Component, ChangeDetectionStrategy, Input } from '@angular/core';
+import { TdChartOptionsService } from '../chart-options.service';
+import { TdChartAxisDirective } from './axis.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../chart-options.service";
+export class TdChartYAxisComponent extends TdChartAxisDirective {
+    constructor(_optionsService) {
+        super('yAxis', _optionsService);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdChartYAxisComponent.ɵfac = function TdChartYAxisComponent_Factory(t) { return new (t || TdChartYAxisComponent)(i0.ɵɵdirectiveInject(i1.TdChartOptionsService)); };
+/** @nocollapse */ /** @nocollapse */ TdChartYAxisComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdChartYAxisComponent, selectors: [["td-chart-y-axis"]], inputs: { config: "config", id: "id", show: "show", gridIndex: "gridIndex", offset: "offset", type: "type", name: "name", nameLocation: "nameLocation", nameTextStyle: "nameTextStyle", nameGap: "nameGap", nameRotate: "nameRotate", inverse: "inverse", boundaryGap: "boundaryGap", min: "min", max: "max", scale: "scale", minInterval: "minInterval", interval: "interval", logBase: "logBase", silent: "silent", triggerEvent: "triggerEvent", axisLine: "axisLine", axisTick: "axisTick", axisLabel: "axisLabel", splitLine: "splitLine", splitArea: "splitArea", data: "data", axisPointer: "axisPointer", zlevel: "zlevel", z: "z", position: "position" }, features: [i0.ɵɵInheritDefinitionFeature], decls: 0, vars: 0, template: function TdChartYAxisComponent_Template(rf, ctx) { }, encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdChartYAxisComponent, [{
+        type: Component,
+        args: [{
+                selector: 'td-chart-y-axis',
+                template: '',
+                inputs: [
+                    'config',
+                    'id',
+                    'show',
+                    'gridIndex',
+                    'offset',
+                    'type',
+                    'name',
+                    'nameLocation',
+                    'nameTextStyle',
+                    'nameGap',
+                    'nameRotate',
+                    'inverse',
+                    'boundaryGap',
+                    'min',
+                    'max',
+                    'scale',
+                    'minInterval',
+                    'interval',
+                    'logBase',
+                    'silent',
+                    'triggerEvent',
+                    'axisLine',
+                    'axisTick',
+                    'axisLabel',
+                    'splitLine',
+                    'splitArea',
+                    'data',
+                    'axisPointer',
+                    'zlevel',
+                    'z',
+                ],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.TdChartOptionsService }]; }, { position: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/base.module.mjs

@@ -0,0 +1,36 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TdChartComponent } from './chart.component';
+import { TdChartXAxisComponent } from './axis/x-axis.component';
+import { TdChartYAxisComponent } from './axis/y-axis.component';
+import { TdDatasetComponent } from './dataset/dataset.component';
+import { registerDefaultThemes } from './utils';
+import * as i0 from "@angular/core";
+export const BASE_MODULE_COMPONENTS = [
+    TdChartComponent,
+    TdChartXAxisComponent,
+    TdChartYAxisComponent,
+    TdDatasetComponent,
+];
+registerDefaultThemes();
+export class CovalentBaseEchartsModule {
+}
+/** @nocollapse */ /** @nocollapse */ CovalentBaseEchartsModule.ɵfac = function CovalentBaseEchartsModule_Factory(t) { return new (t || CovalentBaseEchartsModule)(); };
+/** @nocollapse */ /** @nocollapse */ CovalentBaseEchartsModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CovalentBaseEchartsModule });
+/** @nocollapse */ /** @nocollapse */ CovalentBaseEchartsModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ imports: [[CommonModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentBaseEchartsModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: [BASE_MODULE_COMPONENTS],
+                exports: [BASE_MODULE_COMPONENTS],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CovalentBaseEchartsModule, { declarations: [TdChartComponent,
+        TdChartXAxisComponent,
+        TdChartYAxisComponent,
+        TdDatasetComponent], imports: [CommonModule], exports: [TdChartComponent,
+        TdChartXAxisComponent,
+        TdChartYAxisComponent,
+        TdDatasetComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/base.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/chart-options.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TdChartOptionsService {
+    constructor() {
+        this._options = {};
+        this._optionsSubject = new BehaviorSubject(this._options);
+    }
+    setOption(option, value) {
+        const options = {};
+        options[option] = value;
+        Object.assign(this._options, options);
+        this._optionsSubject.next(this._options);
+    }
+    setArrayOption(option, value) {
+        let prevValue = this.getOption(option);
+        if (prevValue) {
+            const index = prevValue.indexOf(value);
+            index > -1 ? (prevValue[index] = value) : prevValue.push(value);
+        }
+        else {
+            prevValue = [value];
+        }
+        this.setOption(option, prevValue);
+    }
+    removeArrayOption(option, value) {
+        let prevValue = this.getOption(option);
+        if (prevValue) {
+            const index = prevValue.indexOf(value);
+            if (index > -1) {
+                /* tslint:disable-next-line */
+                prevValue[index] = null;
+            }
+            else {
+                prevValue = [];
+            }
+        }
+        this.setOption(option, prevValue);
+    }
+    getOption(option) {
+        return this._options[option];
+    }
+    clearOption(option) {
+        /* tslint:disable-next-line */
+        this.setOption(option, null);
+    }
+    listen() {
+        return this._optionsSubject.asObservable();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdChartOptionsService.ɵfac = function TdChartOptionsService_Factory(t) { return new (t || TdChartOptionsService)(); };
+/** @nocollapse */ /** @nocollapse */ TdChartOptionsService.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: TdChartOptionsService, factory: TdChartOptionsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdChartOptionsService, [{
+        type: Injectable
+    }], null, null); })();
+export function CHART_PROVIDER_FACTORY(parent) {
+    return parent || new TdChartOptionsService();
+}
+export const CHART_PROVIDER = {
+    // If there is already a service available, use that. Otherwise, provide a new one.
+    provide: TdChartOptionsService,
+    deps: [[new Optional(), new SkipSelf(), TdChartOptionsService]],
+    useFactory: CHART_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/chart.component.mjs

@@ -0,0 +1,191 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ElementRef, ChangeDetectorRef, } from '@angular/core';
+import { Subject, fromEvent, merge, timer } from 'rxjs';
+import { debounceTime, distinctUntilChanged, takeUntil, tap } from 'rxjs/operators';
+import { TdChartOptionsService, CHART_PROVIDER } from './chart-options.service';
+import { assignDefined } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart-options.service";
+export class TdChartComponent {
+    constructor(_changeDetectorRef, _elementRef, _optionsService) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._elementRef = _elementRef;
+        this._optionsService = _optionsService;
+        this._destroy = new Subject();
+        this._widthSubject = new Subject();
+        this._heightSubject = new Subject();
+        this._state = {};
+        this._options = {};
+        /**
+         * config?: any;
+         * Sets the JS config object if you choose to not use the property inputs.
+         * Note: [config] input properties will override input values
+         * https://ecomfe.github.io/echarts-doc/public/en/option.html
+         */
+        this.config = {};
+        /**
+         * renderer: 'svg' | 'canvas'
+         * sets the rendering mode for the chart.
+         * defaults to 'canvas'
+         * https://ecomfe.github.io/echarts-doc/public/en/tutorial.html#Render%20by%20Canvas%20or%20SVG
+         */
+        this.renderer = 'canvas';
+        this.chartClick = new EventEmitter();
+        this.chartDblclick = new EventEmitter();
+        this.chartContextmenu = new EventEmitter();
+        this.magicTypeChanged = new EventEmitter();
+        this.dataViewChanged = new EventEmitter();
+        this.datazoom = new EventEmitter();
+        this.restore = new EventEmitter();
+    }
+    /**
+     * returns the echarts instance
+     */
+    get instance() {
+        return this._instance;
+    }
+    ngAfterViewInit() {
+        this._initializeChart();
+    }
+    ngOnChanges(changes) {
+        if (this._instance) {
+            // destroy and reinitialize chart only when `renderer`, `themeName` and `group` changes
+            if (changes.renderer || changes.themeName || changes.group) {
+                this._disposeChart();
+                this._initializeChart();
+            }
+            else {
+                this.render();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this._disposeChart();
+        this._destroy.unsubscribe();
+    }
+    render() {
+        if (this._instance) {
+            this._instance.setOption(assignDefined(this._state, {
+                grid: {
+                    show: true,
+                    left: '20',
+                    right: '20',
+                    bottom: (this.config.toolbox && typeof this.config.toolbox.bottom === 'number') ||
+                        (this._options.toolbox && typeof this._options.toolbox.bottom === 'number')
+                        ? '40'
+                        : '10',
+                    top: (this.config.toolbox && typeof this.config.toolbox.top === 'number') ||
+                        (this._options.toolbox && typeof this._options.toolbox.top === 'number')
+                        ? '40'
+                        : '10',
+                    containLabel: true,
+                },
+            }, this._options, this.config ? this.config : {}), true);
+            this._changeDetectorRef.markForCheck();
+        }
+    }
+    _initializeChart() {
+        this._instance = echarts.init(this._elementRef.nativeElement, this.themeName, {
+            renderer: this.renderer,
+        });
+        fromEvent(this._instance, 'click')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.chartClick.next(params);
+        });
+        fromEvent(this._instance, 'dblclick')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.chartDblclick.next(params);
+        });
+        fromEvent(this._instance, 'contextmenu')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.chartContextmenu.next(params);
+        });
+        fromEvent(this._instance, 'magictypechanged')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.magicTypeChanged.next(params);
+        });
+        fromEvent(this._instance, 'dataviewchanged')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.dataViewChanged.next(params);
+        });
+        fromEvent(this._instance, 'datazoom')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.datazoom.next(params);
+        });
+        fromEvent(this._instance, 'restore')
+            .pipe(takeUntil(this._destroy))
+            .subscribe((params) => {
+            this.restore.next(params);
+        });
+        if (this.group) {
+            this._instance.group = this.group;
+            echarts.connect(this.group);
+            this._changeDetectorRef.markForCheck();
+        }
+        merge(fromEvent(window, 'resize').pipe(debounceTime(100)), this._widthSubject.asObservable().pipe(distinctUntilChanged()), this._heightSubject.asObservable().pipe(distinctUntilChanged()))
+            .pipe(takeUntil(this._destroy), debounceTime(100))
+            .subscribe(() => {
+            if (this._instance) {
+                this._instance.resize();
+                this._changeDetectorRef.markForCheck();
+            }
+        });
+        this._optionsService
+            .listen()
+            .pipe(tap((options) => {
+            assignDefined(this._options, options);
+        }), debounceTime(0), takeUntil(this._destroy))
+            .subscribe(() => {
+            this.render();
+        });
+        timer(500, 250)
+            .pipe(takeUntil(this._destroy))
+            .subscribe(() => {
+            if (this._elementRef && this._elementRef.nativeElement) {
+                this._widthSubject.next(this._elementRef.nativeElement.getBoundingClientRect().width);
+                this._heightSubject.next(this._elementRef.nativeElement.getBoundingClientRect().height);
+            }
+        });
+    }
+    _disposeChart() {
+        if (this._instance) {
+            this._instance.clear();
+            echarts.dispose(this._instance);
+        }
+        this._destroy.next(true);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdChartComponent.ɵfac = function TdChartComponent_Factory(t) { return new (t || TdChartComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.TdChartOptionsService)); };
+/** @nocollapse */ /** @nocollapse */ TdChartComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdChartComponent, selectors: [["td-chart"]], inputs: { config: "config", group: "group", themeName: "themeName", renderer: "renderer" }, outputs: { chartClick: "chartClick", chartDblclick: "chartDblclick", chartContextmenu: "chartContextmenu", magicTypeChanged: "magicTypeChanged", dataViewChanged: "dataViewChanged", datazoom: "datazoom", restore: "restore" }, features: [i0.ɵɵProvidersFeature([CHART_PROVIDER]), i0.ɵɵNgOnChangesFeature], decls: 0, vars: 0, template: function TdChartComponent_Template(rf, ctx) { }, styles: ["[_nghost-%COMP%]{display:block;width:100%}"], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdChartComponent, [{
+        type: Component,
+        args: [{ selector: 'td-chart', template: '', changeDetection: ChangeDetectionStrategy.OnPush, providers: [CHART_PROVIDER], styles: [":host{display:block;width:100%}\n"] }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.TdChartOptionsService }]; }, { config: [{
+            type: Input
+        }], group: [{
+            type: Input
+        }], themeName: [{
+            type: Input
+        }], renderer: [{
+            type: Input
+        }], chartClick: [{
+            type: Output
+        }], chartDblclick: [{
+            type: Output
+        }], chartContextmenu: [{
+            type: Output
+        }], magicTypeChanged: [{
+            type: Output
+        }], dataViewChanged: [{
+            type: Output
+        }], datazoom: [{
+            type: Output
+        }], restore: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../../src/platform/echarts/base/chart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectionStrategy,\n  ElementRef,\n  ChangeDetectorRef,\n  AfterViewInit,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n} from '@angular/core';\n\nimport { Subject, fromEvent, merge, timer } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, takeUntil, tap } from 'rxjs/operators';\n\nimport { TdChartOptionsService, CHART_PROVIDER } from './chart-options.service';\nimport { assignDefined } from './utils';\n\n@Component({\n  selector: 'td-chart',\n  template: '',\n  styleUrls: ['./chart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [CHART_PROVIDER],\n})\nexport class TdChartComponent implements AfterViewInit, OnChanges, OnDestroy {\n  private _destroy: Subject<boolean> = new Subject<boolean>();\n  private _widthSubject: Subject<number> = new Subject<number>();\n  private _heightSubject: Subject<number> = new Subject<number>();\n\n  private _instance: any;\n\n  /**\n   * returns the echarts instance\n   */\n  get instance(): any {\n    return this._instance;\n  }\n\n  private _state: any = {};\n  private _options: any = {};\n\n  /**\n   * config?: any;\n   * Sets the JS config object if you choose to not use the property inputs.\n   * Note: [config] input properties will override input values\n   * https://ecomfe.github.io/echarts-doc/public/en/option.html\n   */\n  @Input() config: any = {};\n\n  /**\n   * group?: string\n   * group name in which the chart instance will be connected to\n   * https://ecomfe.github.io/echarts-doc/public/en/api.html#echarts.connect\n   */\n  @Input() group: string;\n\n  /**\n   * themeName?: string\n   * theme to be applied into chart instance\n   * https://ecomfe.github.io/echarts-doc/public/en/tutorial.html#Overview%20of%20Style%20Customization\n   */\n  @Input() themeName: string;\n\n  /**\n   * renderer: 'svg' | 'canvas'\n   * sets the rendering mode for the chart.\n   * defaults to 'canvas'\n   * https://ecomfe.github.io/echarts-doc/public/en/tutorial.html#Render%20by%20Canvas%20or%20SVG\n   */\n  @Input() renderer: 'canvas' | 'svg' = 'canvas';\n\n  @Output() chartClick: EventEmitter<any> = new EventEmitter<any>();\n  @Output() chartDblclick: EventEmitter<any> = new EventEmitter<any>();\n  @Output() chartContextmenu: EventEmitter<any> = new EventEmitter<any>();\n  @Output() magicTypeChanged: EventEmitter<any> = new EventEmitter<any>();\n  @Output() dataViewChanged: EventEmitter<any> = new EventEmitter<any>();\n  @Output() datazoom: EventEmitter<any> = new EventEmitter<any>();\n  @Output() restore: EventEmitter<any> = new EventEmitter<any>();\n\n  constructor(\n    private _changeDetectorRef: ChangeDetectorRef,\n    private _elementRef: ElementRef,\n    private _optionsService: TdChartOptionsService,\n  ) {}\n\n  ngAfterViewInit(): void {\n    this._initializeChart();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this._instance) {\n      // destroy and reinitialize chart only when `renderer`, `themeName` and `group` changes\n      if (changes.renderer || changes.themeName || changes.group) {\n        this._disposeChart();\n        this._initializeChart();\n      } else {\n        this.render();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._disposeChart();\n    this._destroy.unsubscribe();\n  }\n\n  render(): void {\n    if (this._instance) {\n      this._instance.setOption(\n        assignDefined(\n          this._state,\n          {\n            grid: {\n              show: true,\n              left: '20',\n              right: '20',\n              bottom:\n                (this.config.toolbox && typeof this.config.toolbox.bottom === 'number') ||\n                (this._options.toolbox && typeof this._options.toolbox.bottom === 'number')\n                  ? '40'\n                  : '10',\n              top:\n                (this.config.toolbox && typeof this.config.toolbox.top === 'number') ||\n                (this._options.toolbox && typeof this._options.toolbox.top === 'number')\n                  ? '40'\n                  : '10',\n              containLabel: true,\n            },\n          },\n          this._options,\n          this.config ? this.config : {},\n        ),\n        true,\n      );\n      this._changeDetectorRef.markForCheck();\n    }\n  }\n\n  private _initializeChart(): void {\n    this._instance = echarts.init(this._elementRef.nativeElement, this.themeName, {\n      renderer: this.renderer,\n    });\n    fromEvent(this._instance, 'click')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.chartClick.next(params);\n      });\n    fromEvent(this._instance, 'dblclick')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.chartDblclick.next(params);\n      });\n    fromEvent(this._instance, 'contextmenu')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.chartContextmenu.next(params);\n      });\n    fromEvent(this._instance, 'magictypechanged')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.magicTypeChanged.next(params);\n      });\n    fromEvent(this._instance, 'dataviewchanged')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.dataViewChanged.next(params);\n      });\n    fromEvent(this._instance, 'datazoom')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.datazoom.next(params);\n      });\n    fromEvent(this._instance, 'restore')\n      .pipe(takeUntil(this._destroy))\n      .subscribe((params: any) => {\n        this.restore.next(params);\n      });\n    if (this.group) {\n      this._instance.group = this.group;\n      echarts.connect(this.group);\n      this._changeDetectorRef.markForCheck();\n    }\n    merge(\n      fromEvent(window, 'resize').pipe(debounceTime(100)),\n      this._widthSubject.asObservable().pipe(distinctUntilChanged()),\n      this._heightSubject.asObservable().pipe(distinctUntilChanged()),\n    )\n      .pipe(takeUntil(this._destroy), debounceTime(100))\n      .subscribe(() => {\n        if (this._instance) {\n          this._instance.resize();\n          this._changeDetectorRef.markForCheck();\n        }\n      });\n    this._optionsService\n      .listen()\n      .pipe(\n        tap((options: any) => {\n          assignDefined(this._options, options);\n        }),\n        debounceTime(0),\n        takeUntil(this._destroy),\n      )\n      .subscribe(() => {\n        this.render();\n      });\n    timer(500, 250)\n      .pipe(takeUntil(this._destroy))\n      .subscribe(() => {\n        if (this._elementRef && this._elementRef.nativeElement) {\n          this._widthSubject.next((<HTMLElement>this._elementRef.nativeElement).getBoundingClientRect().width);\n          this._heightSubject.next((<HTMLElement>this._elementRef.nativeElement).getBoundingClientRect().height);\n        }\n      });\n  }\n\n  private _disposeChart(): void {\n    if (this._instance) {\n      this._instance.clear();\n      echarts.dispose(this._instance);\n    }\n    this._destroy.next(true);\n  }\n}\n"]}

package/esm2020/base/covalent-echarts-base.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtZWNoYXJ0cy1iYXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3BsYXRmb3JtL2VjaGFydHMvYmFzZS9jb3ZhbGVudC1lY2hhcnRzLWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/base/dataset/dataset.component.mjs

@@ -0,0 +1,52 @@
+import { Component, Input, ChangeDetectionStrategy } from '@angular/core';
+import { TdChartOptionsService } from '../chart-options.service';
+import { assignDefined } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../chart-options.service";
+export class TdDatasetComponent {
+    constructor(_optionsService) {
+        this._optionsService = _optionsService;
+        this._state = {};
+        this.config = {};
+    }
+    ngOnChanges() {
+        this._setOptions();
+    }
+    ngOnDestroy() {
+        this._removeOption();
+    }
+    _setOptions() {
+        const config = assignDefined(this._state, {
+            id: this.id,
+            source: this.source,
+            dimensions: this.dimensions,
+            sourceHeader: this.sourceHeader,
+        }, this.config ? this.config : {});
+        // set dataset configuration in parent chart and render new configurations
+        this._optionsService.setOption('dataset', config);
+    }
+    _removeOption() {
+        this._optionsService.clearOption('dataset');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDatasetComponent.ɵfac = function TdDatasetComponent_Factory(t) { return new (t || TdDatasetComponent)(i0.ɵɵdirectiveInject(i1.TdChartOptionsService)); };
+/** @nocollapse */ /** @nocollapse */ TdDatasetComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdDatasetComponent, selectors: [["td-chart-dataset"]], inputs: { id: "id", config: "config", source: "source", dimensions: "dimensions", sourceHeader: "sourceHeader" }, features: [i0.ɵɵNgOnChangesFeature], decls: 0, vars: 0, template: function TdDatasetComponent_Template(rf, ctx) { }, encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDatasetComponent, [{
+        type: Component,
+        args: [{
+                template: '',
+                selector: 'td-chart-dataset',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.TdChartOptionsService }]; }, { id: [{
+            type: Input
+        }], config: [{
+            type: Input
+        }], source: [{
+            type: Input
+        }], dimensions: [{
+            type: Input
+        }], sourceHeader: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/base/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vZWNoYXJ0cy9iYXNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/base/public-api.mjs

@@ -0,0 +1,10 @@
+export * from './base.module';
+export { TdChartComponent } from './chart.component';
+export { TdChartAxisDirective } from './axis/axis.component';
+export { TdChartYAxisComponent } from './axis/y-axis.component';
+export { TdChartXAxisComponent } from './axis/x-axis.component';
+export { TdDatasetComponent } from './dataset/dataset.component';
+export { TdChartOptionsService } from './chart-options.service';
+export * from './utils';
+export * from './series/series.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9lY2hhcnRzL2Jhc2UvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUM3RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxjQUFjLFNBQVMsQ0FBQztBQWlEeEIsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS5tb2R1bGUnO1xuZXhwb3J0IHsgVGRDaGFydENvbXBvbmVudCB9IGZyb20gJy4vY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCB7IFRkQ2hhcnRBeGlzRGlyZWN0aXZlIH0gZnJvbSAnLi9heGlzL2F4aXMuY29tcG9uZW50JztcbmV4cG9ydCB7IFRkQ2hhcnRZQXhpc0NvbXBvbmVudCB9IGZyb20gJy4vYXhpcy95LWF4aXMuY29tcG9uZW50JztcbmV4cG9ydCB7IFRkQ2hhcnRYQXhpc0NvbXBvbmVudCB9IGZyb20gJy4vYXhpcy94LWF4aXMuY29tcG9uZW50JztcbmV4cG9ydCB7IFRkRGF0YXNldENvbXBvbmVudCB9IGZyb20gJy4vZGF0YXNldC9kYXRhc2V0LmNvbXBvbmVudCc7XG5leHBvcnQgeyBUZENoYXJ0T3B0aW9uc1NlcnZpY2UgfSBmcm9tICcuL2NoYXJ0LW9wdGlvbnMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbmV4cG9ydCB7XG4gIElUZEF4aXNMaW5lLFxuICBJVGRBeGlzTGFiZWwsXG4gIElUZEF4aXNUaWNrLFxuICBJVGRTcGxpdExpbmUsXG4gIElUZE5hbWVUZXh0U3R5bGUsXG4gIElUZFNwbGl0QXJlYSxcbiAgSVRkQXhpc1BvaW50ZXIsXG4gIFRkWUF4aXNQb3NpdGlvbixcbiAgVGRYQXhpc1Bvc2l0aW9uLFxuICBUZE5hbWVMb2NhdGlvbixcbiAgVGRBeGlzVHlwZSxcbiAgSVRkWEF4aXNDb25maWcsXG4gIElUZFlBeGlzQ29uZmlnLFxufSBmcm9tICcuL2F4aXMvYXhpcy5pbnRlcmZhY2UnO1xuXG5leHBvcnQge1xuICBJVGRBbmltYXRpb24sXG4gIElUZFNoYWRvdyxcbiAgVGRBbGlnbixcbiAgVGRGb250U3R5bGUsXG4gIFRkRm9udFdlaWdodCxcbiAgVGRWZXJ0aWNhbEFsaWduLFxuICBUZFBvaW50ZXJUeXBlLFxuICBUZFN0YXR1cyxcbiAgVGRMaW5lVHlwZSxcbiAgVGRUb29sdGlwVHJpZ2dlcixcbiAgVGRMYWJlbFBvc2l0aW9uLFxuICBUZEF4aXNQb2ludGVyVHlwZSxcbiAgVGRUb29sdGlwVHJpZ2dlck9uLFxuICBJVGRMaW5lU3R5bGUsXG4gIFRkQXJlYU9yaWdpbixcbiAgVGRNYXJrUG9pbnRTeW1ib2wsXG4gIFRkVG9vbHRpcFBvc2l0aW9uLFxuICBJVGRUb29sdGlwLFxuICBJVGRUZXh0U3R5bGUsXG4gIFRkTGluZUxhYmVsUG9zaXRpb24sXG4gIElUZExpbmVDdXJ2ZVN0eWxlLFxuICBJVGRMYWJlbCxcbiAgSVRkQXhpc1BvaW50ZXJMYWJlbCxcbiAgSVRkQmFzZVN0eWxlLFxuICBJVGRUb29sdGlwQXhpc1BvaW50ZXIsXG4gIFRkQXhpc1BvaW50ZXJBeGlzLFxuICBJVGRFZGdlTGFiZWwsXG4gIFRkVGV4dFBvc2l0aW9uLFxuICBUZFRleHRBbGlnbixcbn0gZnJvbSAnLi9iYXNlLnR5cGVzJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZXJpZXMvc2VyaWVzLmNvbXBvbmVudCc7XG5leHBvcnQge1xuICBJVGRJdGVtU3R5bGUsXG4gIElUZEFyZWFTdHlsZSxcbiAgSVRkRW1waGFzaXMsXG4gIElUZE1hcmtQb2ludCxcbiAgVGRDb29yZGluYXRlU3lzdGVtLFxuICBJVGRNYXJrTGluZSxcbiAgSVRkTWFya0FyZWEsXG4gIElUZExpbmVMYWJlbCxcbiAgSVRkTGFiZWxMaW5lLFxuICBJVGRNYXJrTGluZUVtcGhhc2lzLFxuICBJVGRTZXJpZXNUb29sdGlwLFxuICBUZFNlcmllc0xheW91dEJ5LFxuICBUZFByb2dyZXNzaXZlQ2h1bmtNb2RlLFxuICBJVGRNYXJrQXJlYUVtcGhhc2lzLFxufSBmcm9tICcuL3Nlcmllcy9zZXJpZXMuaW50ZXJmYWNlJztcbiJdfQ==