@covalent/echarts 4.0.0 → 4.1.0-develop.10

package/esm2020/base/base.module.mjs

@@ -0,0 +1,35 @@
+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 {
+}
+CovalentBaseEchartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBaseEchartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentBaseEchartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.2", 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: "13.2.2", ngImport: i0, type: CovalentBaseEchartsModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBaseEchartsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [BASE_MODULE_COMPONENTS],
+                    exports: [BASE_MODULE_COMPONENTS],
+                }]
+        }] });
+//# 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();
+    }
+}
+TdChartOptionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdChartOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TdChartOptionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdChartOptionsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", 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 {
+    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);
+    }
+}
+TdChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdChartComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", 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: "13.2.2", 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/covalent-echarts-base.mjs

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

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: "13.2.2", ngImport: i0, type: TdDatasetComponent, deps: [{ token: i1.TdChartOptionsService }], target: i0.ɵɵFactoryTarget.Component });
+TdDatasetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", 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: "13.2.2", 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/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,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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 {
+    constructor(type, optionsService) {
+        this.optionsService = optionsService;
+        this._state = {};
+        this._options = {};
+        this.config = {};
+        this._type = type;
+    }
+    get type() {
+        return this._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: "13.2.2", ngImport: i0, type: TdSeriesDirective, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+TdSeriesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", 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: "13.2.2", 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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

package/esm2020/base/series/series.interface.mjs

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