@syncfusion/ej2-angular-charts 27.1.50-ngcc → 27.1.50

package/esm2020/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './src/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NyYy9pbmRleCc7Il19

package/esm2020/src/accumulation-chart/accumulationchart-all.module.mjs

@@ -0,0 +1,53 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AccumulationChartModule } from './accumulationchart.module';
+import { PieSeries, FunnelSeries, PyramidSeries, AccumulationTooltip, AccumulationLegend, AccumulationSelection, AccumulationHighlight, AccumulationDataLabel, AccumulationAnnotation } from '@syncfusion/ej2-charts';
+import * as i0 from "@angular/core";
+export const PieSeriesService = { provide: 'ChartsPieSeries', useValue: PieSeries };
+export const FunnelSeriesService = { provide: 'ChartsFunnelSeries', useValue: FunnelSeries };
+export const PyramidSeriesService = { provide: 'ChartsPyramidSeries', useValue: PyramidSeries };
+export const AccumulationTooltipService = { provide: 'ChartsAccumulationTooltip', useValue: AccumulationTooltip };
+export const AccumulationLegendService = { provide: 'ChartsAccumulationLegend', useValue: AccumulationLegend };
+export const AccumulationSelectionService = { provide: 'ChartsAccumulationSelection', useValue: AccumulationSelection };
+export const AccumulationHighlightService = { provide: 'ChartsAccumulationHighlight', useValue: AccumulationHighlight };
+export const AccumulationDataLabelService = { provide: 'ChartsAccumulationDataLabel', useValue: AccumulationDataLabel };
+export const AccumulationAnnotationService = { provide: 'ChartsAccumulationAnnotation', useValue: AccumulationAnnotation };
+/**
+ * NgModule definition for the AccumulationChart component with providers.
+ */
+export class AccumulationChartAllModule {
+}
+AccumulationChartAllModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartAllModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AccumulationChartAllModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartAllModule, imports: [CommonModule, AccumulationChartModule], exports: [AccumulationChartModule] });
+AccumulationChartAllModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartAllModule, providers: [
+        PieSeriesService,
+        FunnelSeriesService,
+        PyramidSeriesService,
+        AccumulationTooltipService,
+        AccumulationLegendService,
+        AccumulationSelectionService,
+        AccumulationHighlightService,
+        AccumulationDataLabelService,
+        AccumulationAnnotationService
+    ], imports: [[CommonModule, AccumulationChartModule], AccumulationChartModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartAllModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, AccumulationChartModule],
+                    exports: [
+                        AccumulationChartModule
+                    ],
+                    providers: [
+                        PieSeriesService,
+                        FunnelSeriesService,
+                        PyramidSeriesService,
+                        AccumulationTooltipService,
+                        AccumulationLegendService,
+                        AccumulationSelectionService,
+                        AccumulationHighlightService,
+                        AccumulationDataLabelService,
+                        AccumulationAnnotationService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/accumulation-chart/accumulationchart.component.mjs

@@ -0,0 +1,146 @@
+import { __decorate } from "tslib";
+import { Component, ChangeDetectionStrategy, ContentChild } from '@angular/core';
+import { ComponentBase, ComponentMixins, setValue } from '@syncfusion/ej2-angular-base';
+import { AccumulationChart } from '@syncfusion/ej2-charts';
+import { Template } from '@syncfusion/ej2-angular-base';
+import { AccumulationSeriesCollectionDirective } from './series.directive';
+import { AccumulationAnnotationsDirective } from './annotations.directive';
+import * as i0 from "@angular/core";
+export const inputs = ['allowExport', 'annotations', 'background', 'backgroundImage', 'border', 'center', 'centerLabel', 'currencyCode', 'dataSource', 'enableAnimation', 'enableBorderOnMouseMove', 'enableExport', 'enablePersistence', 'enableRtl', 'enableSmartLabels', 'height', 'highlightColor', 'highlightMode', 'highlightPattern', 'isMultiSelect', 'legendSettings', 'locale', 'margin', 'selectedDataIndexes', 'selectionMode', 'selectionPattern', 'series', 'subTitle', 'subTitleStyle', 'theme', 'title', 'titleStyle', 'tooltip', 'useGroupingSeparator', 'width'];
+export const outputs = ['afterExport', 'animationComplete', 'annotationRender', 'beforePrint', 'beforeResize', 'chartDoubleClick', 'chartMouseClick', 'chartMouseDown', 'chartMouseLeave', 'chartMouseMove', 'chartMouseUp', 'legendClick', 'legendRender', 'load', 'loaded', 'pointClick', 'pointMove', 'pointRender', 'resized', 'selectionComplete', 'seriesRender', 'textRender', 'tooltipRender', 'dataSourceChange'];
+export const twoWays = ['dataSource'];
+/**
+ * AccumulationChart Component
+ * ```html
+ * <ejs-accumulationchart></ejs-accumulationchart>
+ * ```
+ */
+let AccumulationChartComponent = class AccumulationChartComponent extends AccumulationChart {
+    constructor(ngEle, srenderer, viewContainerRef, injector) {
+        super();
+        this.ngEle = ngEle;
+        this.srenderer = srenderer;
+        this.viewContainerRef = viewContainerRef;
+        this.injector = injector;
+        this.tags = ['series', 'annotations'];
+        this.element = this.ngEle.nativeElement;
+        this.injectedModules = this.injectedModules || [];
+        try {
+            let mod = this.injector.get('ChartsPieSeries');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsFunnelSeries');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsPyramidSeries');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationTooltip');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationLegend');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationSelection');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationHighlight');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationDataLabel');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsAccumulationAnnotation');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsExport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        this.registerEvents(outputs);
+        this.addTwoWay.call(this, twoWays);
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.context = new ComponentBase();
+    }
+    ngOnInit() {
+        this.context.ngOnInit(this);
+    }
+    ngAfterViewInit() {
+        this.context.ngAfterViewInit(this);
+    }
+    ngOnDestroy() {
+        this.context.ngOnDestroy(this);
+    }
+    ngAfterContentChecked() {
+        this.tagObjects[0].instance = this.childSeries;
+        if (this.childAnnotations) {
+            this.tagObjects[1].instance = this.childAnnotations;
+        }
+        this.context.ngAfterContentChecked(this);
+    }
+};
+AccumulationChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+AccumulationChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: AccumulationChartComponent, selector: "ejs-accumulationchart", inputs: { allowExport: "allowExport", annotations: "annotations", background: "background", backgroundImage: "backgroundImage", border: "border", center: "center", centerLabel: "centerLabel", currencyCode: "currencyCode", dataSource: "dataSource", enableAnimation: "enableAnimation", enableBorderOnMouseMove: "enableBorderOnMouseMove", enableExport: "enableExport", enablePersistence: "enablePersistence", enableRtl: "enableRtl", enableSmartLabels: "enableSmartLabels", height: "height", highlightColor: "highlightColor", highlightMode: "highlightMode", highlightPattern: "highlightPattern", isMultiSelect: "isMultiSelect", legendSettings: "legendSettings", locale: "locale", margin: "margin", selectedDataIndexes: "selectedDataIndexes", selectionMode: "selectionMode", selectionPattern: "selectionPattern", series: "series", subTitle: "subTitle", subTitleStyle: "subTitleStyle", theme: "theme", title: "title", titleStyle: "titleStyle", tooltip: "tooltip", useGroupingSeparator: "useGroupingSeparator", width: "width" }, outputs: { afterExport: "afterExport", animationComplete: "animationComplete", annotationRender: "annotationRender", beforePrint: "beforePrint", beforeResize: "beforeResize", chartDoubleClick: "chartDoubleClick", chartMouseClick: "chartMouseClick", chartMouseDown: "chartMouseDown", chartMouseLeave: "chartMouseLeave", chartMouseMove: "chartMouseMove", chartMouseUp: "chartMouseUp", legendClick: "legendClick", legendRender: "legendRender", load: "load", loaded: "loaded", pointClick: "pointClick", pointMove: "pointMove", pointRender: "pointRender", resized: "resized", selectionComplete: "selectionComplete", seriesRender: "seriesRender", textRender: "textRender", tooltipRender: "tooltipRender", dataSourceChange: "dataSourceChange" }, queries: [{ propertyName: "tooltip_template", first: true, predicate: ["tooltipTemplate"], descendants: true }, { propertyName: "childSeries", first: true, predicate: AccumulationSeriesCollectionDirective, descendants: true }, { propertyName: "childAnnotations", first: true, predicate: AccumulationAnnotationsDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    Template()
+], AccumulationChartComponent.prototype, "tooltip_template", void 0);
+AccumulationChartComponent = __decorate([
+    ComponentMixins([ComponentBase])
+], AccumulationChartComponent);
+export { AccumulationChartComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ejs-accumulationchart',
+                    inputs: inputs,
+                    outputs: outputs,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    queries: {
+                        childSeries: new ContentChild(AccumulationSeriesCollectionDirective),
+                        childAnnotations: new ContentChild(AccumulationAnnotationsDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.Injector }]; }, propDecorators: { tooltip_template: [{
+                type: ContentChild,
+                args: ['tooltipTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulationchart.component.js","sourceRoot":"","sources":["../../../../src/accumulation-chart/accumulationchart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewContainerRef, ChangeDetectionStrategy, QueryList, Renderer2, Injector, ValueProvider, ContentChild } from '@angular/core';\nimport { ComponentBase, IComponentBase, applyMixins, ComponentMixins, PropertyCollectionInfo, setValue } from '@syncfusion/ej2-angular-base';\nimport { AccumulationChart } from '@syncfusion/ej2-charts';\nimport { Template } from '@syncfusion/ej2-angular-base';\nimport { AccumulationSeriesCollectionDirective } from './series.directive';\nimport { AccumulationAnnotationsDirective } from './annotations.directive';\n\nexport const inputs: string[] = ['allowExport','annotations','background','backgroundImage','border','center','centerLabel','currencyCode','dataSource','enableAnimation','enableBorderOnMouseMove','enableExport','enablePersistence','enableRtl','enableSmartLabels','height','highlightColor','highlightMode','highlightPattern','isMultiSelect','legendSettings','locale','margin','selectedDataIndexes','selectionMode','selectionPattern','series','subTitle','subTitleStyle','theme','title','titleStyle','tooltip','useGroupingSeparator','width'];\nexport const outputs: string[] = ['afterExport','animationComplete','annotationRender','beforePrint','beforeResize','chartDoubleClick','chartMouseClick','chartMouseDown','chartMouseLeave','chartMouseMove','chartMouseUp','legendClick','legendRender','load','loaded','pointClick','pointMove','pointRender','resized','selectionComplete','seriesRender','textRender','tooltipRender','dataSourceChange'];\nexport const twoWays: string[] = ['dataSource'];\n\n/**\n * AccumulationChart Component\n * ```html\n * <ejs-accumulationchart></ejs-accumulationchart>\n * ```\n */\n@Component({\n    selector: 'ejs-accumulationchart',\n    inputs: inputs,\n    outputs: outputs,\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    queries: {\n        childSeries: new ContentChild(AccumulationSeriesCollectionDirective), \n        childAnnotations: new ContentChild(AccumulationAnnotationsDirective)\n    }\n})\n@ComponentMixins([ComponentBase])\nexport class AccumulationChartComponent extends AccumulationChart implements IComponentBase {\n    public context : any;\n    public tagObjects: any;\n\tafterExport: any;\n\tanimationComplete: any;\n\tannotationRender: any;\n\tbeforePrint: any;\n\tbeforeResize: any;\n\tchartDoubleClick: any;\n\tchartMouseClick: any;\n\tchartMouseDown: any;\n\tchartMouseLeave: any;\n\tchartMouseMove: any;\n\tchartMouseUp: any;\n\tlegendClick: any;\n\tlegendRender: any;\n\tload: any;\n\tloaded: any;\n\tpointClick: any;\n\tpointMove: any;\n\tpointRender: any;\n\tresized: any;\n\tselectionComplete: any;\n\tseriesRender: any;\n\ttextRender: any;\n\ttooltipRender: any;\n\tpublic dataSourceChange: any;\n    public childSeries: QueryList<AccumulationSeriesCollectionDirective>;\n    public childAnnotations: QueryList<AccumulationAnnotationsDirective>;\n    public tags: string[] = ['series', 'annotations'];\n    @ContentChild('tooltipTemplate')\n    @Template()\n    public tooltip_template: any;\n\n    constructor(private ngEle: ElementRef, private srenderer: Renderer2, private viewContainerRef:ViewContainerRef, private injector: Injector) {\n        super();\n        this.element = this.ngEle.nativeElement;\n        this.injectedModules = this.injectedModules || [];\n        try {\n                let mod = this.injector.get('ChartsPieSeries');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsFunnelSeries');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsPyramidSeries');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationTooltip');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationLegend');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationSelection');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationHighlight');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationDataLabel');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsAccumulationAnnotation');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsExport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r\n        this.registerEvents(outputs);\n        this.addTwoWay.call(this, twoWays);\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.context  = new ComponentBase();\n    }\n\n    public ngOnInit() {\n        this.context.ngOnInit(this);\n    }\n\n    public ngAfterViewInit(): void {\n        this.context.ngAfterViewInit(this);\n    }\n\n    public ngOnDestroy(): void {\n        this.context.ngOnDestroy(this);\n    }\n\n    public ngAfterContentChecked(): void {\n        this.tagObjects[0].instance = this.childSeries;\n        if (this.childAnnotations) {\n                    this.tagObjects[1].instance = this.childAnnotations as any;\n                }\n        this.context.ngAfterContentChecked(this);\n    }\n\n    public registerEvents: (eventList: string[]) => void;\n    public addTwoWay: (propList: string[]) => void;\n}\n\n"]}

package/esm2020/src/accumulation-chart/accumulationchart.module.mjs

@@ -0,0 +1,43 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AccumulationSeriesDirective, AccumulationSeriesCollectionDirective } from './series.directive';
+import { AccumulationAnnotationDirective, AccumulationAnnotationsDirective } from './annotations.directive';
+import { AccumulationChartComponent } from './accumulationchart.component';
+import * as i0 from "@angular/core";
+/**
+ * NgModule definition for the AccumulationChart component.
+ */
+export class AccumulationChartModule {
+}
+AccumulationChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AccumulationChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartModule, declarations: [AccumulationChartComponent,
+        AccumulationSeriesDirective,
+        AccumulationSeriesCollectionDirective,
+        AccumulationAnnotationDirective,
+        AccumulationAnnotationsDirective], imports: [CommonModule], exports: [AccumulationChartComponent,
+        AccumulationSeriesDirective,
+        AccumulationSeriesCollectionDirective,
+        AccumulationAnnotationDirective,
+        AccumulationAnnotationsDirective] });
+AccumulationChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        AccumulationChartComponent,
+                        AccumulationSeriesDirective,
+                        AccumulationSeriesCollectionDirective,
+                        AccumulationAnnotationDirective,
+                        AccumulationAnnotationsDirective
+                    ],
+                    exports: [
+                        AccumulationChartComponent,
+                        AccumulationSeriesDirective,
+                        AccumulationSeriesCollectionDirective,
+                        AccumulationAnnotationDirective,
+                        AccumulationAnnotationsDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/accumulation-chart/annotations.directive.mjs

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { Directive, ContentChildren, ContentChild } from '@angular/core';
+import { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';
+import { Template } from '@syncfusion/ej2-angular-base';
+import * as i0 from "@angular/core";
+let input = ['content', 'coordinateUnits', 'description', 'horizontalAlignment', 'region', 'verticalAlignment', 'x', 'y'];
+let outputs = [];
+/**
+ * AccumulationAnnotations Directive
+ * ```html
+ * <e-accumulation-annotations>
+ * <e-accumulation-annotation></e-accumulation-annotation>
+ * </e-accumulation-annotations>
+ * ```
+ */
+export class AccumulationAnnotationDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+AccumulationAnnotationDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationAnnotationDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+AccumulationAnnotationDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AccumulationAnnotationDirective, selector: "e-accumulation-annotations>e-accumulation-annotation", inputs: { content: "content", coordinateUnits: "coordinateUnits", description: "description", horizontalAlignment: "horizontalAlignment", region: "region", verticalAlignment: "verticalAlignment", x: "x", y: "y" }, queries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true }], usesInheritance: true, ngImport: i0 });
+__decorate([
+    Template()
+], AccumulationAnnotationDirective.prototype, "content", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationAnnotationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'e-accumulation-annotations>e-accumulation-annotation',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {}
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { content: [{
+                type: ContentChild,
+                args: ['content']
+            }] } });
+/**
+ * AccumulationAnnotation Array Directive
+ * @private
+ */
+export class AccumulationAnnotationsDirective extends ArrayBase {
+    constructor() {
+        super('annotations');
+    }
+}
+AccumulationAnnotationsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationAnnotationsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AccumulationAnnotationsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AccumulationAnnotationsDirective, selector: "ej-accumulationchart>e-accumulation-annotations", queries: [{ propertyName: "children", predicate: AccumulationAnnotationDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationAnnotationsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ej-accumulationchart>e-accumulation-annotations',
+                    queries: {
+                        children: new ContentChildren(AccumulationAnnotationDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ub3RhdGlvbnMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FjY3VtdWxhdGlvbi1jaGFydC9hbm5vdGF0aW9ucy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQW9CLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0YsT0FBTyxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDaEYsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDOztBQUd4RCxJQUFJLEtBQUssR0FBYSxDQUFDLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxhQUFhLEVBQUUscUJBQXFCLEVBQUUsUUFBUSxFQUFFLG1CQUFtQixFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztBQUNwSSxJQUFJLE9BQU8sR0FBYSxFQUFFLENBQUM7QUFDM0I7Ozs7Ozs7R0FPRztBQVNILE1BQU0sT0FBTywrQkFBZ0MsU0FBUSxXQUE0QztJQWtFN0YsWUFBb0IsZ0JBQWlDO1FBQ2pELEtBQUssRUFBRSxDQUFDO1FBRFEscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFpQjtRQUVqRCxRQUFRLENBQUMsaUJBQWlCLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ3pELElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLGlCQUFpQixHQUFHLEtBQUssQ0FBQztJQUNuQyxDQUFDOzs0SEF2RVEsK0JBQStCO2dIQUEvQiwrQkFBK0I7QUFnRXhDO0lBREMsUUFBUSxFQUFFO2dFQUNTOzJGQWhFWCwrQkFBK0I7a0JBUjNDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHNEQUFzRDtvQkFDaEUsTUFBTSxFQUFFLEtBQUs7b0JBQ2IsT0FBTyxFQUFFLE9BQU87b0JBQ2hCLE9BQU8sRUFBRSxFQUVSO2lCQUNKO3VHQWlFVSxPQUFPO3NCQUZiLFlBQVk7dUJBQUMsU0FBUzs7QUFZM0I7OztHQUdHO0FBT0gsTUFBTSxPQUFPLGdDQUFpQyxTQUFRLFNBQTJDO0lBQzdGO1FBQ0ksS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ3pCLENBQUM7OzZIQUhRLGdDQUFnQztpSEFBaEMsZ0NBQWdDLGdIQUhQLCtCQUErQjsyRkFHeEQsZ0NBQWdDO2tCQU41QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxpREFBaUQ7b0JBQzNELE9BQU8sRUFBRTt3QkFDTCxRQUFRLEVBQUUsSUFBSSxlQUFlLENBQUMsK0JBQStCLENBQUM7cUJBQ2pFO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBWaWV3Q29udGFpbmVyUmVmLCBDb250ZW50Q2hpbGRyZW4sIENvbnRlbnRDaGlsZCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tcGxleEJhc2UsIEFycmF5QmFzZSwgc2V0VmFsdWUgfSBmcm9tICdAc3luY2Z1c2lvbi9lajItYW5ndWxhci1iYXNlJztcbmltcG9ydCB7IFRlbXBsYXRlIH0gZnJvbSAnQHN5bmNmdXNpb24vZWoyLWFuZ3VsYXItYmFzZSc7XG5cblxubGV0IGlucHV0OiBzdHJpbmdbXSA9IFsnY29udGVudCcsICdjb29yZGluYXRlVW5pdHMnLCAnZGVzY3JpcHRpb24nLCAnaG9yaXpvbnRhbEFsaWdubWVudCcsICdyZWdpb24nLCAndmVydGljYWxBbGlnbm1lbnQnLCAneCcsICd5J107XG5sZXQgb3V0cHV0czogc3RyaW5nW10gPSBbXTtcbi8qKlxuICogQWNjdW11bGF0aW9uQW5ub3RhdGlvbnMgRGlyZWN0aXZlXG4gKiBgYGBodG1sXG4gKiA8ZS1hY2N1bXVsYXRpb24tYW5ub3RhdGlvbnM+XG4gKiA8ZS1hY2N1bXVsYXRpb24tYW5ub3RhdGlvbj48L2UtYWNjdW11bGF0aW9uLWFubm90YXRpb24+XG4gKiA8L2UtYWNjdW11bGF0aW9uLWFubm90YXRpb25zPlxuICogYGBgXG4gKi9cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnZS1hY2N1bXVsYXRpb24tYW5ub3RhdGlvbnM+ZS1hY2N1bXVsYXRpb24tYW5ub3RhdGlvbicsXG4gICAgaW5wdXRzOiBpbnB1dCxcbiAgICBvdXRwdXRzOiBvdXRwdXRzLCAgICBcbiAgICBxdWVyaWVzOiB7XG5cbiAgICB9XG59KVxuZXhwb3J0IGNsYXNzIEFjY3VtdWxhdGlvbkFubm90YXRpb25EaXJlY3RpdmUgZXh0ZW5kcyBDb21wbGV4QmFzZTxBY2N1bXVsYXRpb25Bbm5vdGF0aW9uRGlyZWN0aXZlPiB7XG4gICAgcHVibGljIGRpcmVjdGl2ZVByb3BMaXN0OiBhbnk7XG5cdFxuXG5cbiAgICAvKiogXG4gICAgICogU3BlY2lmaWVzIHRoZSBjb29yZGluYXRlIHVuaXRzIG9mIHRoZSBhbm5vdGF0aW9uLiBcbiAgICAgKiBUaGUgb3B0aW9ucyBhcmU6IFxuICAgICAqICogUGl4ZWwgLSBSZW5kZXJzIHRoZSBhbm5vdGF0aW9uIGJhc2VkIG9uIHggYW5kIHkgcGl4ZWwgdmFsdWVzLiBcbiAgICAgKiAqIFBvaW50IC0gUmVuZGVycyB0aGUgYW5ub3RhdGlvbiBiYXNlZCBvbiB4IGFuZCB5IGRhdGEgdmFsdWVzLlxuICAgICAqIEBkZWZhdWx0ICdQaXhlbCdcbiAgICAgKi9cbiAgICBwdWJsaWMgY29vcmRpbmF0ZVVuaXRzOiBhbnk7XG4gICAgLyoqIFxuICAgICAqIEEgZGVzY3JpcHRpb24gZm9yIHRoZSBhbm5vdGF0aW9uIHRoYXQgcHJvdmlkZXMgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiBhYm91dCBpdHMgY29udGVudCBmb3Igc2NyZWVuIHJlYWRlcnMuXG4gICAgICogQGRlZmF1bHQgbnVsbFxuICAgICAqL1xuICAgIHB1YmxpYyBkZXNjcmlwdGlvbjogYW55O1xuICAgIC8qKiBcbiAgICAgKiBTcGVjaWZpZXMgdGhlIGFsaWdubWVudCBvZiB0aGUgYW5ub3RhdGlvbi4gXG4gICAgICogVGhlIG9wdGlvbnMgYXJlOiBcbiAgICAgKiAqIE5lYXIgLSBBbGlnbnMgdGhlIGFubm90YXRpb24gZWxlbWVudCB0byB0aGUgdG9wIHNpZGUuIFxuICAgICAqICogRmFyIC0gQWxpZ25zIHRoZSBhbm5vdGF0aW9uIGVsZW1lbnQgdG8gdGhlIGJvdHRvbSBzaWRlLiBcbiAgICAgKiAqIENlbnRlciAtIEFsaWducyB0aGUgYW5ub3RhdGlvbiBlbGVtZW50IHRvIHRoZSBtaWRwb2ludC5cbiAgICAgKiBAZGVmYXVsdCAnQ2VudGVyJ1xuICAgICAqIEBkZXByZWNhdGVkIFxuICAgICAqL1xuICAgIHB1YmxpYyBob3Jpem9udGFsQWxpZ25tZW50OiBhbnk7XG4gICAgLyoqIFxuICAgICAqIFNwZWNpZmllcyB0aGUgcmVnaW9ucyBvZiB0aGUgYW5ub3RhdGlvbi4gXG4gICAgICogVGhlIG9wdGlvbnMgYXJlOiBcbiAgICAgKiAqIENoYXJ0IC0gUmVuZGVycyB0aGUgYW5ub3RhdGlvbiBiYXNlZCBvbiBjaGFydCBjb29yZGluYXRlcy4gXG4gICAgICogKiBTZXJpZXMgLSBSZW5kZXJzIHRoZSBhbm5vdGF0aW9uIGJhc2VkIG9uIHNlcmllcyBjb29yZGluYXRlcy5cbiAgICAgKiBAZGVmYXVsdCAnQ2hhcnQnXG4gICAgICovXG4gICAgcHVibGljIHJlZ2lvbjogYW55O1xuICAgIC8qKiBcbiAgICAgKiBTcGVjaWZpZXMgdGhlIHBvc2l0aW9uIG9mIHRoZSBhbm5vdGF0aW9uLiBcbiAgICAgKiBUaGUgb3B0aW9ucyBhcmUgXG4gICAgICogKiBUb3AgLSBBbGlnbnMgdGhlIGFubm90YXRpb24gZWxlbWVudCB0byB0aGUgdG9wIHNpZGUuIFxuICAgICAqICogQm90dG9tIC0gQWxpZ25zIHRoZSBhbm5vdGF0aW9uIGVsZW1lbnQgdG8gdGhlIGJvdHRvbSBzaWRlLiBcbiAgICAgKiAqIE1pZGRsZSAtIEFsaWducyB0aGUgYW5ub3RhdGlvbiBlbGVtZW50IHRvIHRoZSBtaWRwb2ludC5cbiAgICAgKiBAZGVmYXVsdCAnTWlkZGxlJ1xuICAgICAqIEBkZXByZWNhdGVkIFxuICAgICAqL1xuICAgIHB1YmxpYyB2ZXJ0aWNhbEFsaWdubWVudDogYW55O1xuICAgIC8qKiBcbiAgICAgKiBJZiBgY29vcmRpbmF0ZVVuaXRgIGlzIHNldCB0byBgUGl4ZWxgLCB4IHNwZWNpZmllcyB0aGUgcGl4ZWwgdmFsdWUuIFxuICAgICAqIElmIGBjb29yZGluYXRlVW5pdGAgaXMgc2V0IHRvIGBQb2ludGAsIHggc3BlY2lmaWVzIHRoZSBkYXRhIHZhbHVlLlxuICAgICAqIEBkZWZhdWx0ICcwJ1xuICAgICAqL1xuICAgIHB1YmxpYyB4OiBhbnk7XG4gICAgLyoqIFxuICAgICAqIElmIGBjb29yZGluYXRlVW5pdGAgaXMgc2V0IHRvIGBQaXhlbGAsIHkgc3BlY2lmaWVzIHRoZSBwaXhlbCB2YWx1ZS4gXG4gICAgICogSWYgYGNvb3JkaW5hdGVVbml0YCBpcyBzZXQgdG8gYFBvaW50YCwgeSBzcGVjaWZpZXMgdGhlIGRhdGEgdmFsdWUuXG4gICAgICogQGRlZmF1bHQgJzAnXG4gICAgICovXG4gICAgcHVibGljIHk6IGFueTtcbiAgICAvKiogXG4gICAgICogVGhlIGNvbnRlbnQgb2YgdGhlIGFubm90YXRpb24sIHdoaWNoIGNhbiBhbHNvIGFjY2VwdCB0aGUgSUQgb2YgYSBjdXN0b20gZWxlbWVudC5cbiAgICAgKiBAZGVmYXVsdCBudWxsXG4gICAgICovXG4gICAgQENvbnRlbnRDaGlsZCgnY29udGVudCcpXG4gICAgQFRlbXBsYXRlKClcbiAgICBwdWJsaWMgY29udGVudDogYW55O1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSB2aWV3Q29udGFpbmVyUmVmOlZpZXdDb250YWluZXJSZWYpIHtcbiAgICAgICAgc3VwZXIoKTtcbiAgICAgICAgc2V0VmFsdWUoJ2N1cnJlbnRJbnN0YW5jZScsIHRoaXMsIHRoaXMudmlld0NvbnRhaW5lclJlZik7XG4gICAgICAgIHRoaXMucmVnaXN0ZXJFdmVudHMob3V0cHV0cyk7XG4gICAgICAgIHRoaXMuZGlyZWN0aXZlUHJvcExpc3QgPSBpbnB1dDtcbiAgICB9XG59XG5cbi8qKlxuICogQWNjdW11bGF0aW9uQW5ub3RhdGlvbiBBcnJheSBEaXJlY3RpdmVcbiAqIEBwcml2YXRlXG4gKi9cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnZWotYWNjdW11bGF0aW9uY2hhcnQ+ZS1hY2N1bXVsYXRpb24tYW5ub3RhdGlvbnMnLFxuICAgIHF1ZXJpZXM6IHtcbiAgICAgICAgY2hpbGRyZW46IG5ldyBDb250ZW50Q2hpbGRyZW4oQWNjdW11bGF0aW9uQW5ub3RhdGlvbkRpcmVjdGl2ZSlcbiAgICB9LFxufSlcbmV4cG9ydCBjbGFzcyBBY2N1bXVsYXRpb25Bbm5vdGF0aW9uc0RpcmVjdGl2ZSBleHRlbmRzIEFycmF5QmFzZTxBY2N1bXVsYXRpb25Bbm5vdGF0aW9uc0RpcmVjdGl2ZT4ge1xuICAgIGNvbnN0cnVjdG9yKCkge1xuICAgICAgICBzdXBlcignYW5ub3RhdGlvbnMnKTtcbiAgICB9XG59Il19

package/esm2020/src/accumulation-chart/series.directive.mjs

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { Directive, ContentChildren, ContentChild } from '@angular/core';
+import { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';
+import { Template } from '@syncfusion/ej2-angular-base';
+import * as i0 from "@angular/core";
+let input = ['animation', 'applyPattern', 'border', 'borderRadius', 'dashArray', 'dataLabel', 'dataSource', 'emptyPointSettings', 'enableTooltip', 'endAngle', 'explode', 'explodeAll', 'explodeIndex', 'explodeOffset', 'gapRatio', 'groupMode', 'groupTo', 'height', 'innerRadius', 'legendImageUrl', 'legendShape', 'name', 'neckHeight', 'neckWidth', 'opacity', 'palettes', 'pointColorMapping', 'pyramidMode', 'query', 'radius', 'selectionStyle', 'startAngle', 'tooltipMappingName', 'type', 'visible', 'width', 'xName', 'yName'];
+let outputs = [];
+/**
+ * AccumulationSeries Directive
+ * ```html
+ * <e-accumulation-series-collection>
+ * <e-accumulation-series></e-accumulation-series>
+ * </e-accumulation-series-collection>
+ * ```
+ */
+export class AccumulationSeriesDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+AccumulationSeriesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationSeriesDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+AccumulationSeriesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AccumulationSeriesDirective, selector: "e-accumulation-series-collection>e-accumulation-series", inputs: { animation: "animation", applyPattern: "applyPattern", border: "border", borderRadius: "borderRadius", dashArray: "dashArray", dataLabel: "dataLabel", dataSource: "dataSource", emptyPointSettings: "emptyPointSettings", enableTooltip: "enableTooltip", endAngle: "endAngle", explode: "explode", explodeAll: "explodeAll", explodeIndex: "explodeIndex", explodeOffset: "explodeOffset", gapRatio: "gapRatio", groupMode: "groupMode", groupTo: "groupTo", height: "height", innerRadius: "innerRadius", legendImageUrl: "legendImageUrl", legendShape: "legendShape", name: "name", neckHeight: "neckHeight", neckWidth: "neckWidth", opacity: "opacity", palettes: "palettes", pointColorMapping: "pointColorMapping", pyramidMode: "pyramidMode", query: "query", radius: "radius", selectionStyle: "selectionStyle", startAngle: "startAngle", tooltipMappingName: "tooltipMappingName", type: "type", visible: "visible", width: "width", xName: "xName", yName: "yName" }, queries: [{ propertyName: "dataLabel_template", first: true, predicate: ["dataLabelTemplate"], descendants: true }], usesInheritance: true, ngImport: i0 });
+__decorate([
+    Template()
+], AccumulationSeriesDirective.prototype, "dataLabel_template", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationSeriesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'e-accumulation-series-collection>e-accumulation-series',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {}
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { dataLabel_template: [{
+                type: ContentChild,
+                args: ['dataLabelTemplate']
+            }] } });
+/**
+ * AccumulationSeries Array Directive
+ * @private
+ */
+export class AccumulationSeriesCollectionDirective extends ArrayBase {
+    constructor() {
+        super('series');
+    }
+}
+AccumulationSeriesCollectionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationSeriesCollectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AccumulationSeriesCollectionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AccumulationSeriesCollectionDirective, selector: "ej-accumulationchart>e-accumulation-series-collection", queries: [{ propertyName: "children", predicate: AccumulationSeriesDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AccumulationSeriesCollectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ej-accumulationchart>e-accumulation-series-collection',
+                    queries: {
+                        children: new ContentChildren(AccumulationSeriesDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"series.directive.js","sourceRoot":"","sources":["../../../../src/accumulation-chart/series.directive.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAoB,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;;AAGxD,IAAI,KAAK,GAAa,CAAC,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACthB,IAAI,OAAO,GAAa,EAAE,CAAC;AAC3B;;;;;;;GAOG;AASH,MAAM,OAAO,2BAA4B,SAAQ,WAAwC;IA0NrF,YAAoB,gBAAiC;QACjD,KAAK,EAAE,CAAC;QADQ,qBAAgB,GAAhB,gBAAgB,CAAiB;QAEjD,QAAQ,CAAC,iBAAiB,EAAE,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACnC,CAAC;;wHA/NQ,2BAA2B;4GAA3B,2BAA2B;AAwNpC;IADC,QAAQ,EAAE;uEACoB;2FAxNtB,2BAA2B;kBARvC,SAAS;mBAAC;oBACP,QAAQ,EAAE,wDAAwD;oBAClE,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE,OAAO;oBAChB,OAAO,EAAE,EAER;iBACJ;uGAyNU,kBAAkB;sBAFxB,YAAY;uBAAC,mBAAmB;;AAYrC;;;GAGG;AAOH,MAAM,OAAO,qCAAsC,SAAQ,SAAgD;IACvG;QACI,KAAK,CAAC,QAAQ,CAAC,CAAC;IACpB,CAAC;;kIAHQ,qCAAqC;sHAArC,qCAAqC,sHAHZ,2BAA2B;2FAGpD,qCAAqC;kBANjD,SAAS;mBAAC;oBACP,QAAQ,EAAE,uDAAuD;oBACjE,OAAO,EAAE;wBACL,QAAQ,EAAE,IAAI,eAAe,CAAC,2BAA2B,CAAC;qBAC7D;iBACJ","sourcesContent":["import { Directive, ViewContainerRef, ContentChildren, ContentChild } from '@angular/core';\nimport { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';\nimport { Template } from '@syncfusion/ej2-angular-base';\n\n\nlet input: string[] = ['animation', 'applyPattern', 'border', 'borderRadius', 'dashArray', 'dataLabel', 'dataSource', 'emptyPointSettings', 'enableTooltip', 'endAngle', 'explode', 'explodeAll', 'explodeIndex', 'explodeOffset', 'gapRatio', 'groupMode', 'groupTo', 'height', 'innerRadius', 'legendImageUrl', 'legendShape', 'name', 'neckHeight', 'neckWidth', 'opacity', 'palettes', 'pointColorMapping', 'pyramidMode', 'query', 'radius', 'selectionStyle', 'startAngle', 'tooltipMappingName', 'type', 'visible', 'width', 'xName', 'yName'];\nlet outputs: string[] = [];\n/**\n * AccumulationSeries Directive\n * ```html\n * <e-accumulation-series-collection>\n * <e-accumulation-series></e-accumulation-series>\n * </e-accumulation-series-collection>\n * ```\n */\n@Directive({\n    selector: 'e-accumulation-series-collection>e-accumulation-series',\n    inputs: input,\n    outputs: outputs,    \n    queries: {\n\n    }\n})\nexport class AccumulationSeriesDirective extends ComplexBase<AccumulationSeriesDirective> {\n    public directivePropList: any;\n\t\n\n\n    /** \n     * Specifies the type of series in the accumulation chart.\n     * @default 'Pie'\n     */\n    public type: any;\n    /** \n     * Options for customizing the animation of the series. \n     * By default, animation is enabled with a duration of 1000 milliseconds (about 1 second). It can be disabled by setting enable to `false`. \n     * The following properties are supported in animation: \n     * * enable: If set to true, the series is animated on initial loading. \n     * * duration: The duration of the animation in milliseconds. \n     * * delay: The delay before the animation starts, in milliseconds.\n     */\n    public animation: any;\n    /** \n     * When set to true, a different pattern is applied to each slice of the pie.\n     * @default false\n     */\n    public applyPattern: any;\n    /** \n     * Options for customizing the border of the series.\n     */\n    public border: any;\n    /** \n     * Option for customizing the border radius.\n     * @default 0\n     */\n    public borderRadius: any;\n    /** \n     * Defines the pattern of dashes and gaps for the series border.\n     * @default '0'\n     */\n    public dashArray: any;\n    /** \n     * The data label property can be used to show the data label and customize its position and styling.\n     */\n    public dataLabel: any;\n    /** \n     * Specifies the data source for the series. It can be an array of JSON objects, or an instance of DataManager. \n     * \n     * @default ''\n     */\n    public dataSource: any;\n    /** \n     * Customization options for the appearance of empty points in the series, where `null` or `undefined` values are considered as empty points.\n     */\n    public emptyPointSettings: any;\n    /** \n     * Controls whether the tooltip for the accumulation chart series is enabled or disabled. Set to true to display tooltips on hover, or false to hide them.\n     * @default true\n     */\n    public enableTooltip: any;\n    /** \n     * Specifies the ending angle for the series, in degrees.\n     * @default null\n     */\n    public endAngle: any;\n    /** \n     * If set to true, series points will explode on mouse click or touch.\n     * @default false\n     */\n    public explode: any;\n    /** \n     * If set to true, all the points in the series will explode on load.\n     * @default false\n     */\n    public explodeAll: any;\n    /** \n     * Index of the point in the series to be exploded on initial load.\n     * @default null\n     * @aspdefaultvalueignore \n     * @blazordefaultvalue Double.NaN\n     */\n    public explodeIndex: any;\n    /** \n     * Specifies the distance of the point from the center, which can be defined in both pixels and percentage.\n     * @default '30%'\n     */\n    public explodeOffset: any;\n    /** \n     * Defines the distance between the segments of a funnel or pyramid series. \n     * The range is from 0 to 1.\n     * @default 0\n     */\n    public gapRatio: any;\n    /** \n     * In the accumulation series, y-values less than `groupMode` are combined into a single slice named 'others'.\n     * @default Value\n     */\n    public groupMode: any;\n    /** \n     * The y-values of the accumulation series that are less than `groupTo` are combined into a single slice named 'others'.\n     * @default null\n     */\n    public groupTo: any;\n    /** \n     * Defines the height of the funnel or pyramid series relative to the chart area.\n     * @default '80%'\n     */\n    public height: any;\n    /** \n     * When the `innerRadius` value is greater than 0%, a donut shape will appear in the pie series. It accepts only percentage values.\n     * @default '0'\n     */\n    public innerRadius: any;\n    /** \n     * The URL for the image to be displayed as a legend icon. \n     * > Note that `legendShape` must be set to `Image`.\n     * @default ''\n     */\n    public legendImageUrl: any;\n    /** \n     * Specifies the shape of the legend icon for each data point. \n     * Available shapes for legend: \n     * * Circle - Renders a circular icon. \n     * * Rectangle - Renders a rectangular icon. \n     * * Triangle - Renders a triangular icon. \n     * * Diamond - Renders a diamond-shaped icon. \n     * * Cross - Renders a cross-shaped icon. \n     * * HorizontalLine - Renders a horizontal line icon. \n     * * VerticalLine - Renders a vertical line icon. \n     * * Pentagon - Renders a pentagon-shaped icon. \n     * * InvertedTriangle - Renders an inverted triangle-shaped icon. \n     * * SeriesType - Uses the default icon shape based on the series type. \n     * * Image - Renders a custom image for the legend icon.\n     * @default 'SeriesType'\n     */\n    public legendShape: any;\n    /** \n     * The `name` property allows for setting a name for the series.\n     * @default ''\n     */\n    public name: any;\n    /** \n     * Defines the height of the funnel neck relative to the chart area.\n     * @default '20%'\n     */\n    public neckHeight: any;\n    /** \n     * Defines the width of the funnel neck relative to the chart area.\n     * @default '20%'\n     */\n    public neckWidth: any;\n    /** \n     * Sets the opacity of the series, with a value between 0 and 1 where 0 is fully transparent and 1 is fully opaque.\n     * @default 1.\n     */\n    public opacity: any;\n    /** \n     * The `palettes` array defines a set of colors used for rendering the accumulation chart's points. Each color in the array is applied to each point in order.\n     * @default []\n     */\n    public palettes: any;\n    /** \n     * The data source field that contains the color value of a point. \n     * It is applicable for series.\n     * @default ''\n     */\n    public pointColorMapping: any;\n    /** \n     * Defines how the values are represented, either through the height or surface area of the segments.\n     * @default 'Linear'\n     */\n    public pyramidMode: any;\n    /** \n     * Specifies a query to select data from the data source. This property is applicable only when the data source is an `ej.DataManager`.\n     * @default null\n     */\n    public query: any;\n    /** \n     * Specifies the radius of the pie series as a percentage of the chart's size.\n     * @default null\n     */\n    public radius: any;\n    /** \n     * The `selectionStyle` property is used to specify custom CSS styles for the selected series or points.\n     * @default null\n     */\n    public selectionStyle: any;\n    /** \n     * Specifies the starting angle for the series, in degrees.\n     * @default 0\n     */\n    public startAngle: any;\n    /** \n     * The data source field that contains the value to be displayed in the tooltip.\n     * @default ''\n     */\n    public tooltipMappingName: any;\n    /** \n     * If set to true, the series will be visible. If set to false, the series will be hidden.\n     * @default true\n     */\n    public visible: any;\n    /** \n     * Defines the width of the funnel or pyramid series relative to the chart area.\n     * @default '80%'\n     */\n    public width: any;\n    /** \n     * The data source field that contains the x value.\n     * @default ''\n     */\n    public xName: any;\n    /** \n     * The data source field that contains the y value.\n     * @default ''\n     */\n    public yName: any;\n    @ContentChild('dataLabelTemplate')\n    @Template()\n    public dataLabel_template: any;\n\n    constructor(private viewContainerRef:ViewContainerRef) {\n        super();\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.registerEvents(outputs);\n        this.directivePropList = input;\n    }\n}\n\n/**\n * AccumulationSeries Array Directive\n * @private\n */\n@Directive({\n    selector: 'ej-accumulationchart>e-accumulation-series-collection',\n    queries: {\n        children: new ContentChildren(AccumulationSeriesDirective)\n    },\n})\nexport class AccumulationSeriesCollectionDirective extends ArrayBase<AccumulationSeriesCollectionDirective> {\n    constructor() {\n        super('series');\n    }\n}"]}

package/esm2020/src/bullet-chart/bulletchart-all.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BulletChartModule } from './bulletchart.module';
+import { BulletTooltip, BulletChartLegend } from '@syncfusion/ej2-charts';
+import * as i0 from "@angular/core";
+export const BulletTooltipService = { provide: 'ChartsBulletTooltip', useValue: BulletTooltip };
+export const BulletChartLegendService = { provide: 'ChartsBulletChartLegend', useValue: BulletChartLegend };
+/**
+ * NgModule definition for the BulletChart component with providers.
+ */
+export class BulletChartAllModule {
+}
+BulletChartAllModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartAllModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BulletChartAllModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartAllModule, imports: [CommonModule, BulletChartModule], exports: [BulletChartModule] });
+BulletChartAllModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartAllModule, providers: [
+        BulletTooltipService,
+        BulletChartLegendService
+    ], imports: [[CommonModule, BulletChartModule], BulletChartModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartAllModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, BulletChartModule],
+                    exports: [
+                        BulletChartModule
+                    ],
+                    providers: [
+                        BulletTooltipService,
+                        BulletChartLegendService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVsbGV0Y2hhcnQtYWxsLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9idWxsZXQtY2hhcnQvYnVsbGV0Y2hhcnQtYWxsLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUN4RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFHL0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDekQsT0FBTyxFQUFDLGFBQWEsRUFBRSxpQkFBaUIsRUFBQyxNQUFNLHdCQUF3QixDQUFBOztBQUd2RSxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBa0IsRUFBRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBQyxDQUFDO0FBQzlHLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFrQixFQUFFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxRQUFRLEVBQUUsaUJBQWlCLEVBQUMsQ0FBQztBQUUxSDs7R0FFRztBQVdILE1BQU0sT0FBTyxvQkFBb0I7O2lIQUFwQixvQkFBb0I7a0hBQXBCLG9CQUFvQixZQVRuQixZQUFZLEVBQUUsaUJBQWlCLGFBRXJDLGlCQUFpQjtrSEFPWixvQkFBb0IsYUFMbkI7UUFDTixvQkFBb0I7UUFDcEIsd0JBQXdCO0tBQzNCLFlBUFEsQ0FBQyxZQUFZLEVBQUUsaUJBQWlCLENBQUMsRUFFdEMsaUJBQWlCOzJGQU9aLG9CQUFvQjtrQkFWaEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsaUJBQWlCLENBQUM7b0JBQzFDLE9BQU8sRUFBRTt3QkFDTCxpQkFBaUI7cUJBQ3BCO29CQUNELFNBQVMsRUFBQzt3QkFDTixvQkFBb0I7d0JBQ3BCLHdCQUF3QjtxQkFDM0I7aUJBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgVmFsdWVQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEJ1bGxldFJhbmdlRGlyZWN0aXZlLCBCdWxsZXRSYW5nZUNvbGxlY3Rpb25EaXJlY3RpdmUgfSBmcm9tICcuL3Jhbmdlcy5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQnVsbGV0Q2hhcnRDb21wb25lbnQgfSBmcm9tICcuL2J1bGxldGNoYXJ0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBCdWxsZXRDaGFydE1vZHVsZSB9IGZyb20gJy4vYnVsbGV0Y2hhcnQubW9kdWxlJztcbmltcG9ydCB7QnVsbGV0VG9vbHRpcCwgQnVsbGV0Q2hhcnRMZWdlbmR9IGZyb20gJ0BzeW5jZnVzaW9uL2VqMi1jaGFydHMnXG5cblxuZXhwb3J0IGNvbnN0IEJ1bGxldFRvb2x0aXBTZXJ2aWNlOiBWYWx1ZVByb3ZpZGVyID0geyBwcm92aWRlOiAnQ2hhcnRzQnVsbGV0VG9vbHRpcCcsIHVzZVZhbHVlOiBCdWxsZXRUb29sdGlwfTtcbmV4cG9ydCBjb25zdCBCdWxsZXRDaGFydExlZ2VuZFNlcnZpY2U6IFZhbHVlUHJvdmlkZXIgPSB7IHByb3ZpZGU6ICdDaGFydHNCdWxsZXRDaGFydExlZ2VuZCcsIHVzZVZhbHVlOiBCdWxsZXRDaGFydExlZ2VuZH07XG5cbi8qKlxuICogTmdNb2R1bGUgZGVmaW5pdGlvbiBmb3IgdGhlIEJ1bGxldENoYXJ0IGNvbXBvbmVudCB3aXRoIHByb3ZpZGVycy5cbiAqL1xuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBCdWxsZXRDaGFydE1vZHVsZV0sXG4gICAgZXhwb3J0czogW1xuICAgICAgICBCdWxsZXRDaGFydE1vZHVsZVxuICAgIF0sXG4gICAgcHJvdmlkZXJzOltcbiAgICAgICAgQnVsbGV0VG9vbHRpcFNlcnZpY2UsXG4gICAgICAgIEJ1bGxldENoYXJ0TGVnZW5kU2VydmljZVxuICAgIF1cbn0pXG5leHBvcnQgY2xhc3MgQnVsbGV0Q2hhcnRBbGxNb2R1bGUgeyB9Il19

package/esm2020/src/bullet-chart/bulletchart.component.mjs

@@ -0,0 +1,85 @@
+import { __decorate } from "tslib";
+import { Component, ChangeDetectionStrategy, ContentChild } from '@angular/core';
+import { ComponentBase, ComponentMixins, setValue } from '@syncfusion/ej2-angular-base';
+import { BulletChart } from '@syncfusion/ej2-charts';
+import { Template } from '@syncfusion/ej2-angular-base';
+import { BulletRangeCollectionDirective } from './ranges.directive';
+import * as i0 from "@angular/core";
+export const inputs = ['animation', 'border', 'categoryField', 'categoryLabelStyle', 'dataLabel', 'dataSource', 'enableGroupSeparator', 'enablePersistence', 'enableRtl', 'height', 'interval', 'labelFormat', 'labelPosition', 'labelStyle', 'legendSettings', 'locale', 'majorTickLines', 'margin', 'maximum', 'minimum', 'minorTickLines', 'minorTicksPerInterval', 'opposedPosition', 'orientation', 'query', 'ranges', 'subtitle', 'subtitleStyle', 'tabIndex', 'targetColor', 'targetField', 'targetTypes', 'targetWidth', 'theme', 'tickPosition', 'title', 'titlePosition', 'titleStyle', 'tooltip', 'type', 'valueBorder', 'valueField', 'valueFill', 'valueHeight', 'width'];
+export const outputs = ['beforePrint', 'bulletChartMouseClick', 'legendRender', 'load', 'loaded', 'tooltipRender', 'dataSourceChange'];
+export const twoWays = ['dataSource'];
+/**
+ * BulletChart Component
+ * ```html
+ * <ejs-bulletchart></ejs-bulletchart>
+ * ```
+ */
+let BulletChartComponent = class BulletChartComponent extends BulletChart {
+    constructor(ngEle, srenderer, viewContainerRef, injector) {
+        super();
+        this.ngEle = ngEle;
+        this.srenderer = srenderer;
+        this.viewContainerRef = viewContainerRef;
+        this.injector = injector;
+        this.tags = ['ranges'];
+        this.element = this.ngEle.nativeElement;
+        this.injectedModules = this.injectedModules || [];
+        try {
+            let mod = this.injector.get('ChartsBulletTooltip');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ChartsBulletChartLegend');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        this.registerEvents(outputs);
+        this.addTwoWay.call(this, twoWays);
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.context = new ComponentBase();
+    }
+    ngOnInit() {
+        this.context.ngOnInit(this);
+    }
+    ngAfterViewInit() {
+        this.context.ngAfterViewInit(this);
+    }
+    ngOnDestroy() {
+        this.context.ngOnDestroy(this);
+    }
+    ngAfterContentChecked() {
+        this.tagObjects[0].instance = this.childRanges;
+        this.context.ngAfterContentChecked(this);
+    }
+};
+BulletChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BulletChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: BulletChartComponent, selector: "ejs-bulletchart", inputs: { animation: "animation", border: "border", categoryField: "categoryField", categoryLabelStyle: "categoryLabelStyle", dataLabel: "dataLabel", dataSource: "dataSource", enableGroupSeparator: "enableGroupSeparator", enablePersistence: "enablePersistence", enableRtl: "enableRtl", height: "height", interval: "interval", labelFormat: "labelFormat", labelPosition: "labelPosition", labelStyle: "labelStyle", legendSettings: "legendSettings", locale: "locale", majorTickLines: "majorTickLines", margin: "margin", maximum: "maximum", minimum: "minimum", minorTickLines: "minorTickLines", minorTicksPerInterval: "minorTicksPerInterval", opposedPosition: "opposedPosition", orientation: "orientation", query: "query", ranges: "ranges", subtitle: "subtitle", subtitleStyle: "subtitleStyle", tabIndex: "tabIndex", targetColor: "targetColor", targetField: "targetField", targetTypes: "targetTypes", targetWidth: "targetWidth", theme: "theme", tickPosition: "tickPosition", title: "title", titlePosition: "titlePosition", titleStyle: "titleStyle", tooltip: "tooltip", type: "type", valueBorder: "valueBorder", valueField: "valueField", valueFill: "valueFill", valueHeight: "valueHeight", width: "width" }, outputs: { beforePrint: "beforePrint", bulletChartMouseClick: "bulletChartMouseClick", legendRender: "legendRender", load: "load", loaded: "loaded", tooltipRender: "tooltipRender", dataSourceChange: "dataSourceChange" }, queries: [{ propertyName: "tooltip_template", first: true, predicate: ["tooltipTemplate"], descendants: true }, { propertyName: "childRanges", first: true, predicate: BulletRangeCollectionDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    Template()
+], BulletChartComponent.prototype, "tooltip_template", void 0);
+BulletChartComponent = __decorate([
+    ComponentMixins([ComponentBase])
+], BulletChartComponent);
+export { BulletChartComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: BulletChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ejs-bulletchart',
+                    inputs: inputs,
+                    outputs: outputs,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    queries: {
+                        childRanges: new ContentChild(BulletRangeCollectionDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.Injector }]; }, propDecorators: { tooltip_template: [{
+                type: ContentChild,
+                args: ['tooltipTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulletchart.component.js","sourceRoot":"","sources":["../../../../src/bullet-chart/bulletchart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewContainerRef, ChangeDetectionStrategy, QueryList, Renderer2, Injector, ValueProvider, ContentChild } from '@angular/core';\nimport { ComponentBase, IComponentBase, applyMixins, ComponentMixins, PropertyCollectionInfo, setValue } from '@syncfusion/ej2-angular-base';\nimport { BulletChart } from '@syncfusion/ej2-charts';\nimport { Template } from '@syncfusion/ej2-angular-base';\nimport { BulletRangeCollectionDirective } from './ranges.directive';\n\nexport const inputs: string[] = ['animation','border','categoryField','categoryLabelStyle','dataLabel','dataSource','enableGroupSeparator','enablePersistence','enableRtl','height','interval','labelFormat','labelPosition','labelStyle','legendSettings','locale','majorTickLines','margin','maximum','minimum','minorTickLines','minorTicksPerInterval','opposedPosition','orientation','query','ranges','subtitle','subtitleStyle','tabIndex','targetColor','targetField','targetTypes','targetWidth','theme','tickPosition','title','titlePosition','titleStyle','tooltip','type','valueBorder','valueField','valueFill','valueHeight','width'];\nexport const outputs: string[] = ['beforePrint','bulletChartMouseClick','legendRender','load','loaded','tooltipRender','dataSourceChange'];\nexport const twoWays: string[] = ['dataSource'];\n\n/**\n * BulletChart Component\n * ```html\n * <ejs-bulletchart></ejs-bulletchart>\n * ```\n */\n@Component({\n    selector: 'ejs-bulletchart',\n    inputs: inputs,\n    outputs: outputs,\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    queries: {\n        childRanges: new ContentChild(BulletRangeCollectionDirective)\n    }\n})\n@ComponentMixins([ComponentBase])\nexport class BulletChartComponent extends BulletChart implements IComponentBase {\n    public context : any;\n    public tagObjects: any;\n\tbeforePrint: any;\n\tbulletChartMouseClick: any;\n\tlegendRender: any;\n\tload: any;\n\tloaded: any;\n\ttooltipRender: any;\n\tpublic dataSourceChange: any;\n    public childRanges: QueryList<BulletRangeCollectionDirective>;\n    public tags: string[] = ['ranges'];\n    @ContentChild('tooltipTemplate')\n    @Template()\n    public tooltip_template: any;\n\n    constructor(private ngEle: ElementRef, private srenderer: Renderer2, private viewContainerRef:ViewContainerRef, private injector: Injector) {\n        super();\n        this.element = this.ngEle.nativeElement;\n        this.injectedModules = this.injectedModules || [];\n        try {\n                let mod = this.injector.get('ChartsBulletTooltip');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ChartsBulletChartLegend');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r\n        this.registerEvents(outputs);\n        this.addTwoWay.call(this, twoWays);\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.context  = new ComponentBase();\n    }\n\n    public ngOnInit() {\n        this.context.ngOnInit(this);\n    }\n\n    public ngAfterViewInit(): void {\n        this.context.ngAfterViewInit(this);\n    }\n\n    public ngOnDestroy(): void {\n        this.context.ngOnDestroy(this);\n    }\n\n    public ngAfterContentChecked(): void {\n        this.tagObjects[0].instance = this.childRanges;\n        this.context.ngAfterContentChecked(this);\n    }\n\n    public registerEvents: (eventList: string[]) => void;\n    public addTwoWay: (propList: string[]) => void;\n}\n\n"]}