@covalent/echarts 6.4.0 → 6.4.2

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);
+    }
+}
+TdChartXAxisComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartXAxisComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdChartXAxisComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdChartXAxisComponent, selector: "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" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartXAxisComponent, decorators: [{
+            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,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TdChartOptionsService }]; }, propDecorators: { 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);
+    }
+}
+TdChartYAxisComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartYAxisComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdChartYAxisComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdChartYAxisComponent, selector: "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" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartYAxisComponent, decorators: [{
+            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,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TdChartOptionsService }]; }, propDecorators: { position: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/base/base.module.mjs

@@ -14,17 +14,17 @@ export const BASE_MODULE_COMPONENTS = [
 ];
 registerDefaultThemes();
 export class CovalentBaseEchartsModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBaseEchartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: CovalentBaseEchartsModule, declarations: [TdChartComponent,
-            TdChartXAxisComponent,
-            TdChartYAxisComponent,
-            TdDatasetComponent], imports: [CommonModule], exports: [TdChartComponent,
-            TdChartXAxisComponent,
-            TdChartYAxisComponent,
-            TdDatasetComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBaseEchartsModule, imports: [CommonModule] });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBaseEchartsModule, decorators: [{
+CovalentBaseEchartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBaseEchartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentBaseEchartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CovalentBaseEchartsModule, declarations: [TdChartComponent,
+        TdChartXAxisComponent,
+        TdChartYAxisComponent,
+        TdDatasetComponent], imports: [CommonModule], exports: [TdChartComponent,
+        TdChartXAxisComponent,
+        TdChartYAxisComponent,
+        TdDatasetComponent] });
+CovalentBaseEchartsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBaseEchartsModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBaseEchartsModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule],
@@ -32,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImpor
                     exports: [BASE_MODULE_COMPONENTS],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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();
+    }
+}
+TdChartOptionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TdChartOptionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartOptionsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartOptionsService, decorators: [{
+            type: Injectable
+        }] });
+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,195 @@
+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 {
+    /**
+     * returns the echarts instance
+     */
+    get instance() {
+        return this._instance;
+    }
+    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();
+    }
+    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);
+    }
+}
+TdChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdChartComponent, selector: "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" }, providers: [CHART_PROVIDER], usesOnChanges: true, ngImport: i0, template: '', isInline: true, styles: [":host{display:block;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'td-chart', template: '', changeDetection: ChangeDetectionStrategy.OnPush, providers: [CHART_PROVIDER], styles: [":host{display:block;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.TdChartOptionsService }]; }, propDecorators: { 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":["../../../../../libs/angular-echarts/base/src/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 {\n  debounceTime,\n  distinctUntilChanged,\n  takeUntil,\n  tap,\n} 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 | null;\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 &&\n                  typeof this.config.toolbox.bottom === 'number') ||\n                (this._options.toolbox &&\n                  typeof this._options.toolbox.bottom === 'number')\n                  ? '40'\n                  : '10',\n              top:\n                (this.config.toolbox &&\n                  typeof this.config.toolbox.top === 'number') ||\n                (this._options.toolbox &&\n                  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(\n      this._elementRef.nativeElement,\n      this.themeName ?? '',\n      {\n        renderer: this.renderer,\n      }\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(\n            (<HTMLElement>(\n              this._elementRef.nativeElement\n            )).getBoundingClientRect().width\n          );\n          this._heightSubject.next(\n            (<HTMLElement>(\n              this._elementRef.nativeElement\n            )).getBoundingClientRect().height\n          );\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/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');
+    }
+}
+TdDatasetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDatasetComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdDatasetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdDatasetComponent, selector: "td-chart-dataset", inputs: { id: "id", config: "config", source: "source", dimensions: "dimensions", sourceHeader: "sourceHeader" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDatasetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    selector: 'td-chart-dataset',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TdChartOptionsService }]; }, propDecorators: { 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/series/series.component.mjs

@@ -0,0 +1,91 @@
+import { Input, Directive } from '@angular/core';
+import { assignDefined } from '../utils/assign-defined';
+import { TdChartOptionsService } from '../chart-options.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../chart-options.service";
+export class TdSeriesDirective {
+    get type() {
+        return this._type;
+    }
+    constructor(type, optionsService) {
+        this.optionsService = optionsService;
+        this._state = {};
+        this._options = {};
+        this.config = {};
+        this._type = type;
+    }
+    ngOnInit() {
+        this._setOptions();
+    }
+    ngOnChanges() {
+        this._setOptions();
+    }
+    ngOnDestroy() {
+        this._removeOption();
+    }
+    setStateOption(option, value) {
+        this._options[option] = value;
+        this._setOptions();
+    }
+    removeStateOption(option) {
+        /* tslint:disable-next-line */
+        this._options[option] = null;
+        this._setOptions();
+    }
+    _setOptions() {
+        const config = assignDefined(this._state, {
+            id: this.id,
+            type: this.type,
+            name: this.name,
+            color: this.color,
+            data: this.data,
+            animation: this.animation,
+            animationThreshold: this.animationThreshold,
+            animationDuration: this.animationDuration,
+            animationEasing: this.animationEasing,
+            animationDelay: this.animationDelay,
+            animationDurationUpdate: this.animationDurationUpdate,
+            animationEasingUpdate: this.animationEasingUpdate,
+            animationDelayUpdate: this.animationDelayUpdate,
+            tooltip: this.tooltip,
+        }, this.getConfig(), this._options, this.config ? this.config : {});
+        this.optionsService.setArrayOption('series', config);
+    }
+    _removeOption() {
+        this.optionsService.removeArrayOption('series', this._state);
+    }
+}
+TdSeriesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdSeriesDirective, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+TdSeriesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: TdSeriesDirective, inputs: { config: "config", id: "id", name: "name", color: "color", data: "data", animation: "animation", animationThreshold: "animationThreshold", animationDuration: "animationDuration", animationEasing: "animationEasing", animationDelay: "animationDelay", animationDurationUpdate: "animationDurationUpdate", animationEasingUpdate: "animationEasingUpdate", animationDelayUpdate: "animationDelayUpdate", tooltip: "tooltip" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdSeriesDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: i1.TdChartOptionsService }]; }, propDecorators: { config: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], animation: [{
+                type: Input
+            }], animationThreshold: [{
+                type: Input
+            }], animationDuration: [{
+                type: Input
+            }], animationEasing: [{
+                type: Input
+            }], animationDelay: [{
+                type: Input
+            }], animationDurationUpdate: [{
+                type: Input
+            }], animationEasingUpdate: [{
+                type: Input
+            }], animationDelayUpdate: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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