igniteui-angular-extras 15.0.11

package/esm2020/lib/context-menu/igx-context-menu.directive.mjs

@@ -0,0 +1,160 @@
+import { Directive, EventEmitter, Optional, Output } from '@angular/core';
+import { AbsoluteScrollStrategy, AutoPositionStrategy, HorizontalAlignment, VerticalAlignment } from '@infragistics/igniteui-angular';
+import { Subject } from 'rxjs';
+import { debounceTime, filter, merge, takeUntil } from 'rxjs/operators';
+import { IgxContextMenuComponent } from './context-menu.component';
+import { ResizeObserver } from '@juggle/resize-observer';
+import * as i0 from "@angular/core";
+import * as i1 from "@infragistics/igniteui-angular";
+import * as i2 from "../directives/conditional-formatting/conditional-formatting.directive";
+import * as i3 from "../directives/chart-integration/chart-integration.directive";
+export class IgxContextMenuDirective {
+    constructor(grid, textFormatter, chartsDirective, overlayService) {
+        this.grid = grid;
+        this.textFormatter = textFormatter;
+        this.chartsDirective = chartsDirective;
+        this.overlayService = overlayService;
+        this.onButtonClose = new EventEmitter();
+        this.formatters = [];
+        this.charts = [];
+        this.gridResizeNotify = new Subject();
+        this._collapsed = true;
+        this.destroy$ = new Subject();
+        this._analyticsBtnSettings = {
+            closeOnOutsideClick: false,
+            modal: false
+        };
+    }
+    ngOnInit() {
+        this.gridResizeNotify.pipe(takeUntil(this.destroy$))
+            .subscribe(() => {
+            if (this._id && !this._collapsed) {
+                this.renderButton();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.setUpGridListeners();
+        if (this.textFormatter) {
+            this.textFormatter.onFormattersReady.pipe(takeUntil(this.destroy$))
+                .subscribe(names => this.formatters = names);
+        }
+        if (this.chartsDirective) {
+            this.chartsDirective.onChartTypesDetermined.pipe(takeUntil(this.destroy$))
+                .subscribe((args) => this.charts = args.chartsForCreation);
+        }
+        this.overlayService.opening.pipe(takeUntil(this.destroy$))
+            .subscribe((args) => {
+            if (args.componentRef) {
+                const instance = args.componentRef.instance;
+                instance.contextDirective = this;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+        if (!this._collapsed) {
+            this.close();
+        }
+    }
+    setUpGridListeners() {
+        this.contentObserver = new ResizeObserver(() => this.gridResizeNotify.next());
+        this.contentObserver.observe(this.grid.nativeElement);
+        this.grid.rangeSelected.pipe(takeUntil(this.destroy$))
+            .subscribe((args) => {
+            this._range = args;
+            if (this.chartsDirective) {
+                if (this.grid.getSelectedRanges().length === 1) {
+                    this.chartsDirective.chartData = this.grid.getSelectedData();
+                }
+                else {
+                    this.chartsDirective.chartData = [];
+                }
+            }
+            if (!this._collapsed) {
+                this.onButtonClose.emit();
+            }
+            this.renderButton();
+        });
+        this.grid.verticalScrollContainer.chunkLoad.pipe(merge(this.grid.parentVirtDir.chunkLoad, this.grid.filteringDone, this.grid.columnResized, this.grid.columnVisibilityChanged.pipe(debounceTime(30))), filter(() => this._range), takeUntil(this.destroy$)).subscribe(() => {
+            this.onButtonClose.emit();
+            this.renderButton();
+        });
+        this.grid.selected.pipe(merge(this.grid.pagingDone, this.grid.onGroupingDone, this.grid.perPageChange), takeUntil(this.destroy$)).subscribe((args) => {
+            if (this.grid.selectedCells.length < 2 || args.expressions) {
+                this._range = undefined;
+                this.close();
+            }
+        });
+    }
+    renderButton() {
+        if (!this._range) {
+            return;
+        }
+        let rowIndex = this._range.rowEnd;
+        let colIndex = +this._range.columnEnd;
+        while (colIndex >= this._range.columnStart && !this.grid.navigation.isColumnFullyVisible(colIndex)) {
+            colIndex--;
+        }
+        while (rowIndex >= this._range.rowStart && this.grid.navigation.shouldPerformVerticalScroll(rowIndex, -1)) {
+            rowIndex--;
+        }
+        const field = this.grid.visibleColumns[colIndex] ? this.grid.visibleColumns[colIndex].field : '';
+        const cell = this.grid.gridAPI.get_cell_by_index(rowIndex, field);
+        if (!cell || !this.isWithInRange(cell.row.key, cell.column.index - 1)) {
+            this.close();
+            return;
+        }
+        this._analyticsBtnSettings.positionStrategy = new AutoPositionStrategy({
+            horizontalDirection: HorizontalAlignment.Right,
+            horizontalStartPoint: HorizontalAlignment.Right,
+            verticalStartPoint: VerticalAlignment.Bottom,
+            verticalDirection: VerticalAlignment.Bottom, closeAnimation: null,
+            target: cell.nativeElement
+        });
+        this._analyticsBtnSettings.scrollStrategy = new AbsoluteScrollStrategy();
+        const info = this.overlayService.getOverlayById(this._id);
+        if (info) {
+            info.settings.positionStrategy = this._analyticsBtnSettings.positionStrategy;
+        }
+        this._collapsed ? this.show() : this.overlayService.reposition(this._id);
+    }
+    show() {
+        if (!this._collapsed) {
+            return;
+        }
+        this._collapsed = false;
+        this._id = this._id ? this._id :
+            this.overlayService.attach(IgxContextMenuComponent, this._analyticsBtnSettings);
+        this.overlayService.show(this._id);
+    }
+    close() {
+        if (this._collapsed) {
+            return;
+        }
+        this._collapsed = true;
+        this.overlayService.hide(this._id);
+        this.onButtonClose.emit();
+        this._id = undefined;
+    }
+    isWithInRange(rInex, cIndex) {
+        return rInex >= this._range.rowStart && rInex <= this._range.rowEnd
+            && cIndex >= this._range.columnStart && cIndex <= this._range.columnEnd;
+    }
+}
+IgxContextMenuDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxContextMenuDirective, deps: [{ token: i1.IgxGridComponent }, { token: i2.IgxConditionalFormattingDirective, optional: true }, { token: i3.IgxChartIntegrationDirective, optional: true }, { token: i1.IgxOverlayService }], target: i0.ɵɵFactoryTarget.Directive });
+IgxContextMenuDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: IgxContextMenuDirective, selector: "[igxContextMenu]", outputs: { onButtonClose: "onButtonClose" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxContextMenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igxContextMenu]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IgxGridComponent }, { type: i2.IgxConditionalFormattingDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i3.IgxChartIntegrationDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i1.IgxOverlayService }]; }, propDecorators: { onButtonClose: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"igx-context-menu.directive.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular-extras/src/lib/context-menu/igx-context-menu.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, EventEmitter, Optional, Output, OnInit, OnDestroy } from '@angular/core';\r\nimport { AbsoluteScrollStrategy, AutoPositionStrategy, HorizontalAlignment, IgxGridComponent,\r\n    IgxOverlayService, OverlayCancelableEventArgs, VerticalAlignment, OverlaySettings } from '@infragistics/igniteui-angular';\r\nimport { Subject } from 'rxjs';\r\nimport { debounceTime, filter, merge, takeUntil } from 'rxjs/operators';\r\nimport { IgxChartIntegrationDirective } from '../directives/chart-integration/chart-integration.directive';\r\nimport { IgxConditionalFormattingDirective } from '../directives/conditional-formatting/conditional-formatting.directive';\r\nimport { IgxContextMenuComponent } from './context-menu.component';\r\nimport { ResizeObserver } from '@juggle/resize-observer';\r\n\r\n@Directive({\r\n    selector: '[igxContextMenu]'\r\n})\r\nexport class IgxContextMenuDirective implements OnInit, AfterViewInit, OnDestroy {\r\n\r\n    @Output() public onButtonClose = new EventEmitter<any>();\r\n\r\n    public formatters = [];\r\n    public charts = [];\r\n    public gridResizeNotify = new Subject();\r\n    private contentObserver: ResizeObserver;\r\n    private _range;\r\n    private _id;\r\n    private _collapsed = true;\r\n    private destroy$ = new Subject<any>();\r\n    private _analyticsBtnSettings: OverlaySettings = {\r\n        closeOnOutsideClick: false,\r\n        modal: false\r\n    };\r\n    constructor(public grid: IgxGridComponent,\r\n                @Optional() public textFormatter: IgxConditionalFormattingDirective,\r\n                @Optional() public chartsDirective: IgxChartIntegrationDirective,\r\n                private overlayService: IgxOverlayService) { }\r\n\r\n    public ngOnInit () {\r\n        this.gridResizeNotify.pipe(takeUntil(this.destroy$))\r\n        .subscribe(() => {\r\n                if (this._id && !this._collapsed) {\r\n                    this.renderButton();\r\n                }\r\n        });\r\n    }\r\n\r\n    public ngAfterViewInit() {\r\n        this.setUpGridListeners();\r\n        if (this.textFormatter) {\r\n            this.textFormatter.onFormattersReady.pipe(takeUntil(this.destroy$))\r\n                .subscribe(names => this.formatters = names);\r\n        }\r\n        if (this.chartsDirective) {\r\n            this.chartsDirective.onChartTypesDetermined.pipe(takeUntil(this.destroy$))\r\n                .subscribe((args) => this.charts = args.chartsForCreation);\r\n        }\r\n        this.overlayService.opening.pipe(takeUntil(this.destroy$))\r\n            .subscribe((args: OverlayCancelableEventArgs) => {\r\n                if (args.componentRef) {\r\n                    const instance = (args.componentRef.instance as IgxContextMenuComponent);\r\n                    instance.contextDirective = this;\r\n                }\r\n            });\r\n    }\r\n\r\n    public ngOnDestroy(): void {\r\n        this.destroy$.next(true);\r\n        this.destroy$.complete();\r\n        if (!this._collapsed) {\r\n            this.close();\r\n        }\r\n    }\r\n\r\n    private setUpGridListeners() {\r\n        this.contentObserver = new ResizeObserver(() => this.gridResizeNotify.next());\r\n        this.contentObserver.observe(this.grid.nativeElement);\r\n\r\n        this.grid.rangeSelected.pipe(takeUntil(this.destroy$))\r\n            .subscribe((args) => {\r\n                this._range = args;\r\n                if (this.chartsDirective ) {\r\n                    if ( this.grid.getSelectedRanges().length === 1) {\r\n                        this.chartsDirective.chartData = this.grid.getSelectedData();\r\n                    } else {\r\n                        this.chartsDirective.chartData = [];\r\n                    }\r\n                }\r\n                if (!this._collapsed) {\r\n                    this.onButtonClose.emit();\r\n                 }\r\n                this.renderButton();\r\n            });\r\n        this.grid.verticalScrollContainer.chunkLoad.pipe(\r\n            merge(this.grid.parentVirtDir.chunkLoad, this.grid.filteringDone, this.grid.columnResized,\r\n                this.grid.columnVisibilityChanged.pipe(debounceTime(30))),\r\n            filter(() => this._range), takeUntil(this.destroy$)).subscribe(() => {\r\n                this.onButtonClose.emit();\r\n                this.renderButton();\r\n            });\r\n        this.grid.selected.pipe(merge(this.grid.pagingDone, this.grid.onGroupingDone, this.grid.perPageChange),\r\n            takeUntil(this.destroy$)).subscribe((args: any) => {\r\n                if (this.grid.selectedCells.length < 2 || args.expressions) {\r\n                    this._range = undefined;\r\n                    this.close();\r\n                }\r\n            });\r\n    }\r\n\r\n    private renderButton() {\r\n        if (!this._range) { return; }\r\n        let rowIndex = this._range.rowEnd;\r\n        let colIndex = +this._range.columnEnd;\r\n        while (colIndex >= this._range.columnStart && !this.grid.navigation.isColumnFullyVisible(colIndex)) {\r\n            colIndex--;\r\n        }\r\n        while (rowIndex >= this._range.rowStart && this.grid.navigation.shouldPerformVerticalScroll(rowIndex, -1)) {\r\n            rowIndex--;\r\n        }\r\n        const field = this.grid.visibleColumns[colIndex] ? this.grid.visibleColumns[colIndex].field : '';\r\n        const cell = this.grid.gridAPI.get_cell_by_index(rowIndex, field);\r\n        if (!cell || !this.isWithInRange(cell.row.key, cell.column.index - 1)) {\r\n            this.close();\r\n            return;\r\n        }\r\n        this._analyticsBtnSettings.positionStrategy = new AutoPositionStrategy({\r\n            horizontalDirection: HorizontalAlignment.Right,\r\n            horizontalStartPoint: HorizontalAlignment.Right,\r\n            verticalStartPoint: VerticalAlignment.Bottom,\r\n            verticalDirection: VerticalAlignment.Bottom, closeAnimation: null,\r\n            target: cell.nativeElement\r\n        });\r\n        this._analyticsBtnSettings.scrollStrategy = new AbsoluteScrollStrategy();\r\n        const info = this.overlayService.getOverlayById(this._id);\r\n        if (info) {\r\n            info.settings.positionStrategy = this._analyticsBtnSettings.positionStrategy;\r\n        }\r\n        this._collapsed ? this.show() : this.overlayService.reposition(this._id);\r\n    }\r\n\r\n    private show() {\r\n        if (!this._collapsed) { return; }\r\n        this._collapsed = false;\r\n        this._id = this._id ? this._id :\r\n            this.overlayService.attach(IgxContextMenuComponent, this._analyticsBtnSettings);\r\n        this.overlayService.show(this._id);\r\n    }\r\n\r\n    private close() {\r\n        if (this._collapsed) { return; }\r\n        this._collapsed = true;\r\n        this.overlayService.hide(this._id);\r\n        this.onButtonClose.emit();\r\n        this._id = undefined;\r\n    }\r\n\r\n    private isWithInRange(rInex, cIndex) {\r\n        return rInex >= this._range.rowStart && rInex <= this._range.rowEnd\r\n            && cIndex >= this._range.columnStart && cIndex <= this._range.columnEnd;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/directives/chart-integration/chart-integration.directive.mjs

@@ -0,0 +1,312 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { IgxAreaSeriesComponent, IgxBarSeriesComponent, IgxBubbleSeriesComponent, IgxColumnSeriesComponent, IgxDataChartComponent, IgxItemLegendComponent, IgxLegendComponent, IgxLineSeriesComponent, IgxPieChartComponent, IgxScatterLineSeriesComponent, IgxScatterSeriesComponent, IgxSizeScaleComponent, IgxStacked100AreaSeriesComponent, IgxStacked100BarSeriesComponent, IgxStacked100ColumnSeriesComponent, IgxStacked100LineSeriesComponent, IgxStackedAreaSeriesComponent, IgxStackedBarSeriesComponent, IgxStackedColumnSeriesComponent, IgxStackedLineSeriesComponent } from 'igniteui-angular-charts';
+import { CHART_TYPE } from './chart-types';
+import { IgxDataChartInitializer, IgxPieChartInitializer, IgxStackedDataChartInitializer } from './initializers';
+import * as i0 from "@angular/core";
+export class IgxChartIntegrationDirective {
+    get chartData() {
+        return this._chartData;
+    }
+    set chartData(selectedData) {
+        const charts = new Set(this._dataChartTypes);
+        const dataModel = selectedData.length ? selectedData[0] : {};
+        this._labelMemberPaths = Object.keys(dataModel).filter(key => typeof dataModel[key] === 'string');
+        this._valueMemberPaths = Object.keys(dataModel).filter(key => typeof dataModel[key] === 'number');
+        this._chartData = selectedData.map((dataRecord, index) => this.addIndexMemberPath(dataRecord, index + 1));
+        const args = {
+            chartsAvailabilty: new Map(),
+            chartsForCreation: []
+        };
+        if (selectedData.length === 0 || this._valueMemberPaths.length === 0) {
+            this.onChartTypesDetermined.emit(args);
+            return;
+        }
+        if (selectedData.length === 1) {
+            charts.forEach((chart, _, set) => {
+                const isColumnChart = chart.indexOf('Column') !== -1;
+                const isBarChart = chart.indexOf('Bar') !== -1;
+                const isPieChart = chart.indexOf('Pie') !== -1;
+                if (!(isColumnChart || isBarChart || isPieChart)) {
+                    set.delete(chart);
+                }
+            });
+        }
+        // Config pie chart
+        const cannotCreatePieChart = selectedData.some(record => record[this._valueMemberPaths[0]] <= 0);
+        if (cannotCreatePieChart) {
+            charts.delete(CHART_TYPE.PIE);
+        }
+        // Config scatter chart member paths
+        const canCreateScatterChart = this._valueMemberPaths.length >= 2;
+        const canCreateBubbleChart = this._valueMemberPaths.length >= 3;
+        if (!canCreateScatterChart) {
+            charts.delete(CHART_TYPE.SCATTER_BUBBLE);
+            charts.delete(CHART_TYPE.SCATTER_LINE);
+            charts.delete(CHART_TYPE.SCATTER_POINT);
+        }
+        if (!canCreateBubbleChart) {
+            charts.delete(CHART_TYPE.SCATTER_BUBBLE);
+        }
+        args.chartsAvailabilty = this.chartTypesAvailability;
+        args.chartsForCreation = [...charts];
+        this.onChartTypesDetermined.emit(args);
+    }
+    set scatterChartYAxisValueMemberPath(path) {
+        this._scatterChartYAxisValueMemberPath = path;
+    }
+    get scatterChartYAxisValueMemberPath() {
+        return this._scatterChartYAxisValueMemberPath &&
+            this._valueMemberPaths.indexOf(this._scatterChartYAxisValueMemberPath) !== -1 ?
+            this._scatterChartYAxisValueMemberPath : this._valueMemberPaths[0];
+    }
+    set bubbleChartRadiusMemberPath(path) {
+        this._bubbleChartRadiusMemberPath = path;
+    }
+    get bubbleChartRadiusMemberPath() {
+        return this._bubbleChartRadiusMemberPath &&
+            this._valueMemberPaths.indexOf(this._bubbleChartRadiusMemberPath) !== -1 ?
+            this._bubbleChartRadiusMemberPath : this._valueMemberPaths[1];
+    }
+    get _labelMemberPath() {
+        return this.defaultLabelMemberPath && this._chartData.some(r => r[this.defaultLabelMemberPath] !== undefined) ?
+            this.defaultLabelMemberPath : this._labelMemberPaths.length > 0 ? this._labelMemberPaths[0] : 'Index';
+    }
+    get pieChartOptions() {
+        return {
+            width: '85%',
+            height: '75%',
+            dataSource: this.chartData,
+            valueMemberPath: this._valueMemberPaths[0],
+            legendLabelMemberPath: this._labelMemberPath,
+            labelMemberPath: this._labelMemberPath,
+        };
+    }
+    get dataChartOptions() {
+        return {
+            width: '100%',
+            height: '85%',
+            autoMarginWidth: 50,
+            isVerticalZoomEnabled: true,
+            isHorizontalZoomEnabled: true,
+            dataSource: this.chartData
+        };
+    }
+    constructor(factoryResolver) {
+        this.factoryResolver = factoryResolver;
+        this.onChartTypesDetermined = new EventEmitter();
+        this.onChartCreationDone = new EventEmitter();
+        this.useLegend = true;
+        this.defaultLabelMemberPath = undefined;
+        this.chartTypesAvailability = new Map();
+        this.customChartComponentOptions = new Map();
+        this.dataCharts = new Map();
+        this._scatterChartYAxisValueMemberPath = undefined;
+        this._bubbleChartRadiusMemberPath = undefined;
+        this._valueMemberPaths = [];
+        this._labelMemberPaths = [];
+        this._sizeScale = new IgxSizeScaleComponent();
+        this._dataChartTypes = new Set();
+        this.dataChartSeriesOptionsModel = {
+            isHighlightingEnabled: true,
+            areaFillOpacity: .4,
+            markerType: 3,
+            showDefaultTooltip: true
+        };
+        this.scatterChartSeriesOptionsModel = {
+            markerType: 3,
+            showDefaultTooltip: true
+        };
+        this.bubbleChartSeriesOptionsModel = {
+            radiusScale: this._sizeScale
+        };
+        this.dataCharts.set(CHART_TYPE.COLUMN_GROUPED, IgxColumnSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.AREA_GROUPED, IgxAreaSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.LINE_GROUPED, IgxLineSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.BAR_GROUPED, IgxBarSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.COLUMN_STACKED, IgxStackedColumnSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.AREA_STACKED, IgxStackedAreaSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.LINE_STACKED, IgxStackedLineSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.BAR_STACKED, IgxStackedBarSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.COLUMN_100_STACKED, IgxStacked100ColumnSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.AREA_100_STACKED, IgxStacked100AreaSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.LINE_100_STACKED, IgxStacked100LineSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.BAR_100_STACKED, IgxStacked100BarSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.SCATTER_POINT, IgxScatterSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.SCATTER_BUBBLE, IgxBubbleSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.SCATTER_LINE, IgxScatterLineSeriesComponent);
+        this.dataCharts.set(CHART_TYPE.PIE, IgxPieChartComponent);
+        const iterable = this.dataCharts.keys();
+        for (let head = iterable.next().value; head !== undefined; head = iterable.next().value) {
+            this._dataChartTypes.add(head);
+            this.chartTypesAvailability.set(head, true);
+            this.customChartComponentOptions.set(head, {});
+        }
+    }
+    getAvailableCharts() {
+        const res = [];
+        this.chartTypesAvailability.forEach((isAvailable, chartType) => {
+            if (isAvailable) {
+                res.push(chartType);
+            }
+        });
+        return res;
+    }
+    disableCharts(types) {
+        types.forEach(type => {
+            if (this.chartTypesAvailability.get(type)) {
+                this.chartTypesAvailability.set(type, false);
+            }
+        });
+    }
+    enableCharts(types) {
+        types.forEach(type => {
+            if (!this.chartTypesAvailability.get(type)) {
+                this.chartTypesAvailability.set(type, true);
+            }
+        });
+    }
+    chartFactory(type, viewContainerRef) {
+        if (!this.chartTypesAvailability.get(type)) {
+            return;
+        }
+        let componentFactory;
+        let componentRef;
+        this._sizeScale.maximumValue = 60;
+        this._sizeScale.minimumValue = 10;
+        const chartType = this.dataCharts.get(type);
+        if (type === CHART_TYPE.PIE) {
+            componentFactory = this.factoryResolver.resolveComponentFactory(IgxPieChartComponent);
+            componentRef = viewContainerRef.createComponent(componentFactory);
+        }
+        else {
+            componentFactory = this.factoryResolver.resolveComponentFactory(IgxDataChartComponent);
+            componentRef = viewContainerRef.createComponent(componentFactory);
+        }
+        const options = this.getChartOptions(type);
+        const initializer = this.getInitializer(type, chartType);
+        if (this.useLegend) {
+            const legendType = type === CHART_TYPE.PIE ? IgxItemLegendComponent : IgxLegendComponent;
+            const legendFactory = this.factoryResolver.resolveComponentFactory(legendType);
+            const legendComponentRef = viewContainerRef.createComponent(legendFactory);
+            options.chartOptions['legend'] = legendComponentRef.instance;
+        }
+        const chart = initializer.initChart(componentRef.instance, options);
+        this.onChartCreationDone.emit(chart);
+    }
+    getInitializer(chartType, componentClassRef) {
+        if (chartType.includes('Pie')) {
+            return new IgxPieChartInitializer();
+        }
+        else if (chartType.includes('Stacked')) {
+            return new IgxStackedDataChartInitializer(componentClassRef);
+        }
+        else {
+            return new IgxDataChartInitializer(componentClassRef);
+        }
+    }
+    getChartOptions(type) {
+        const chartComponentOptions = {};
+        return type === CHART_TYPE.PIE ? this.addPieChartDataOptions(chartComponentOptions) :
+            this.addDataChartDataOptions(type, chartComponentOptions, type.includes('Stacked'));
+    }
+    addPieChartDataOptions(chartComponentOptions) {
+        // tslint:disable-next-line: max-line-length
+        chartComponentOptions.chartOptions = Object.assign(this.pieChartOptions, this.customChartComponentOptions.get(CHART_TYPE.PIE).chartOptions);
+        return chartComponentOptions;
+    }
+    addDataChartDataOptions(type, chartComponentOptions, stacked) {
+        chartComponentOptions.chartOptions = Object.assign(this.dataChartOptions, this.customChartComponentOptions.get(type));
+        if (type.indexOf('Scatter') !== -1) {
+            this.addScatterChartDataOptions(type, chartComponentOptions);
+        }
+        else {
+            // tslint:disable-next-line: max-line-length
+            chartComponentOptions.seriesModel = Object.assign(this.dataChartSeriesOptionsModel, this.customChartComponentOptions.get(type).seriesModel);
+            this.setAxisLabelOption(type, chartComponentOptions);
+            const options = [];
+            this._valueMemberPaths.forEach(valueMemberPath => {
+                const dataOptions = {
+                    title: valueMemberPath,
+                    valueMemberPath
+                };
+                if (stacked) {
+                    options.push({ ...dataOptions });
+                }
+                else {
+                    options.push({ ...dataOptions, ...chartComponentOptions.seriesModel });
+                }
+            });
+            stacked ? chartComponentOptions.stackedFragmentOptions = options :
+                chartComponentOptions.seriesOptions = options;
+        }
+        return chartComponentOptions;
+    }
+    addScatterChartDataOptions(scatterChart, chartComponentOptions) {
+        // tslint:disable-next-line: max-line-length
+        chartComponentOptions.seriesModel = Object.assign(this.scatterChartSeriesOptionsModel, this.customChartComponentOptions.get(scatterChart).seriesModel);
+        chartComponentOptions.seriesModel['yMemberPath'] = this.scatterChartYAxisValueMemberPath;
+        if (scatterChart === CHART_TYPE.SCATTER_BUBBLE) {
+            chartComponentOptions.seriesModel = Object.assign(chartComponentOptions.seriesModel, this.bubbleChartSeriesOptionsModel);
+            chartComponentOptions.seriesModel['radiusMemberPath'] = this.bubbleChartRadiusMemberPath;
+        }
+        const model = chartComponentOptions.seriesModel;
+        const seriesOptions = [];
+        this._valueMemberPaths.filter(v => !(v === model['yMemberPath'] ||
+            v === model['radiusMemberPath'])).forEach(valueMemberPath => {
+            const dataOptions = {
+                title: `${model['yMemberPath']} vs ${valueMemberPath}`,
+                xMemberPath: valueMemberPath,
+                labelMemberPath: this._labelMemberPath
+            };
+            seriesOptions.push({ ...dataOptions, ...model });
+        });
+        chartComponentOptions.seriesOptions = seriesOptions;
+    }
+    addIndexMemberPath(dataRecord, index) {
+        dataRecord = { ...{ [this._labelMemberPath]: index }, ...dataRecord };
+        return dataRecord;
+    }
+    setAxisLabelOption(type, options) {
+        if (type.indexOf('Bar') !== -1) {
+            options.yAxisOptions = Object.assign({
+                label: this._labelMemberPath
+            }, this.customChartComponentOptions.get(type).yAxisOptions);
+        }
+        else {
+            options.xAxisOptions = Object.assign({
+                label: this._labelMemberPath
+            }, this.customChartComponentOptions.get(type).xAxisOptions);
+        }
+    }
+    setChartComponentOptions(chart, optionsType, options) {
+        if (!this.customChartComponentOptions.get(chart)[optionsType]) {
+            this.customChartComponentOptions.get(chart)[optionsType] = {};
+        }
+        Object.keys(options).forEach(property => {
+            this.customChartComponentOptions.get(chart)[optionsType][property] = options[property];
+        });
+    }
+}
+IgxChartIntegrationDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxChartIntegrationDirective, deps: [{ token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Directive });
+IgxChartIntegrationDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: IgxChartIntegrationDirective, selector: "[igxChartIntegration]", inputs: { chartData: "chartData", useLegend: "useLegend", defaultLabelMemberPath: "defaultLabelMemberPath", scatterChartYAxisValueMemberPath: "scatterChartYAxisValueMemberPath", bubbleChartRadiusMemberPath: "bubbleChartRadiusMemberPath" }, outputs: { onChartTypesDetermined: "onChartTypesDetermined", onChartCreationDone: "onChartCreationDone" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxChartIntegrationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igxChartIntegration]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }]; }, propDecorators: { chartData: [{
+                type: Input
+            }], onChartTypesDetermined: [{
+                type: Output
+            }], onChartCreationDone: [{
+                type: Output
+            }], useLegend: [{
+                type: Input
+            }], defaultLabelMemberPath: [{
+                type: Input
+            }], scatterChartYAxisValueMemberPath: [{
+                type: Input
+            }], bubbleChartRadiusMemberPath: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-integration.directive.js","sourceRoot":"","sources":["../../../../../../projects/igniteui-angular-extras/src/lib/directives/chart-integration/chart-integration.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentFactory, ComponentFactoryResolver, ComponentRef, Directive,\r\n    EventEmitter, Input, Output, Type, ViewContainerRef } from '@angular/core';\r\nimport {\r\n    IgxAreaSeriesComponent, IgxBarSeriesComponent, IgxBubbleSeriesComponent, IgxColumnSeriesComponent,\r\n    IgxDataChartComponent, IgxItemLegendComponent, IgxLegendComponent, IgxLineSeriesComponent, IgxPieChartComponent,\r\n    IgxScatterLineSeriesComponent, IgxScatterSeriesComponent, IgxSizeScaleComponent, IgxStacked100AreaSeriesComponent,\r\n    IgxStacked100BarSeriesComponent, IgxStacked100ColumnSeriesComponent, IgxStacked100LineSeriesComponent,\r\n    IgxStackedAreaSeriesComponent, IgxStackedBarSeriesComponent, IgxStackedColumnSeriesComponent,\r\n    IgxStackedLineSeriesComponent\r\n} from 'igniteui-angular-charts';\r\nimport { CHART_TYPE, OPTIONS_TYPE } from './chart-types';\r\nimport { ChartInitializer, IChartComponentOptions, IgxDataChartInitializer,\r\n    IgxPieChartInitializer, IgxStackedDataChartInitializer, IOptions } from './initializers';\r\n\r\nexport interface IDeterminedChartTypesArgs {\r\n    chartsAvailabilty: Map<CHART_TYPE, boolean>;\r\n    chartsForCreation: CHART_TYPE[];\r\n}\r\n\r\n@Directive({\r\n    selector: '[igxChartIntegration]'\r\n})\r\nexport class IgxChartIntegrationDirective {\r\n    @Input()\r\n    public get chartData() {\r\n        return this._chartData;\r\n    }\r\n\r\n    public set chartData(selectedData: any[]) {\r\n        const charts = new Set(this._dataChartTypes);\r\n        const dataModel = selectedData.length ? selectedData[0] : {};\r\n        this._labelMemberPaths = Object.keys(dataModel).filter(key => typeof dataModel[key] === 'string');\r\n        this._valueMemberPaths = Object.keys(dataModel).filter(key => typeof dataModel[key] === 'number');\r\n        this._chartData = selectedData.map((dataRecord, index) => this.addIndexMemberPath(dataRecord, index + 1));\r\n        const args: IDeterminedChartTypesArgs = {\r\n            chartsAvailabilty: new Map<CHART_TYPE, boolean>(),\r\n            chartsForCreation: []\r\n        };\r\n\r\n        if (selectedData.length === 0 || this._valueMemberPaths.length === 0) {\r\n            this.onChartTypesDetermined.emit(args);\r\n            return;\r\n        }\r\n        if (selectedData.length === 1) {\r\n            charts.forEach((chart, _, set) => {\r\n                const isColumnChart = chart.indexOf('Column') !== -1;\r\n                const isBarChart = chart.indexOf('Bar') !== -1;\r\n                const isPieChart = chart.indexOf('Pie') !== -1;\r\n                if (!(isColumnChart || isBarChart || isPieChart)) {\r\n                    set.delete(chart);\r\n                }\r\n            });\r\n        }\r\n        // Config pie chart\r\n        const cannotCreatePieChart = selectedData.some(record => record[this._valueMemberPaths[0]] <= 0);\r\n        if (cannotCreatePieChart) {\r\n            charts.delete(CHART_TYPE.PIE);\r\n        }\r\n        // Config scatter chart member paths\r\n        const canCreateScatterChart = this._valueMemberPaths.length >= 2;\r\n        const canCreateBubbleChart = this._valueMemberPaths.length >= 3;\r\n        if (!canCreateScatterChart) {\r\n            charts.delete(CHART_TYPE.SCATTER_BUBBLE);\r\n            charts.delete(CHART_TYPE.SCATTER_LINE);\r\n            charts.delete(CHART_TYPE.SCATTER_POINT);\r\n        }\r\n        if (!canCreateBubbleChart) {\r\n            charts.delete(CHART_TYPE.SCATTER_BUBBLE);\r\n        }\r\n\r\n        args.chartsAvailabilty = this.chartTypesAvailability;\r\n        args.chartsForCreation = [...charts];\r\n        this.onChartTypesDetermined.emit(args);\r\n    }\r\n\r\n    @Output()\r\n    public onChartTypesDetermined = new EventEmitter<IDeterminedChartTypesArgs>();\r\n\r\n    @Output()\r\n    public onChartCreationDone = new EventEmitter<any>();\r\n\r\n    @Input()\r\n    public useLegend = true;\r\n\r\n    @Input()\r\n    public defaultLabelMemberPath: string = undefined;\r\n\r\n    @Input()\r\n    public set scatterChartYAxisValueMemberPath(path: string) {\r\n        this._scatterChartYAxisValueMemberPath = path;\r\n    }\r\n\r\n    public get scatterChartYAxisValueMemberPath() {\r\n        return this._scatterChartYAxisValueMemberPath &&\r\n            this._valueMemberPaths.indexOf(this._scatterChartYAxisValueMemberPath) !== -1 ?\r\n            this._scatterChartYAxisValueMemberPath : this._valueMemberPaths[0];\r\n    }\r\n\r\n    @Input()\r\n    public set bubbleChartRadiusMemberPath(path: string) {\r\n        this._bubbleChartRadiusMemberPath = path;\r\n    }\r\n\r\n    public get bubbleChartRadiusMemberPath() {\r\n        return this._bubbleChartRadiusMemberPath &&\r\n            this._valueMemberPaths.indexOf(this._bubbleChartRadiusMemberPath) !== -1 ?\r\n            this._bubbleChartRadiusMemberPath : this._valueMemberPaths[1];\r\n    }\r\n\r\n    private chartTypesAvailability = new Map<CHART_TYPE, boolean>();\r\n    private customChartComponentOptions = new Map<CHART_TYPE, IChartComponentOptions>();\r\n    private dataCharts = new Map<string, Type<any>>();\r\n    private _scatterChartYAxisValueMemberPath = undefined;\r\n    private _bubbleChartRadiusMemberPath = undefined;\r\n    private _valueMemberPaths = [];\r\n    private _labelMemberPaths = [];\r\n    private _chartData: any[];\r\n    private _sizeScale = new IgxSizeScaleComponent();\r\n    private _dataChartTypes = new Set<CHART_TYPE>();\r\n    private get _labelMemberPath(): string {\r\n        return this.defaultLabelMemberPath && this._chartData.some(r => r[this.defaultLabelMemberPath] !== undefined) ?\r\n            this.defaultLabelMemberPath : this._labelMemberPaths.length > 0 ? this._labelMemberPaths[0] : 'Index';\r\n    }\r\n\r\n    private get pieChartOptions(): IOptions {\r\n        return {\r\n            width: '85%',\r\n            height: '75%',\r\n            dataSource: this.chartData,\r\n            valueMemberPath: this._valueMemberPaths[0],\r\n            legendLabelMemberPath: this._labelMemberPath,\r\n            labelMemberPath: this._labelMemberPath,\r\n        };\r\n    }\r\n\r\n    private dataChartSeriesOptionsModel: IOptions = {\r\n        isHighlightingEnabled: true,\r\n        areaFillOpacity: .4,\r\n        markerType: 3,\r\n        showDefaultTooltip: true\r\n    };\r\n\r\n    private scatterChartSeriesOptionsModel: IOptions = {\r\n        markerType: 3,\r\n        showDefaultTooltip: true\r\n    };\r\n\r\n    private bubbleChartSeriesOptionsModel: IOptions = {\r\n        radiusScale: this._sizeScale\r\n    };\r\n\r\n    private get dataChartOptions(): IOptions {\r\n        return {\r\n            width: '100%',\r\n            height: '85%',\r\n            autoMarginWidth: 50,\r\n            isVerticalZoomEnabled: true,\r\n            isHorizontalZoomEnabled: true,\r\n            dataSource: this.chartData\r\n        };\r\n    }\r\n    constructor(private factoryResolver: ComponentFactoryResolver) {\r\n        this.dataCharts.set(CHART_TYPE.COLUMN_GROUPED, IgxColumnSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.AREA_GROUPED, IgxAreaSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.LINE_GROUPED, IgxLineSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.BAR_GROUPED, IgxBarSeriesComponent);\r\n\r\n        this.dataCharts.set(CHART_TYPE.COLUMN_STACKED, IgxStackedColumnSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.AREA_STACKED, IgxStackedAreaSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.LINE_STACKED, IgxStackedLineSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.BAR_STACKED, IgxStackedBarSeriesComponent);\r\n\r\n        this.dataCharts.set(CHART_TYPE.COLUMN_100_STACKED, IgxStacked100ColumnSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.AREA_100_STACKED, IgxStacked100AreaSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.LINE_100_STACKED, IgxStacked100LineSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.BAR_100_STACKED, IgxStacked100BarSeriesComponent);\r\n\r\n        this.dataCharts.set(CHART_TYPE.SCATTER_POINT, IgxScatterSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.SCATTER_BUBBLE, IgxBubbleSeriesComponent);\r\n        this.dataCharts.set(CHART_TYPE.SCATTER_LINE, IgxScatterLineSeriesComponent);\r\n\r\n        this.dataCharts.set(CHART_TYPE.PIE, IgxPieChartComponent);\r\n        const iterable = this.dataCharts.keys();\r\n        for (let head = iterable.next().value; head !== undefined; head = iterable.next().value) {\r\n            this._dataChartTypes.add(head);\r\n            this.chartTypesAvailability.set(head, true);\r\n            this.customChartComponentOptions.set(head, {});\r\n        }\r\n    }\r\n\r\n    public getAvailableCharts() {\r\n        const res = [];\r\n        this.chartTypesAvailability.forEach((isAvailable, chartType) => {\r\n            if (isAvailable) {\r\n                res.push(chartType);\r\n            }\r\n        });\r\n        return res;\r\n    }\r\n\r\n    public disableCharts(types: CHART_TYPE[]) {\r\n        types.forEach(type => {\r\n            if (this.chartTypesAvailability.get(type)) {\r\n                this.chartTypesAvailability.set(type, false);\r\n            }\r\n        });\r\n    }\r\n\r\n    public enableCharts(types: CHART_TYPE[]) {\r\n        types.forEach(type => {\r\n            if (!this.chartTypesAvailability.get(type)) {\r\n                this.chartTypesAvailability.set(type, true);\r\n            }\r\n        });\r\n    }\r\n\r\n    public chartFactory(type: CHART_TYPE, viewContainerRef: ViewContainerRef) {\r\n        if (!this.chartTypesAvailability.get(type)) {\r\n            return;\r\n        }\r\n        let componentFactory: ComponentFactory<any>;\r\n        let componentRef: ComponentRef<any>;\r\n        this._sizeScale.maximumValue = 60;\r\n        this._sizeScale.minimumValue = 10;\r\n        const chartType = this.dataCharts.get(type);\r\n\r\n        if (type === CHART_TYPE.PIE) {\r\n            componentFactory = this.factoryResolver.resolveComponentFactory(IgxPieChartComponent);\r\n            componentRef = viewContainerRef.createComponent(componentFactory);\r\n        } else {\r\n            componentFactory = this.factoryResolver.resolveComponentFactory(IgxDataChartComponent);\r\n            componentRef = viewContainerRef.createComponent(componentFactory);\r\n        }\r\n        const options: IChartComponentOptions = this.getChartOptions(type);\r\n        const initializer: ChartInitializer = this.getInitializer(type, chartType);\r\n        if (this.useLegend) {\r\n            const legendType = type === CHART_TYPE.PIE ? IgxItemLegendComponent : IgxLegendComponent;\r\n            const legendFactory = this.factoryResolver.resolveComponentFactory(legendType as any);\r\n            const legendComponentRef: ComponentRef<any> = viewContainerRef.createComponent(legendFactory);\r\n            options.chartOptions['legend'] = legendComponentRef.instance;\r\n        }\r\n        const chart = initializer.initChart(componentRef.instance, options);\r\n        this.onChartCreationDone.emit(chart);\r\n    }\r\n\r\n    private getInitializer(chartType: CHART_TYPE, componentClassRef): ChartInitializer {\r\n        if (chartType.includes('Pie')) {\r\n            return new IgxPieChartInitializer();\r\n        } else if (chartType.includes('Stacked')) {\r\n            return new IgxStackedDataChartInitializer(componentClassRef);\r\n        } else {\r\n            return new IgxDataChartInitializer(componentClassRef);\r\n        }\r\n    }\r\n\r\n    private getChartOptions(type: CHART_TYPE): IChartComponentOptions {\r\n        const chartComponentOptions: IChartComponentOptions = {};\r\n        return type === CHART_TYPE.PIE ? this.addPieChartDataOptions(chartComponentOptions) :\r\n            this.addDataChartDataOptions(type, chartComponentOptions, type.includes('Stacked'));\r\n    }\r\n\r\n    private addPieChartDataOptions(chartComponentOptions: IChartComponentOptions) {\r\n        // tslint:disable-next-line: max-line-length\r\n        chartComponentOptions.chartOptions = Object.assign(this.pieChartOptions, this.customChartComponentOptions.get(CHART_TYPE.PIE).chartOptions);\r\n        return chartComponentOptions;\r\n    }\r\n\r\n    private addDataChartDataOptions(type: CHART_TYPE, chartComponentOptions: IChartComponentOptions, stacked: boolean) {\r\n        chartComponentOptions.chartOptions = Object.assign(this.dataChartOptions, this.customChartComponentOptions.get(type));\r\n        if (type.indexOf('Scatter') !== -1) {\r\n            this.addScatterChartDataOptions(type, chartComponentOptions);\r\n        } else {\r\n            // tslint:disable-next-line: max-line-length\r\n            chartComponentOptions.seriesModel = Object.assign(this.dataChartSeriesOptionsModel, this.customChartComponentOptions.get(type).seriesModel);\r\n            this.setAxisLabelOption(type, chartComponentOptions);\r\n            const options: IOptions[] = [];\r\n            this._valueMemberPaths.forEach(valueMemberPath => {\r\n                const dataOptions = {\r\n                    title: valueMemberPath,\r\n                    valueMemberPath\r\n                };\r\n                if (stacked) {\r\n                    options.push({ ...dataOptions });\r\n                } else {\r\n                    options.push({ ...dataOptions, ...chartComponentOptions.seriesModel });\r\n                }\r\n            });\r\n            stacked ? chartComponentOptions.stackedFragmentOptions = options :\r\n            chartComponentOptions.seriesOptions = options;\r\n        }\r\n        return chartComponentOptions;\r\n    }\r\n\r\n    private addScatterChartDataOptions(scatterChart: CHART_TYPE, chartComponentOptions: IChartComponentOptions) {\r\n                // tslint:disable-next-line: max-line-length\r\n        chartComponentOptions.seriesModel = Object.assign(this.scatterChartSeriesOptionsModel, this.customChartComponentOptions.get(scatterChart).seriesModel);\r\n        chartComponentOptions.seriesModel['yMemberPath'] = this.scatterChartYAxisValueMemberPath;\r\n        if (scatterChart === CHART_TYPE.SCATTER_BUBBLE) {\r\n            chartComponentOptions.seriesModel = Object.assign(chartComponentOptions.seriesModel, this.bubbleChartSeriesOptionsModel);\r\n            chartComponentOptions.seriesModel['radiusMemberPath'] = this.bubbleChartRadiusMemberPath;\r\n        }\r\n\r\n        const model = chartComponentOptions.seriesModel;\r\n        const seriesOptions: IOptions[] = [];\r\n        this._valueMemberPaths.filter(v => !(v === model['yMemberPath'] ||\r\n            v === model['radiusMemberPath'])).forEach(valueMemberPath => {\r\n                const dataOptions = {\r\n                    title: `${model['yMemberPath']} vs ${valueMemberPath}`,\r\n                    xMemberPath: valueMemberPath,\r\n                    labelMemberPath: this._labelMemberPath\r\n                };\r\n                seriesOptions.push({ ...dataOptions, ...model });\r\n            });\r\n        chartComponentOptions.seriesOptions = seriesOptions;\r\n    }\r\n\r\n    private addIndexMemberPath(dataRecord, index) {\r\n        dataRecord = { ...{ [this._labelMemberPath]: index }, ...dataRecord };\r\n        return dataRecord;\r\n    }\r\n\r\n    private setAxisLabelOption(type: CHART_TYPE, options: IChartComponentOptions) {\r\n        if (type.indexOf('Bar') !== -1) {\r\n            options.yAxisOptions = Object.assign({\r\n                label: this._labelMemberPath\r\n            }, this.customChartComponentOptions.get(type).yAxisOptions);\r\n        } else {\r\n            options.xAxisOptions = Object.assign({\r\n                label: this._labelMemberPath\r\n            }, this.customChartComponentOptions.get(type).xAxisOptions);\r\n        }\r\n    }\r\n\r\n    public setChartComponentOptions(chart: CHART_TYPE, optionsType: OPTIONS_TYPE, options: IOptions) {\r\n        if (!this.customChartComponentOptions.get(chart)[optionsType]) {\r\n            this.customChartComponentOptions.get(chart)[optionsType] = {};\r\n        }\r\n        Object.keys(options).forEach(property => {\r\n                this.customChartComponentOptions.get(chart)[optionsType][property] = options[property];\r\n        });\r\n    }\r\n\r\n}\r\n"]}

package/esm2020/lib/directives/chart-integration/chart-types.mjs

@@ -0,0 +1,28 @@
+export var CHART_TYPE;
+(function (CHART_TYPE) {
+    CHART_TYPE["PIE"] = "Pie";
+    CHART_TYPE["COLUMN_GROUPED"] = "ColumnGrouped";
+    CHART_TYPE["AREA_GROUPED"] = "AreaGrouped";
+    CHART_TYPE["LINE_GROUPED"] = "LineGrouped";
+    CHART_TYPE["BAR_GROUPED"] = "BarGrouped";
+    CHART_TYPE["COLUMN_STACKED"] = "ColumnStacked";
+    CHART_TYPE["AREA_STACKED"] = "AreaStacked";
+    CHART_TYPE["LINE_STACKED"] = "LineStacked";
+    CHART_TYPE["BAR_STACKED"] = "BarStacked";
+    CHART_TYPE["COLUMN_100_STACKED"] = "Column100Stacked";
+    CHART_TYPE["AREA_100_STACKED"] = "Area100Stacked";
+    CHART_TYPE["LINE_100_STACKED"] = "Line100Stacked";
+    CHART_TYPE["BAR_100_STACKED"] = "Bar100Stacked";
+    CHART_TYPE["SCATTER_POINT"] = "ScatterPoint";
+    CHART_TYPE["SCATTER_BUBBLE"] = "ScatterBubble";
+    CHART_TYPE["SCATTER_LINE"] = "ScatterLine";
+})(CHART_TYPE || (CHART_TYPE = {}));
+export var OPTIONS_TYPE;
+(function (OPTIONS_TYPE) {
+    OPTIONS_TYPE["CHART"] = "chartOptions";
+    OPTIONS_TYPE["SERIES"] = "seriesModel";
+    OPTIONS_TYPE["X_AXIS"] = "xAxisOptions";
+    OPTIONS_TYPE["Y_AXIS"] = "yAxisOptions";
+    OPTIONS_TYPE["STACKED_SERIES"] = "stackedFragmentOptions";
+})(OPTIONS_TYPE || (OPTIONS_TYPE = {}));
+//# sourceMappingURL=data:application/json;base64,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