@covalent/echarts
Version:
Teradata Charts built on echarts
1,991 lines • 82.5 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/operators'), require('echarts/lib/echarts'), require('rxjs'), require('zrender/lib/svg/svg'), require('echarts/lib/chart/bar'), require('echarts/lib/chart/line'), require('echarts/lib/chart/scatter'), require('echarts/lib/chart/tree'), require('echarts/lib/component/tooltip'), require('@angular/common'), require('echarts/lib/component/toolbox'), require('@angular/core'), require('@covalent/echarts/base')) :
typeof define === 'function' && define.amd ? define('@covalent/echarts', ['exports', 'rxjs/operators', 'echarts/lib/echarts', 'rxjs', 'zrender/lib/svg/svg', 'echarts/lib/chart/bar', 'echarts/lib/chart/line', 'echarts/lib/chart/scatter', 'echarts/lib/chart/tree', 'echarts/lib/component/tooltip', '@angular/common', 'echarts/lib/component/toolbox', '@angular/core', '@covalent/echarts/base'], factory) :
(factory((global.covalent = global.covalent || {}, global.covalent.echarts = {}),global.rxjs.operators,global.echarts,global.rxjs,null,null,null,null,null,null,global.ng.common,null,global.ng.core,global.covalent.echarts.base));
}(this, (function (exports,operators,echarts,rxjs,svg,bar,line,scatter,tree,tooltip,common,toolbox,core,base) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartOptionsService = /** @class */ (function () {
function TdChartOptionsService() {
this._options = {};
this._optionsSubject = new rxjs.BehaviorSubject(this._options);
}
/**
* @param {?} option
* @param {?} value
* @return {?}
*/
TdChartOptionsService.prototype.setOption = /**
* @param {?} option
* @param {?} value
* @return {?}
*/
function (option, value) {
/** @type {?} */
var options = {};
options[option] = value;
Object.assign(this._options, options);
this._optionsSubject.next(this._options);
};
/**
* @param {?} option
* @param {?} value
* @return {?}
*/
TdChartOptionsService.prototype.setArrayOption = /**
* @param {?} option
* @param {?} value
* @return {?}
*/
function (option, value) {
/** @type {?} */
var prevValue = this.getOption(option);
if (prevValue) {
/** @type {?} */
var index = prevValue.indexOf(value);
index > -1 ? prevValue[index] = value : prevValue.push(value);
}
else {
prevValue = [value];
}
this.setOption(option, prevValue);
};
/**
* @param {?} option
* @param {?} value
* @return {?}
*/
TdChartOptionsService.prototype.removeArrayOption = /**
* @param {?} option
* @param {?} value
* @return {?}
*/
function (option, value) {
/** @type {?} */
var prevValue = this.getOption(option);
if (prevValue) {
/** @type {?} */
var index = prevValue.indexOf(value);
if (index > -1) {
/* tslint:disable-next-line */
prevValue[index] = null;
}
else {
prevValue = [];
}
}
this.setOption(option, prevValue);
};
/**
* @param {?} option
* @return {?}
*/
TdChartOptionsService.prototype.getOption = /**
* @param {?} option
* @return {?}
*/
function (option) {
return this._options[option];
};
/**
* @param {?} option
* @return {?}
*/
TdChartOptionsService.prototype.clearOption = /**
* @param {?} option
* @return {?}
*/
function (option) {
/* tslint:disable-next-line */
this.setOption(option, null);
};
/**
* @return {?}
*/
TdChartOptionsService.prototype.listen = /**
* @return {?}
*/
function () {
return this._optionsSubject.asObservable();
};
TdChartOptionsService.decorators = [
{ type: core.Injectable }
];
return TdChartOptionsService;
}());
/**
* @param {?} parent
* @return {?}
*/
function CHART_PROVIDER_FACTORY(parent) {
return parent || new TdChartOptionsService();
}
/** @type {?} */
var CHART_PROVIDER = {
// If there is already a service available, use that. Otherwise, provide a new one.
provide: TdChartOptionsService,
deps: [[new core.Optional(), new core.SkipSelf(), TdChartOptionsService]],
useFactory: CHART_PROVIDER_FACTORY,
};
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (b.hasOwnProperty(p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m)
return m.call(o);
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @param {?} target
* @param {...?} sources
* @return {?}
*/
function assignDefined(target) {
var sources = [];
for (var _i = 1; _i < arguments.length; _i++) {
sources[_i - 1] = arguments[_i];
}
var e_1, _a, e_2, _b, e_3, _c;
/** @type {?} */
var keys = new Set();
try {
for (var sources_1 = __values(sources), sources_1_1 = sources_1.next(); !sources_1_1.done; sources_1_1 = sources_1.next()) {
var source = sources_1_1.value;
try {
for (var _d = __values(Object.keys(source)), _e = _d.next(); !_e.done; _e = _d.next()) {
var key = _e.value;
keys.add(key);
/** @type {?} */
var val = source[key];
/* tslint:disable-next-line */
if (val !== undefined && val !== null) {
target[key] = val;
/* tslint:disable-next-line */
}
else if (val === null) {
delete target[key];
}
}
}
catch (e_2_1) {
e_2 = { error: e_2_1 };
}
finally {
try {
if (_e && !_e.done && (_b = _d.return))
_b.call(_d);
}
finally {
if (e_2)
throw e_2.error;
}
}
}
}
catch (e_1_1) {
e_1 = { error: e_1_1 };
}
finally {
try {
if (sources_1_1 && !sources_1_1.done && (_a = sources_1.return))
_a.call(sources_1);
}
finally {
if (e_1)
throw e_1.error;
}
}
try {
// delete keys that are not in any source
for (var _f = __values(Object.keys(target)), _g = _f.next(); !_g.done; _g = _f.next()) {
var key = _g.value;
if (!keys.has(key)) {
delete target[key];
}
}
}
catch (e_3_1) {
e_3 = { error: e_3_1 };
}
finally {
try {
if (_g && !_g.done && (_c = _f.return))
_c.call(_f);
}
finally {
if (e_3)
throw e_3.error;
}
}
return target;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartComponent = /** @class */ (function () {
function TdChartComponent(_changeDetectorRef, _elementRef, _optionsService) {
this._changeDetectorRef = _changeDetectorRef;
this._elementRef = _elementRef;
this._optionsService = _optionsService;
this._destroy = new rxjs.Subject();
this._widthSubject = new rxjs.Subject();
this._heightSubject = new rxjs.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 core.EventEmitter();
this.chartDblclick = new core.EventEmitter();
this.chartContextmenu = new core.EventEmitter();
this.magicTypeChanged = new core.EventEmitter();
this.dataViewChanged = new core.EventEmitter();
this.datazoom = new core.EventEmitter();
this.restore = new core.EventEmitter();
}
Object.defineProperty(TdChartComponent.prototype, "instance", {
/**
* returns the echarts instance
*/
get: /**
* returns the echarts instance
* @return {?}
*/ function () {
return this._instance;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
TdChartComponent.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
this._initializeChart();
};
/**
* @param {?} changes
* @return {?}
*/
TdChartComponent.prototype.ngOnChanges = /**
* @param {?} changes
* @return {?}
*/
function (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();
}
}
};
/**
* @return {?}
*/
TdChartComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._disposeChart();
this._destroy.unsubscribe();
};
/**
* @return {?}
*/
TdChartComponent.prototype.render = /**
* @return {?}
*/
function () {
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,
borderColor: '#FCFCFC',
},
}, this._options, this.config ? this.config : {}), true);
this._changeDetectorRef.markForCheck();
}
};
/**
* @return {?}
*/
TdChartComponent.prototype._initializeChart = /**
* @return {?}
*/
function () {
var _this = this;
this._instance = echarts.init(this._elementRef.nativeElement, this.themeName, {
renderer: this.renderer,
});
rxjs.fromEvent(this._instance, 'click').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.chartClick.next(params);
});
rxjs.fromEvent(this._instance, 'dblclick').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.chartDblclick.next(params);
});
rxjs.fromEvent(this._instance, 'contextmenu').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.chartContextmenu.next(params);
});
rxjs.fromEvent(this._instance, 'magictypechanged').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.magicTypeChanged.next(params);
});
rxjs.fromEvent(this._instance, 'dataviewchanged').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.dataViewChanged.next(params);
});
rxjs.fromEvent(this._instance, 'datazoom').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.datazoom.next(params);
});
rxjs.fromEvent(this._instance, 'restore').pipe(operators.takeUntil(this._destroy)).subscribe(function (params) {
_this.restore.next(params);
});
if (this.group) {
this._instance.group = this.group;
echarts.connect(this.group);
this._changeDetectorRef.markForCheck();
}
rxjs.merge(rxjs.fromEvent(window, 'resize').pipe(operators.debounceTime(100)), this._widthSubject.asObservable().pipe(operators.distinctUntilChanged()), this._heightSubject.asObservable().pipe(operators.distinctUntilChanged())).pipe(operators.takeUntil(this._destroy), operators.debounceTime(100)).subscribe(function () {
if (_this._instance) {
_this._instance.resize();
_this._changeDetectorRef.markForCheck();
}
});
this._optionsService.listen().pipe(operators.tap(function (options) {
assignDefined(_this._options, options);
}), operators.debounceTime(0), operators.takeUntil(this._destroy)).subscribe(function () {
_this.render();
});
rxjs.timer(500, 250).pipe(operators.takeUntil(this._destroy)).subscribe(function () {
if (_this._elementRef && _this._elementRef.nativeElement) {
_this._widthSubject.next((( /** @type {?} */(_this._elementRef.nativeElement))).getBoundingClientRect().width);
_this._heightSubject.next((( /** @type {?} */(_this._elementRef.nativeElement))).getBoundingClientRect().height);
}
});
};
/**
* @return {?}
*/
TdChartComponent.prototype._disposeChart = /**
* @return {?}
*/
function () {
if (this._instance) {
this._instance.clear();
echarts.dispose(this._instance);
}
this._destroy.next(true);
};
TdChartComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush,
providers: [CHART_PROVIDER],
styles: [":host{display:block;width:100%}"]
}] }
];
/** @nocollapse */
TdChartComponent.ctorParameters = function () {
return [
{ type: core.ChangeDetectorRef },
{ type: core.ElementRef },
{ type: TdChartOptionsService }
];
};
TdChartComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
group: [{ type: core.Input, args: ['group',] }],
themeName: [{ type: core.Input, args: ['themeName',] }],
renderer: [{ type: core.Input, args: ['renderer',] }],
chartClick: [{ type: core.Output, args: ['chartClick',] }],
chartDblclick: [{ type: core.Output, args: ['chartDblclick',] }],
chartContextmenu: [{ type: core.Output, args: ['chartContextmenu',] }],
magicTypeChanged: [{ type: core.Output, args: ['magicTypeChanged',] }],
dataViewChanged: [{ type: core.Output, args: ['dataViewChanged',] }],
datazoom: [{ type: core.Output, args: ['datazoom',] }],
restore: [{ type: core.Output, args: ['restore',] }]
};
return TdChartComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @abstract
*/
var TdChartAxisComponent = /** @class */ (function () {
function TdChartAxisComponent(_axisOption, _optionsService) {
this._axisOption = _axisOption;
this._optionsService = _optionsService;
this._state = {
axisLine: {
lineStyle: {
color: '#ABABAB',
},
},
splitLine: {
lineStyle: {
color: '#ABABAB',
},
},
};
this.config = {};
this.show = true;
}
/**
* @return {?}
*/
TdChartAxisComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdChartAxisComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdChartAxisComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._removeOption();
};
/**
* @return {?}
*/
TdChartAxisComponent.prototype._setOptions = /**
* @return {?}
*/
function () {
/** @type {?} */
var config = assignDefined(this._state, {
id: this.id,
show: this.show,
gridIndex: this.gridIndex,
position: this.position,
offset: this.offset,
type: this.type,
name: this.name,
nameLocation: this.nameLocation,
nameTextStyle: this.nameTextStyle,
nameGap: this.nameGap,
nameRotate: this.nameRotate,
inverse: this.inverse,
boundaryGap: this.boundaryGap,
min: this.min,
max: this.max,
scale: this.scale,
minInterval: this.minInterval,
interval: this.interval,
logBase: this.logBase,
silent: this.silent,
triggerEvent: this.triggerEvent,
axisLine: this.axisLine,
axisTick: this.axisTick,
axisLabel: this.axisLabel,
splitLine: this.splitLine,
splitArea: this.splitArea,
data: this.data,
axisPointer: this.axisPointer,
zlevel: this.zlevel,
z: this.z,
}, this.config ? this.config : {});
this._optionsService.setArrayOption(this._axisOption, config);
};
/**
* @return {?}
*/
TdChartAxisComponent.prototype._removeOption = /**
* @return {?}
*/
function () {
this._optionsService.clearOption(this._axisOption);
};
TdChartAxisComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
id: [{ type: core.Input, args: ['id',] }],
show: [{ type: core.Input, args: ['show',] }],
gridIndex: [{ type: core.Input, args: ['gridIndex',] }],
offset: [{ type: core.Input, args: ['offset',] }],
type: [{ type: core.Input, args: ['type',] }],
name: [{ type: core.Input, args: ['name',] }],
nameLocation: [{ type: core.Input, args: ['nameLocation',] }],
nameTextStyle: [{ type: core.Input, args: ['nameTextStyle',] }],
nameGap: [{ type: core.Input, args: ['nameGap',] }],
nameRotate: [{ type: core.Input, args: ['nameRotate',] }],
inverse: [{ type: core.Input, args: ['inverse',] }],
boundaryGap: [{ type: core.Input, args: ['boundaryGap',] }],
min: [{ type: core.Input, args: ['min',] }],
max: [{ type: core.Input, args: ['max',] }],
scale: [{ type: core.Input, args: ['scale',] }],
minInterval: [{ type: core.Input, args: ['minInterval',] }],
interval: [{ type: core.Input, args: ['interval',] }],
logBase: [{ type: core.Input, args: ['logBase',] }],
silent: [{ type: core.Input, args: ['silent',] }],
triggerEvent: [{ type: core.Input, args: ['triggerEvent',] }],
axisLine: [{ type: core.Input, args: ['axisLine',] }],
axisTick: [{ type: core.Input, args: ['axisTick',] }],
axisLabel: [{ type: core.Input, args: ['axisLabel',] }],
splitLine: [{ type: core.Input, args: ['splitLine',] }],
splitArea: [{ type: core.Input, args: ['splitArea',] }],
data: [{ type: core.Input, args: ['data',] }],
axisPointer: [{ type: core.Input, args: ['axisPointer',] }],
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }]
};
return TdChartAxisComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartXAxisComponent = /** @class */ (function (_super) {
__extends(TdChartXAxisComponent, _super);
function TdChartXAxisComponent(_optionsService) {
return _super.call(this, 'xAxis', _optionsService) || this;
}
TdChartXAxisComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-x-axis',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
TdChartXAxisComponent.ctorParameters = function () {
return [
{ type: TdChartOptionsService }
];
};
TdChartXAxisComponent.propDecorators = {
position: [{ type: core.Input, args: ['position',] }]
};
return TdChartXAxisComponent;
}(TdChartAxisComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartYAxisComponent = /** @class */ (function (_super) {
__extends(TdChartYAxisComponent, _super);
function TdChartYAxisComponent(_optionsService) {
return _super.call(this, 'yAxis', _optionsService) || this;
}
TdChartYAxisComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-y-axis',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
TdChartYAxisComponent.ctorParameters = function () {
return [
{ type: TdChartOptionsService }
];
};
TdChartYAxisComponent.propDecorators = {
position: [{ type: core.Input, args: ['position',] }]
};
return TdChartYAxisComponent;
}(TdChartAxisComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var BASE_MODULE_COMPONENTS = [
TdChartComponent,
TdChartXAxisComponent,
TdChartYAxisComponent,
];
var CovalentBaseEchartsModule = /** @class */ (function () {
function CovalentBaseEchartsModule() {
}
CovalentBaseEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
BASE_MODULE_COMPONENTS,
],
exports: [
BASE_MODULE_COMPONENTS,
],
},] }
];
return CovalentBaseEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @abstract
* @template T
*/
var TdSeriesComponent = /** @class */ (function () {
function TdSeriesComponent(type, optionsService) {
this.optionsService = optionsService;
this._state = {};
this._options = {};
this.config = {};
this._type = type;
}
Object.defineProperty(TdSeriesComponent.prototype, "type", {
get: /**
* @return {?}
*/ function () {
return this._type;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
TdSeriesComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdSeriesComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdSeriesComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._removeOption();
};
/**
* @param {?} option
* @param {?} value
* @return {?}
*/
TdSeriesComponent.prototype.setStateOption = /**
* @param {?} option
* @param {?} value
* @return {?}
*/
function (option, value) {
this._options[option] = value;
this._setOptions();
};
/**
* @param {?} option
* @return {?}
*/
TdSeriesComponent.prototype.removeStateOption = /**
* @param {?} option
* @return {?}
*/
function (option) {
/* tslint:disable-next-line */
this._options[option] = null;
this._setOptions();
};
/**
* @return {?}
*/
TdSeriesComponent.prototype._setOptions = /**
* @return {?}
*/
function () {
/** @type {?} */
var 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);
};
/**
* @return {?}
*/
TdSeriesComponent.prototype._removeOption = /**
* @return {?}
*/
function () {
this.optionsService.removeArrayOption('series', this._state);
};
TdSeriesComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
id: [{ type: core.Input, args: ['id',] }],
name: [{ type: core.Input, args: ['name',] }],
color: [{ type: core.Input, args: ['color',] }],
data: [{ type: core.Input, args: ['data',] }],
animation: [{ type: core.Input, args: ['animation',] }],
animationThreshold: [{ type: core.Input, args: ['animationThreshold',] }],
animationDuration: [{ type: core.Input, args: ['animationDuration',] }],
animationEasing: [{ type: core.Input, args: ['animationEasing',] }],
animationDelay: [{ type: core.Input, args: ['animationDelay',] }],
animationDurationUpdate: [{ type: core.Input, args: ['animationDurationUpdate',] }],
animationEasingUpdate: [{ type: core.Input, args: ['animationEasingUpdate',] }],
animationDelayUpdate: [{ type: core.Input, args: ['animationDelayUpdate',] }],
tooltip: [{ type: core.Input, args: ['tooltip',] }]
};
return TdSeriesComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartSeriesBarComponent = /** @class */ (function (_super) {
__extends(TdChartSeriesBarComponent, _super);
function TdChartSeriesBarComponent(_optionsService) {
return _super.call(this, 'bar', _optionsService) || this;
}
/**
* @return {?}
*/
TdChartSeriesBarComponent.prototype.getConfig = /**
* @return {?}
*/
function () {
return {
coordinateSystem: this.coordinateSystem,
xAxisIndex: this.xAxisIndex,
yAxisIndex: this.yAxisIndex,
legendHoverLink: this.legendHoverLink,
stack: this.stack,
cursor: this.cursor,
label: this.label,
itemStyle: this.itemStyle,
emphasis: this.emphasis,
barWidth: this.barWidth,
barMaxWidth: this.barMaxWidth,
barMinHeight: this.barMinHeight,
barGap: this.barGap,
barCategoryGap: this.barCategoryGap,
large: this.large,
largeThreshold: this.largeThreshold,
progressive: this.progressive,
progressiveThreshold: this.progressiveThreshold,
progressiveChunkMode: this.progressiveChunkMode,
dimensions: this.dimensions,
encode: this.encode,
seriesLayoutBy: this.seriesLayoutBy,
datasetIndex: this.datasetIndex,
markPoint: this.markPoint,
markLine: this.markLine,
markArea: this.markArea,
zlevel: this.zlevel,
z: this.z,
};
};
TdChartSeriesBarComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-series[td-bar]',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush,
providers: [{
provide: base.TdSeriesComponent, useExisting: core.forwardRef(function () { return TdChartSeriesBarComponent; }),
}]
}] }
];
/** @nocollapse */
TdChartSeriesBarComponent.ctorParameters = function () {
return [
{ type: base.TdChartOptionsService }
];
};
TdChartSeriesBarComponent.propDecorators = {
coordinateSystem: [{ type: core.Input, args: ['coordinateSystem',] }],
xAxisIndex: [{ type: core.Input, args: ['xAxisIndex',] }],
yAxisIndex: [{ type: core.Input, args: ['yAxisIndex',] }],
legendHoverLink: [{ type: core.Input, args: ['legendHoverLink',] }],
stack: [{ type: core.Input, args: ['stack',] }],
cursor: [{ type: core.Input, args: ['cursor',] }],
label: [{ type: core.Input, args: ['label',] }],
itemStyle: [{ type: core.Input, args: ['itemStyle',] }],
emphasis: [{ type: core.Input, args: ['emphasis',] }],
barWidth: [{ type: core.Input, args: ['barWidth',] }],
barMaxWidth: [{ type: core.Input, args: ['barMaxWidth',] }],
barMinHeight: [{ type: core.Input, args: ['barMinHeight',] }],
barGap: [{ type: core.Input, args: ['barGap',] }],
barCategoryGap: [{ type: core.Input, args: ['barCategoryGap',] }],
large: [{ type: core.Input, args: ['large',] }],
largeThreshold: [{ type: core.Input, args: ['largeThreshold',] }],
progressive: [{ type: core.Input, args: ['progressive',] }],
progressiveThreshold: [{ type: core.Input, args: ['progressiveThreshold',] }],
progressiveChunkMode: [{ type: core.Input, args: ['progressiveChunkMode',] }],
dimensions: [{ type: core.Input, args: ['dimensions',] }],
encode: [{ type: core.Input, args: ['encode',] }],
seriesLayoutBy: [{ type: core.Input, args: ['seriesLayoutBy',] }],
datasetIndex: [{ type: core.Input, args: ['datasetIndex',] }],
markPoint: [{ type: core.Input, args: ['markPoint',] }],
markLine: [{ type: core.Input, args: ['markLine',] }],
markArea: [{ type: core.Input, args: ['markArea',] }],
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }]
};
return TdChartSeriesBarComponent;
}(base.TdSeriesComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var BAR_MODULE_COMPONENTS = [
TdChartSeriesBarComponent,
];
var CovalentBarEchartsModule = /** @class */ (function () {
function CovalentBarEchartsModule() {
}
CovalentBarEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
BAR_MODULE_COMPONENTS,
],
exports: [
BAR_MODULE_COMPONENTS,
],
},] }
];
return CovalentBarEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartSeriesLineComponent = /** @class */ (function (_super) {
__extends(TdChartSeriesLineComponent, _super);
function TdChartSeriesLineComponent(_optionsService) {
return _super.call(this, 'line', _optionsService) || this;
}
/**
* @return {?}
*/
TdChartSeriesLineComponent.prototype.getConfig = /**
* @return {?}
*/
function () {
return {
coordinateSystem: this.coordinateSystem,
xAxisIndex: this.xAxisIndex,
yAxisIndex: this.yAxisIndex,
polarIndex: this.polarIndex,
symbol: this.symbol,
symbolSize: this.symbolSize,
symbolRotate: this.symbolRotate,
symbolKeepAspect: this.symbolKeepAspect,
symbolOffset: this.symbolOffset,
showSymbol: this.showSymbol,
showAllSymbol: this.showAllSymbol,
hoverAnimation: this.hoverAnimation,
legendHoverLink: this.legendHoverLink,
stack: this.stack,
cursor: this.cursor,
connectNulls: this.connectNulls,
clipOverflow: this.clipOverflow,
step: this.step,
label: this.label,
itemStyle: this.itemStyle,
lineStyle: this.lineStyle,
areaStyle: this.areaStyle,
emphasis: this.emphasis,
smooth: this.smooth,
smoothMonotone: this.smoothMonotone,
sampling: this.sampling,
dimensions: this.dimensions,
encode: this.encode,
seriesLayoutBy: this.seriesLayoutBy,
datasetIndex: this.datasetIndex,
markPoint: this.markPoint,
markLine: this.markLine,
markArea: this.markArea,
zlevel: this.zlevel,
z: this.z,
silent: this.silent,
};
};
TdChartSeriesLineComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-series[td-line]',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush,
providers: [{
provide: base.TdSeriesComponent, useExisting: core.forwardRef(function () { return TdChartSeriesLineComponent; }),
}]
}] }
];
/** @nocollapse */
TdChartSeriesLineComponent.ctorParameters = function () {
return [
{ type: base.TdChartOptionsService }
];
};
TdChartSeriesLineComponent.propDecorators = {
coordinateSystem: [{ type: core.Input, args: ['coordinateSystem',] }],
xAxisIndex: [{ type: core.Input, args: ['xAxisIndex',] }],
yAxisIndex: [{ type: core.Input, args: ['yAxisIndex',] }],
polarIndex: [{ type: core.Input, args: ['polarIndex',] }],
symbol: [{ type: core.Input, args: ['symbol',] }],
symbolSize: [{ type: core.Input, args: ['symbolSize',] }],
symbolRotate: [{ type: core.Input, args: ['symbolRotate',] }],
symbolKeepAspect: [{ type: core.Input, args: ['symbolKeepAspect',] }],
symbolOffset: [{ type: core.Input, args: ['symbolOffset',] }],
showSymbol: [{ type: core.Input, args: ['showSymbol',] }],
showAllSymbol: [{ type: core.Input, args: ['showAllSymbol',] }],
hoverAnimation: [{ type: core.Input, args: ['hoverAnimation',] }],
legendHoverLink: [{ type: core.Input, args: ['legendHoverLink',] }],
stack: [{ type: core.Input, args: ['stack',] }],
cursor: [{ type: core.Input, args: ['cursor',] }],
connectNulls: [{ type: core.Input, args: ['connectNulls',] }],
clipOverflow: [{ type: core.Input, args: ['clipOverflow',] }],
step: [{ type: core.Input, args: ['step',] }],
label: [{ type: core.Input, args: ['label',] }],
itemStyle: [{ type: core.Input, args: ['itemStyle',] }],
lineStyle: [{ type: core.Input, args: ['lineStyle',] }],
areaStyle: [{ type: core.Input, args: ['areaStyle',] }],
emphasis: [{ type: core.Input, args: ['emphasis',] }],
smooth: [{ type: core.Input, args: ['smooth',] }],
smoothMonotone: [{ type: core.Input, args: ['smoothMonotone',] }],
sampling: [{ type: core.Input, args: ['sampling',] }],
dimensions: [{ type: core.Input, args: ['dimensions',] }],
encode: [{ type: core.Input, args: ['encode',] }],
seriesLayoutBy: [{ type: core.Input, args: ['seriesLayoutBy',] }],
datasetIndex: [{ type: core.Input, args: ['datasetIndex',] }],
markPoint: [{ type: core.Input, args: ['markPoint',] }],
markLine: [{ type: core.Input, args: ['markLine',] }],
markArea: [{ type: core.Input, args: ['markArea',] }],
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }],
silent: [{ type: core.Input, args: ['silent',] }]
};
return TdChartSeriesLineComponent;
}(base.TdSeriesComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var LINE_MODULE_COMPONENTS = [
TdChartSeriesLineComponent,
];
var CovalentLineEchartsModule = /** @class */ (function () {
function CovalentLineEchartsModule() {
}
CovalentLineEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
LINE_MODULE_COMPONENTS,
],
exports: [
LINE_MODULE_COMPONENTS,
],
},] }
];
return CovalentLineEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartSeriesScatterComponent = /** @class */ (function (_super) {
__extends(TdChartSeriesScatterComponent, _super);
function TdChartSeriesScatterComponent(_optionsService) {
return _super.call(this, 'scatter', _optionsService) || this;
}
/**
* @return {?}
*/
TdChartSeriesScatterComponent.prototype.getConfig = /**
* @return {?}
*/
function () {
return {
coordinateSystem: this.coordinateSystem,
xAxisIndex: this.xAxisIndex,
yAxisIndex: this.yAxisIndex,
polarIndex: this.polarIndex,
geoIndex: this.geoIndex,
calendarIndex: this.calendarIndex,
hoverAnimation: this.hoverAnimation,
legendHoverLink: this.legendHoverLink,
symbol: this.symbol,
symbolSize: this.symbolSize,
symbolRotate: this.symbolRotate,
symbolKeepAspect: this.symbolKeepAspect,
symbolOffset: this.symbolOffset,
large: this.large,
largeThreshold: this.largeThreshold,
cursor: this.cursor,
label: this.label,
itemStyle: this.itemStyle,
emphasis: this.emphasis,
progressive: this.progressive,
progressiveThreshold: this.progressiveThreshold,
dimensions: this.dimensions,
encode: this.encode,
seriesLayoutBy: this.seriesLayoutBy,
datasetIndex: this.datasetIndex,
markPoint: this.markPoint,
markLine: this.markLine,
markArea: this.markArea,
zlevel: this.zlevel,
z: this.z,
silent: this.silent,
};
};
TdChartSeriesScatterComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-series[td-scatter]',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush,
providers: [{
provide: base.TdSeriesComponent, useExisting: core.forwardRef(function () { return TdChartSeriesScatterComponent; }),
}]
}] }
];
/** @nocollapse */
TdChartSeriesScatterComponent.ctorParameters = function () {
return [
{ type: base.TdChartOptionsService }
];
};
TdChartSeriesScatterComponent.propDecorators = {
coordinateSystem: [{ type: core.Input, args: ['coordinateSystem',] }],
xAxisIndex: [{ type: core.Input, args: ['xAxisIndex',] }],
yAxisIndex: [{ type: core.Input, args: ['yAxisIndex',] }],
polarIndex: [{ type: core.Input, args: ['polarIndex',] }],
geoIndex: [{ type: core.Input, args: ['geoIndex',] }],
calendarIndex: [{ type: core.Input, args: ['calendarIndex',] }],
hoverAnimation: [{ type: core.Input, args: ['hoverAnimation',] }],
legendHoverLink: [{ type: core.Input, args: ['legendHoverLink',] }],
symbol: [{ type: core.Input, args: ['symbol',] }],
symbolSize: [{ type: core.Input, args: ['symbolSize',] }],
symbolRotate: [{ type: core.Input, args: ['symbolRotate',] }],
symbolKeepAspect: [{ type: core.Input, args: ['symbolKeepAspect',] }],
symbolOffset: [{ type: core.Input, args: ['symbolOffset',] }],
large: [{ type: core.Input, args: ['large',] }],
largeThreshold: [{ type: core.Input, args: ['largeThreshold',] }],
cursor: [{ type: core.Input, args: ['cursor',] }],
label: [{ type: core.Input, args: ['label',] }],
itemStyle: [{ type: core.Input, args: ['itemStyle',] }],
emphasis: [{ type: core.Input, args: ['emphasis',] }],
progressive: [{ type: core.Input, args: ['progressive',] }],
progressiveThreshold: [{ type: core.Input, args: ['progressiveThreshold',] }],
dimensions: [{ type: core.Input, args: ['dimensions',] }],
encode: [{ type: core.Input, args: ['encode',] }],
seriesLayoutBy: [{ type: core.Input, args: ['seriesLayoutBy',] }],
datasetIndex: [{ type: core.Input, args: ['datasetIndex',] }],
markPoint: [{ type: core.Input, args: ['markPoint',] }],
markLine: [{ type: core.Input, args: ['markLine',] }],
markArea: [{ type: core.Input, args: ['markArea',] }],
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }],
silent: [{ type: core.Input, args: ['silent',] }]
};
return TdChartSeriesScatterComponent;
}(base.TdSeriesComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var SCATTER_MODULE_COMPONENTS = [
TdChartSeriesScatterComponent,
];
var CovalentScatterEchartsModule = /** @class */ (function () {
function CovalentScatterEchartsModule() {
}
CovalentScatterEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
SCATTER_MODULE_COMPONENTS,
],
exports: [
SCATTER_MODULE_COMPONENTS,
],
},] }
];
return CovalentScatterEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartSeriesTreeComponent = /** @class */ (function (_super) {
__extends(TdChartSeriesTreeComponent, _super);
function TdChartSeriesTreeComponent(_optionsService) {
return _super.call(this, 'tree', _optionsService) || this;
}
/**
* @return {?}
*/
TdChartSeriesTreeComponent.prototype.getConfig = /**
* @return {?}
*/
function () {
return {
zlevel: this.zlevel,
z: this.z,
left: this.left,
top: this.top,
right: this.right,
bottom: this.bottom,
width: this.width,
height: this.height,
layout: this.layout,
orient: this.orient,
symbol: this.symbol,
symbolSize: this.symbolSize,
symbolRotate: this.symbolRotate,
symbolKeepAspect: this.symbolKeepAspect,
roam: this.roam,
expandAndCollapse: this.expandAndCollapse,
initialTreeDepth: this.initialTreeDepth,
itemStyle: this.itemStyle,
label: this.label,
lineStyle: this.lineStyle,
leaves: this.leaves,
emphasis: this.emphasis,
};
};
TdChartSeriesTreeComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-series[td-tree]',
template: '',
changeDetection: core.ChangeDetectionStrategy.OnPush,
providers: [{
provide: base.TdSeriesComponent, useExisting: core.forwardRef(function () { return TdChartSeriesTreeComponent; }),
}]
}] }
];
/** @nocollapse */
TdChartSeriesTreeComponent.ctorParameters = function () {
return [
{ type: base.TdChartOptionsService }
];
};
TdChartSeriesTreeComponent.propDecorators = {
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }],
left: [{ type: core.Input, args: ['left',] }],
top: [{ type: core.Input, args: ['top',] }],
right: [{ type: core.Input, args: ['right',] }],
bottom: [{ type: core.Input, args: ['bottom',] }],
width: [{ type: core.Input, args: ['width',] }],
height: [{ type: core.Input, args: ['height',] }],
layout: [{ type: core.Input, args: ['layout',] }],
orient: [{ type: core.Input, args: ['orient',] }],
symbol: [{ type: core.Input, args: ['symbol',] }],
symbolSize: [{ type: core.Input, args: ['symbolSize',] }],
symbolRotate: [{ type: core.Input, args: ['symbolRotate',] }],
symbolKeepAspect: [{ type: core.Input, args: ['symbolKeepAspect',] }],
roam: [{ type: core.Input, args: ['roam',] }],
expandAndCollapse: [{ type: core.Input, args: ['expandAndCollapse',] }],
initialTreeDepth: [{ type: core.Input, args: ['initialTreeDepth',] }],
itemStyle: [{ type: core.Input, args: ['itemStyle',] }],
label: [{ type: core.Input, args: ['label',] }],
lineStyle: [{ type: core.Input, args: ['lineStyle',] }],
leaves: [{ type: core.Input, args: ['leaves',] }],
emphasis: [{ type: core.Input, args: ['emphasis',] }]
};
return TdChartSeriesTreeComponent;
}(base.TdSeriesComponent));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var TREE_MODULE_COMPONENTS = [
TdChartSeriesTreeComponent,
];
var CovalentTreeEchartsModule = /** @class */ (function () {
function CovalentTreeEchartsModule() {
}
CovalentTreeEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
TREE_MODULE_COMPONENTS,
],
exports: [
TREE_MODULE_COMPONENTS,
],
},] }
];
return CovalentTreeEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdTooltipContext = /** @class */ (function () {
function TdTooltipContext() {
}
return TdTooltipContext;
}());
var TdChartTooltipFormatterDirective = /** @class */ (function () {
function TdChartTooltipFormatterDirective() {
}
TdChartTooltipFormatterDirective.decorators = [
{ type: core.Directive, args: [{
selector: 'ng-template[tdTooltipFormatter]',
},] }
];
return TdChartTooltipFormatterDirective;
}());
var TdChartTooltipComponent = /** @class */ (function () {
function TdChartTooltipComponent(_changeDetectorRef, _elementRef, _optionsService) {
this._changeDetectorRef = _changeDetectorRef;
this._elementRef = _elementRef;
this._optionsService = _optionsService;
this._state = {};
this._context = new TdTooltipContext();
this.config = {};
this.show = true;
this.trigger = 'axis';
this.showContent = true;
this.alwaysShowContent = false;
this.triggerOn = 'mousemove|click';
this.showDelay = 0;
this.hideDelay = 0;
this.enterable = false;
this.confine = false;
this.transitionDuration = 0.5;
// series
this.backgroundColor = 'rgba(50,50,50,0.7)'; // series
// series
this.borderColor = '#333'; // series
// series
this.borderWidth = 0; // series
// series
this.padding = 5; // series
// series
this.textStyle = {
// series
color: '#FFF',
};
}
/**
* @return {?}
*/
TdChartTooltipComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdChartTooltipComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._removeOption();
};
/**
* @return {?}
*/
TdChartTooltipComponent.prototype._setOptions = /**
* @return {?}
*/
function () {
/** @type {?} */
var config = base.assignDefined(this._state, {
show: this.show,
trigger: this.trigger,
axisPointer: this.axisPointer,
showContent: this.showContent,
alwaysShowContent: this.alwaysShowContent,
triggerOn: this.triggerOn,
showDelay: this.showDelay,
hideDelay: this.hideDelay,
enterable: this.enterable,
confine: this.confine,
transitionDuration: this.transitionDuration,
position: this.position,
formatter: this.formatter ? this.formatter : (this.formatterTemplate ? this._formatter() : undefined),
backgroundColor: this.backgroundColor,
borderColor: this.borderColor,
borderWidth: this.borderWidth,
padding: this.padding,
textStyle: this.textStyle,
extraCssText: this.extraCssText,
}, this.config ? this.config : {});
// set tooltip configuration in parent chart and render new configurations
this._optionsService.setOption('tooltip', config);
};
/**
* @return {?}
*/
TdChartTooltipComponent.prototype._removeOption = /**
* @return {?}
*/
function () {
this._optionsService.clearOption('tooltip');
};
/**
* @return {?}
*/
TdChartTooltipComponent.prototype._formatter = /**
* @return {?}
*/
function () {
var _this = this;
return function (params, ticket, callback) {
_this._context = {
$implicit: params,
ticket: ticket,
};
// timeout set since we need to set the HTML at the end of the angular lifecycle when
// the tooltip delay is more than 0
setTimeout(function () {
callback(ticket, (( /** @type {?} */(_this._elementRef.nativeElement))).innerHTML);
});
_this._changeDetectorRef.markForCheck();
return (( /** @type {?} */(_this._elementRef.nativeElement))).innerHTML;
};
};
TdChartTooltipComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-tooltip',
template: "<ng-template #tooltipContent\n [ngTemplateOutlet]=\"formatterTemplate\"\n [ngTemplateOutletContext]=\"_context\">\n</ng-template>",
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
TdChartTooltipComponent.ctorParameters = function () {
return [
{ type: core.ChangeDetectorRef },
{ type: core.ElementRef },
{ type: base.TdChartOptionsService }
];
};
TdChartTooltipComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
show: [{ type: core.Input, args: ['show',] }],
trigger: [{ type: core.Input, args: ['trigger',] }],
axisPointer: [{ type: core.Input, args: ['axisPointer',] }],
showContent: [{ type: core.Input, args: ['showContent',] }],
alwaysShowContent: [{ type: core.Input, args: ['alwaysShowContent',] }],
triggerOn: [{ type: core.Input, args: ['triggerOn',] }],
showDelay: [{ type: core.Input, args: ['showDelay',] }],
hideDelay: [{ type: core.Input, args: ['hideDelay',] }],
enterable: [{ type: core.Input, args: ['enterable',] }],
renderMode: [{ type: core.Input, args: ['renderMode',] }],
confine: [{ type: core.Input, args: ['confine',] }],
transitionDuration: [{ type: core.Input, args: ['transitionDuration',] }],
position: [{ type: core.Input, args: ['position',] }],
formatter: [{ type: core.Input, args: ['formatter',] }],
backgroundColor: [{ type: core.Input, args: ['backgroundColor',] }],
borderColor: [{ type: core.Input, args: ['borderColor',] }],
borderWidth: [{ type: core.Input, args: ['borderWidth',] }],
padding: [{ type: core.Input, args: ['padding',] }],
textStyle: [{ type: core.Input, args: ['textStyle',] }],
extraCssText: [{ type: core.Input, args: ['extraCssText',] }],
formatterTemplate: [{ type: core.ContentChild, args: [TdChartTooltipFormatterDirective, { read: core.TemplateRef },] }],
fullTemplate: [{ type: core.ViewChild, args: ['tooltipContent',] }]
};
return TdChartTooltipComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdSeriesTooltipComponent = /** @class */ (function () {
function TdSeriesTooltipComponent(_changeDetectorRef, _elementRef, _seriesComponent) {
this._changeDetectorRef = _changeDetectorRef;
this._elementRef = _elementRef;
this._seriesComponent = _seriesComponent;
this._state = {};
this._context = new TdTooltipContext();
this.backgroundColor = 'rgba(50,50,50,0.7)';
this.borderColor = '#333';
this.borderWidth = 0;
this.padding = 5;
this.textStyle = {
color: '#FFF',
};
}
/**
* @return {?}
*/
TdSeriesTooltipComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdSeriesTooltipComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._removeOption();
};
/**
* @return {?}
*/
TdSeriesTooltipComponent.prototype._setOptions = /**
* @return {?}
*/
function () {
/** @type {?} */
var config = base.assignDefined(this._state, {
position: this.position,
backgroundColor: this.backgroundColor,
borderColor: this.borderColor,
borderWidth: this.borderWidth,
padding: this.padding,
textStyle: this.textStyle,
extraCssText: this.extraCssText,
formatter: this.formatter ? this.formatter : (this.formatterTemplate ? this._formatter() : undefined),
}, this.config ? this.config : {});
// set series tooltip configuration in parent chart and render new configurations
this._seriesComponent.setStateOption('tooltip', config);
};
/**
* Formatter for tooltip
*
*/
/**
* Formatter for tooltip
*
* @return {?}
*/
TdSeriesTooltipComponent.prototype._formatter = /**
* Formatter for tooltip
*
* @return {?}
*/
function () {
var _this = this;
return function (params, ticket, callback) {
_this._context = {
$implicit: params,
ticket: ticket,
};
// timeout set since we need to set the HTML at the end of the angular lifecycle when
// the tooltip delay is more than 0
setTimeout(function () {
callback(ticket, (( /** @type {?} */(_this._elementRef.nativeElement))).innerHTML);
});
_this._changeDetectorRef.markForCheck();
return (( /** @type {?} */(_this._elementRef.nativeElement))).innerHTML;
};
};
/**
* @return {?}
*/
TdSeriesTooltipComponent.prototype._removeOption = /**
* @return {?}
*/
function () {
this._seriesComponent.removeStateOption('tooltip');
};
TdSeriesTooltipComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-series-tooltip',
template: "<ng-template #tooltipContent\n [ngTemplateOutlet]=\"formatterTemplate\"\n [ngTemplateOutletContext]=\"_context\">\n</ng-template>",
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
TdSeriesTooltipComponent.ctorParameters = function () {
return [
{ type: core.ChangeDetectorRef },
{ type: core.ElementRef },
{ type: base.TdSeriesComponent }
];
};
TdSeriesTooltipComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
formatter: [{ type: core.Input, args: ['formatter',] }],
position: [{ type: core.Input, args: ['position',] }],
backgroundColor: [{ type: core.Input, args: ['backgroundColor',] }],
borderColor: [{ type: core.Input, args: ['borderColor',] }],
borderWidth: [{ type: core.Input, args: ['borderWidth',] }],
padding: [{ type: core.Input, args: ['padding',] }],
textStyle: [{ type: core.Input, args: ['textStyle',] }],
extraCssText: [{ type: core.Input, args: ['extraCssText',] }],
formatterTemplate: [{ type: core.ContentChild, args: [TdChartTooltipFormatterDirective, { read: core.TemplateRef },] }],
fullTemplate: [{ type: core.ViewChild, args: ['tooltipContent',] }]
};
return TdSeriesTooltipComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var TOOLTIP_MODULE_COMPONENTS = [
TdChartTooltipComponent,
TdChartTooltipFormatterDirective,
TdSeriesTooltipComponent,
];
var CovalentTooltipEchartsModule = /** @class */ (function () {
function CovalentTooltipEchartsModule() {
}
CovalentTooltipEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
TOOLTIP_MODULE_COMPONENTS,
],
exports: [
TOOLTIP_MODULE_COMPONENTS,
],
},] }
];
return CovalentTooltipEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
var TdChartViewDataFormatterDirective = /** @class */ (function () {
function TdChartViewDataFormatterDirective() {
}
TdChartViewDataFormatterDirective.decorators = [
{ type: core.Directive, args: [{
selector: 'ng-template[tdViewDataFormatter]',
},] }
];
return TdChartViewDataFormatterDirective;
}());
var TdChartToolboxComponent = /** @class */ (function () {
function TdChartToolboxComponent(_changeDetectorRef, _elementRef, _optionsService) {
this._changeDetectorRef = _changeDetectorRef;
this._elementRef = _elementRef;
this._optionsService = _optionsService;
this._state = {};
this.config = {};
this.show = true;
this.showTitle = true;
this.transitionDuration = 0.5;
this.left = 'auto';
this.top = 'auto';
this.right = 'auto';
this.bottom = 'auto';
this.width = 'auto';
this.height = 'auto';
}
/**
* @return {?}
*/
TdChartToolboxComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
this._setOptions();
};
/**
* @return {?}
*/
TdChartToolboxComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._removeOption();
};
/**
* @return {?}
*/
TdChartToolboxComponent.prototype._setOptions = /**
* @return {?}
*/
function () {
this._checkFormatterTemplate();
/** @type {?} */
var config = base.assignDefined(this._state, {
show: this.show,
name: this.trigger,
orient: this.orient,
itemSize: this.itemSize,
itemGap: this.itemGap,
showTitle: this.showTitle,
label: this.label,
feature: this.feature,
iconStyle: this.iconStyle,
zlevel: this.zlevel,
z: this.z,
transitionDuration: this.transitionDuration,
left: this.left,
top: this.top,
right: this.right,
bottom: this.bottom,
width: this.width,
height: this.height,
}, this.config ? this.config : {});
// set toolbox configuration in parent chart and render new configurations
this._optionsService.setOption('toolbox', config);
};
/**
* @return {?}
*/
TdChartToolboxComponent.prototype._removeOption = /**
* @return {?}
*/
function () {
this._optionsService.clearOption('toolbox');
};
/**
* @return {?}
*/
TdChartToolboxComponent.prototype._checkFormatterTemplate = /**
* @return {?}
*/
function () {
if (this.formatterTemplate) {
this.feature = __assign({}, this.feature, { dataView: __assign({}, this.feature.dataView, { optionToContent: this._optionToContentFormatter() }) });
}
};
/**
* @return {?}
*/
TdChartToolboxComponent.prototype._optionToContentFormatter = /**
* @return {?}
*/
function () {
var _this = this;
return function () {
_this._changeDetectorRef.markForCheck();
return (( /** @type {?} */(_this._elementRef.nativeElement))).innerHTML;
};
};
TdChartToolboxComponent.decorators = [
{ type: core.Component, args: [{
selector: 'td-chart-toolbox',
template: "<ng-template #toolboxContent\n [ngTemplateOutlet]=\"formatterTemplate\">\n</ng-template>",
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
TdChartToolboxComponent.ctorParameters = function () {
return [
{ type: core.ChangeDetectorRef },
{ type: core.ElementRef },
{ type: base.TdChartOptionsService }
];
};
TdChartToolboxComponent.propDecorators = {
config: [{ type: core.Input, args: ['config',] }],
show: [{ type: core.Input, args: ['show',] }],
trigger: [{ type: core.Input, args: ['name',] }],
orient: [{ type: core.Input, args: ['orient',] }],
itemSize: [{ type: core.Input, args: ['itemSize',] }],
itemGap: [{ type: core.Input, args: ['itemGap',] }],
showTitle: [{ type: core.Input, args: ['showTitle',] }],
label: [{ type: core.Input, args: ['label',] }],
feature: [{ type: core.Input, args: ['feature',] }],
iconStyle: [{ type: core.Input, args: ['iconStyle',] }],
zlevel: [{ type: core.Input, args: ['zlevel',] }],
z: [{ type: core.Input, args: ['z',] }],
transitionDuration: [{ type: core.Input, args: ['transitionDuration',] }],
left: [{ type: core.Input, args: ['left',] }],
top: [{ type: core.Input, args: ['top',] }],
right: [{ type: core.Input, args: ['right',] }],
bottom: [{ type: core.Input, args: ['bottom',] }],
width: [{ type: core.Input, args: ['width',] }],
height: [{ type: core.Input, args: ['height',] }],
formatterTemplate: [{ type: core.ContentChild, args: [TdChartViewDataFormatterDirective, { read: core.TemplateRef },] }],
fullTemplate: [{ type: core.ViewChild, args: ['toolboxContent',] }]
};
return TdChartToolboxComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
var TOOLBOX_MODULE_COMPONENTS = [
TdChartToolboxComponent,
TdChartViewDataFormatterDirective,
];
var CovalentToolboxEchartsModule = /** @class */ (function () {
function CovalentToolboxEchartsModule() {
}
CovalentToolboxEchartsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
],
declarations: [
TOOLBOX_MODULE_COMPONENTS,
],
exports: [
TOOLBOX_MODULE_COMPONENTS,
],
},] }
];
return CovalentToolboxEchartsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
exports.TdChartComponent = TdChartComponent;
exports.TdChartAxisComponent = TdChartAxisComponent;
exports.TdChartYAxisComponent = TdChartYAxisComponent;
exports.TdChartXAxisComponent = TdChartXAxisComponent;
exports.TdChartOptionsService = TdChartOptionsService;
exports.CHART_PROVIDER = CHART_PROVIDER;
exports.BASE_MODULE_COMPONENTS = BASE_MODULE_COMPONENTS;
exports.CovalentBaseEchartsModule = CovalentBaseEchartsModule;
exports.assignDefined = assignDefined;
exports.TdSeriesComponent = TdSeriesComponent;
exports.BAR_MODULE_COMPONENTS = BAR_MODULE_COMPONENTS;
exports.CovalentBarEchartsModule = CovalentBarEchartsModule;
exports.TdChartSeriesBarComponent = TdChartSeriesBarComponent;
exports.LINE_MODULE_COMPONENTS = LINE_MODULE_COMPONENTS;
exports.CovalentLineEchartsModule = CovalentLineEchartsModule;
exports.TdChartSeriesLineComponent = TdChartSeriesLineComponent;
exports.SCATTER_MODULE_COMPONENTS = SCATTER_MODULE_COMPONENTS;
exports.CovalentScatterEchartsModule = CovalentScatterEchartsModule;
exports.TdChartSeriesScatterComponent = TdChartSeriesScatterComponent;
exports.TREE_MODULE_COMPONENTS = TREE_MODULE_COMPONENTS;
exports.CovalentTreeEchartsModule = CovalentTreeEchartsModule;
exports.TdChartSeriesTreeComponent = TdChartSeriesTreeComponent;
exports.TOOLTIP_MODULE_COMPONENTS = TOOLTIP_MODULE_COMPONENTS;
exports.CovalentTooltipEchartsModule = CovalentTooltipEchartsModule;
exports.TdTooltipContext = TdTooltipContext;
exports.TdChartTooltipFormatterDirective = TdChartTooltipFormatterDirective;
exports.TdChartTooltipComponent = TdChartTooltipComponent;
exports.TdSeriesTooltipComponent = TdSeriesTooltipComponent;
exports.TOOLBOX_MODULE_COMPONENTS = TOOLBOX_MODULE_COMPONENTS;
exports.CovalentToolboxEchartsModule = CovalentToolboxEchartsModule;
exports.TdChartViewDataFormatterDirective = TdChartViewDataFormatterDirective;
exports.TdChartToolboxComponent = TdChartToolboxComponent;
exports.ɵa = CHART_PROVIDER_FACTORY;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=covalent-echarts.umd.js.map