@covalent/echarts 6.3.0 → 7.0.0

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

@@ -0,0 +1,56 @@
+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 {
+    position;
+    constructor(_optionsService) {
+        super('yAxis', _optionsService);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdChartYAxisComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", 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: "16.1.7", 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/{esm2020 → esm2022}/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] });
 }
-CovalentBaseEchartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: CovalentBaseEchartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CovalentBaseEchartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.5", 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.5", ngImport: i0, type: CovalentBaseEchartsModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: CovalentBaseEchartsModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBaseEchartsModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule],
@@ -32,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImpor
                     exports: [BASE_MODULE_COMPONENTS],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TdChartOptionsService {
+    _options = {};
+    _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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdChartOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdChartOptionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", 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/esm2022/base/chart.component.mjs

@@ -0,0 +1,211 @@
+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 {
+    _changeDetectorRef;
+    _elementRef;
+    _optionsService;
+    _destroy = new Subject();
+    _widthSubject = new Subject();
+    _heightSubject = new Subject();
+    _instance;
+    /**
+     * returns the echarts instance
+     */
+    get instance() {
+        return this._instance;
+    }
+    _state = {};
+    _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
+     */
+    config = {};
+    /**
+     * group?: string
+     * group name in which the chart instance will be connected to
+     * https://ecomfe.github.io/echarts-doc/public/en/api.html#echarts.connect
+     */
+    group;
+    /**
+     * themeName?: string
+     * theme to be applied into chart instance
+     * https://ecomfe.github.io/echarts-doc/public/en/tutorial.html#Overview%20of%20Style%20Customization
+     */
+    themeName;
+    /**
+     * 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
+     */
+    renderer = 'canvas';
+    chartClick = new EventEmitter();
+    chartDblclick = new EventEmitter();
+    chartContextmenu = new EventEmitter();
+    magicTypeChanged = new EventEmitter();
+    dataViewChanged = new EventEmitter();
+    datazoom = new EventEmitter();
+    restore = new EventEmitter();
+    constructor(_changeDetectorRef, _elementRef, _optionsService) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._elementRef = _elementRef;
+        this._optionsService = _optionsService;
+    }
+    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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdChartComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", 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: "16.1.7", 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/esm2022/base/dataset/dataset.component.mjs

@@ -0,0 +1,57 @@
+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 {
+    _optionsService;
+    _state = {};
+    id;
+    config = {};
+    source;
+    dimensions;
+    sourceHeader;
+    constructor(_optionsService) {
+        this._optionsService = _optionsService;
+    }
+    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');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdDatasetComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", 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: "16.1.7", 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/esm2022/base/series/series.component.mjs

@@ -0,0 +1,106 @@
+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 {
+    optionsService;
+    _type;
+    get type() {
+        return this._type;
+    }
+    _state = {};
+    _options = {};
+    config = {};
+    id;
+    name;
+    color;
+    data;
+    animation;
+    animationThreshold;
+    animationDuration;
+    animationEasing;
+    animationDelay;
+    animationDurationUpdate;
+    animationEasingUpdate;
+    animationDelayUpdate;
+    tooltip;
+    constructor(type, optionsService) {
+        this.optionsService = optionsService;
+        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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdSeriesDirective, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", 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: "16.1.7", 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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