igniteui-angular-extras 15.0.11

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

@@ -0,0 +1,103 @@
+// tslint:disable: max-line-length
+import { EventEmitter } from '@angular/core';
+import { IgxBarSeriesComponent, IgxBubbleSeriesComponent, IgxCategoryXAxisComponent, IgxCategoryYAxisComponent, IgxNumericXAxisComponent, IgxNumericYAxisComponent, IgxScatterLineSeriesComponent, IgxScatterSeriesComponent, IgxStacked100BarSeriesComponent, IgxStackedBarSeriesComponent, IgxStackedFragmentSeriesComponent } from 'igniteui-angular-charts';
+class SeriesFactory {
+    create(type) {
+        return new type();
+    }
+}
+export class ChartInitializer {
+    constructor() {
+        this.seriesFactory = new SeriesFactory();
+    }
+    applyOptions(target, options) {
+        if (options) {
+            Object.keys(options).forEach(key => {
+                if (target[key] instanceof EventEmitter) {
+                    target[key].subscribe(options[key]);
+                }
+                else {
+                    target[key] = options[key];
+                }
+            });
+        }
+    }
+}
+export class IgxPieChartInitializer extends ChartInitializer {
+    constructor() {
+        super();
+    }
+    initChart(chart, options) {
+        this.applyOptions(chart, options.chartOptions);
+        return chart;
+    }
+}
+export class IgxDataChartInitializer extends ChartInitializer {
+    constructor(seriesType) {
+        super();
+        switch (seriesType) {
+            case IgxBarSeriesComponent:
+                this.xAxis = new IgxNumericXAxisComponent();
+                this.yAxis = new IgxCategoryYAxisComponent();
+                break;
+            case IgxScatterSeriesComponent:
+            case IgxBubbleSeriesComponent:
+            case IgxScatterLineSeriesComponent:
+                this.xAxis = new IgxNumericXAxisComponent();
+                this.yAxis = new IgxNumericYAxisComponent();
+                break;
+            default:
+                this.xAxis = new IgxCategoryXAxisComponent();
+                this.yAxis = new IgxNumericYAxisComponent();
+        }
+        this.seriesType = seriesType;
+    }
+    initChart(chart, options) {
+        options.seriesOptions.forEach((option) => {
+            const series = this.seriesFactory.create(this.seriesType);
+            series.xAxis = this.xAxis;
+            series.yAxis = this.yAxis;
+            this.applyOptions(series, option);
+            chart.series.add(series);
+        });
+        this.applyOptions(chart, options.chartOptions);
+        this.applyOptions(this.xAxis, options.xAxisOptions);
+        this.applyOptions(this.yAxis, options.yAxisOptions);
+        chart.axes.add(this.xAxis);
+        chart.axes.add(this.yAxis);
+        return chart;
+    }
+}
+export class IgxStackedDataChartInitializer extends ChartInitializer {
+    constructor(seriesType) {
+        super();
+        if (seriesType === IgxStackedBarSeriesComponent || seriesType === IgxStacked100BarSeriesComponent) {
+            this.xAxis = new IgxNumericXAxisComponent();
+            this.yAxis = new IgxCategoryYAxisComponent();
+        }
+        else {
+            this.xAxis = new IgxCategoryXAxisComponent();
+            this.yAxis = new IgxNumericYAxisComponent();
+        }
+        this.seriesType = seriesType;
+    }
+    initChart(chart, options) {
+        const series = this.seriesFactory.create(this.seriesType);
+        series.xAxis = this.xAxis;
+        series.yAxis = this.yAxis;
+        options.stackedFragmentOptions.forEach(fragOpt => {
+            const frag = new IgxStackedFragmentSeriesComponent();
+            this.applyOptions(frag, fragOpt);
+            series.series.add(frag);
+        });
+        this.applyOptions(series, options.seriesOptions);
+        this.applyOptions(chart, options.chartOptions);
+        this.applyOptions(this.xAxis, options.xAxisOptions);
+        this.applyOptions(this.yAxis, options.yAxisOptions);
+        chart.series.add(series);
+        chart.axes.add(this.xAxis);
+        chart.axes.add(this.yAxis);
+        return chart;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializers.js","sourceRoot":"","sources":["../../../../../../projects/igniteui-angular-extras/src/lib/directives/chart-integration/initializers.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable: max-line-length\r\nimport { EventEmitter, Type } from '@angular/core';\r\nimport { IgxBarSeriesComponent, IgxBubbleSeriesComponent, IgxCategoryXAxisComponent,\r\n    IgxCategoryYAxisComponent, IgxDataChartComponent, IgxNumericXAxisComponent,\r\n    IgxNumericYAxisComponent, IgxPieChartComponent, IgxScatterLineSeriesComponent,\r\n    IgxScatterSeriesComponent, IgxStacked100BarSeriesComponent, IgxStackedBarSeriesComponent,\r\n    IgxStackedFragmentSeriesComponent } from 'igniteui-angular-charts';\r\n\r\nclass SeriesFactory {\r\n    public create<T>(type: (new () => T)): T {\r\n        return new type();\r\n    }\r\n}\r\n\r\nexport interface IOptions {\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IChartComponentOptions {\r\n     chartOptions?: IOptions;\r\n     seriesOptions?: IOptions[];\r\n     xAxisOptions?: IOptions;\r\n     seriesModel?: IOptions;\r\n     yAxisOptions?: IOptions;\r\n     stackedFragmentOptions?: IOptions;\r\n}\r\n\r\nexport abstract class ChartInitializer {\r\n    protected yAxis;\r\n    protected xAxis;\r\n    protected seriesFactory = new SeriesFactory();\r\n    constructor() { }\r\n\r\n    public applyOptions(target: any, options: IOptions) {\r\n        if (options) {\r\n            Object.keys(options).forEach(key => {\r\n                if (target[key] instanceof EventEmitter) {\r\n                    target[key].subscribe(options[key]);\r\n                } else {\r\n                    target[key] = options[key];\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    public abstract initChart(chart: any, options?: IChartComponentOptions): any;\r\n}\r\n\r\nexport class IgxPieChartInitializer extends ChartInitializer {\r\n    constructor() {\r\n        super();\r\n    }\r\n\r\n    public initChart(chart: IgxPieChartComponent, options: IChartComponentOptions) {\r\n\r\n        this.applyOptions(chart, options.chartOptions);\r\n        return chart;\r\n    }\r\n}\r\n\r\nexport class IgxDataChartInitializer extends ChartInitializer {\r\n    public seriesType: Type<any>;\r\n\r\n    constructor(seriesType: Type<any>) {\r\n        super();\r\n        switch (seriesType) {\r\n            case IgxBarSeriesComponent:\r\n                this.xAxis =  new IgxNumericXAxisComponent();\r\n                this.yAxis =  new IgxCategoryYAxisComponent();\r\n                break;\r\n            case IgxScatterSeriesComponent:\r\n            case IgxBubbleSeriesComponent:\r\n            case IgxScatterLineSeriesComponent:\r\n                this.xAxis =  new IgxNumericXAxisComponent();\r\n                this.yAxis =  new IgxNumericYAxisComponent();\r\n                break;\r\n            default:\r\n                this.xAxis =  new IgxCategoryXAxisComponent();\r\n                this.yAxis =  new IgxNumericYAxisComponent();\r\n        }\r\n\r\n        this.seriesType = seriesType;\r\n    }\r\n\r\n    public initChart(chart: IgxDataChartComponent, options: IChartComponentOptions): IgxDataChartComponent {\r\n        options.seriesOptions.forEach((option) => {\r\n            const series = this.seriesFactory.create(this.seriesType);\r\n            series.xAxis = this.xAxis;\r\n            series.yAxis = this.yAxis;\r\n            this.applyOptions(series, option);\r\n            chart.series.add(series);\r\n        });\r\n        this.applyOptions(chart, options.chartOptions);\r\n        this.applyOptions(this.xAxis, options.xAxisOptions);\r\n        this.applyOptions(this.yAxis, options.yAxisOptions);\r\n        chart.axes.add(this.xAxis);\r\n        chart.axes.add(this.yAxis);\r\n        return chart;\r\n    }\r\n}\r\n\r\nexport class IgxStackedDataChartInitializer extends ChartInitializer {\r\n    public seriesType: Type<any>;\r\n\r\n    constructor(seriesType: Type<any>) {\r\n        super();\r\n        if (seriesType === IgxStackedBarSeriesComponent || seriesType === IgxStacked100BarSeriesComponent) {\r\n            this.xAxis = new IgxNumericXAxisComponent();\r\n            this.yAxis = new IgxCategoryYAxisComponent();\r\n         } else {\r\n            this.xAxis = new IgxCategoryXAxisComponent();\r\n            this.yAxis = new IgxNumericYAxisComponent();\r\n         }\r\n        this.seriesType = seriesType;\r\n    }\r\n    public initChart(chart: IgxDataChartComponent, options?: IChartComponentOptions): IgxDataChartComponent {\r\n        const series = this.seriesFactory.create(this.seriesType);\r\n        series.xAxis = this.xAxis;\r\n        series.yAxis = this.yAxis;\r\n        options.stackedFragmentOptions.forEach(fragOpt => {\r\n            const frag = new IgxStackedFragmentSeriesComponent();\r\n            this.applyOptions(frag, fragOpt);\r\n            series.series.add(frag);\r\n        });\r\n        this.applyOptions(series, options.seriesOptions);\r\n        this.applyOptions(chart, options.chartOptions);\r\n        this.applyOptions(this.xAxis, options.xAxisOptions);\r\n        this.applyOptions(this.yAxis, options.yAxisOptions);\r\n        chart.series.add(series);\r\n        chart.axes.add(this.xAxis);\r\n        chart.axes.add(this.yAxis);\r\n        return chart;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/directives/conditional-formatting/conditional-formatting.directive.mjs

@@ -0,0 +1,311 @@
+import { Directive, EventEmitter, Inject, Input, Output } from '@angular/core';
+import { IgxGridComponent } from '@infragistics/igniteui-angular';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@infragistics/igniteui-angular";
+export var ConditionalFormattingType;
+(function (ConditionalFormattingType) {
+    ConditionalFormattingType["dataBars"] = "Data Bars";
+    ConditionalFormattingType["colorScale"] = "Color Scale";
+    ConditionalFormattingType["top10"] = "Top 10";
+    ConditionalFormattingType["textContains"] = "Text Contains";
+    ConditionalFormattingType["single"] = "Duplicate Values";
+    ConditionalFormattingType["unique"] = "Unique Values";
+    ConditionalFormattingType["empty"] = "Empty";
+})(ConditionalFormattingType || (ConditionalFormattingType = {}));
+export class IgxConditionalFormattingDirective {
+    set formatColors(val) {
+        this._formatColors = val;
+    }
+    get formatColors() {
+        return this._formatColors;
+    }
+    get selectedData() {
+        if (!this._selectedData.length) {
+            this._selectedData = this.toArray(this.grid.getSelectedData());
+        }
+        return this._selectedData;
+    }
+    get textData() {
+        return this.selectedData.filter(val => typeof val === 'string');
+    }
+    get numericData() {
+        return this.selectedData.filter(val => typeof val === 'number');
+    }
+    constructor(grid) {
+        this.grid = grid;
+        this.onFormattersReady = new EventEmitter();
+        this.colorScale = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (!(typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname))) {
+                    return;
+                }
+                return this.lowTresholdValue >= cellValue ? this.formatColors.error :
+                    this.middleTresholdValue >= cellValue ? this.formatColors.warning : this.formatColors.success;
+            }
+        };
+        this.dataBars = {
+            backgroundImage: (rowData, colname, cellValue, rowIndex) => {
+                if (!(typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname))) {
+                    return;
+                }
+                const treshold = this.threshold;
+                let gradientPercents;
+                if (cellValue < 0) {
+                    const negativeStartingPoint = 100 - treshold;
+                    gradientPercents = this.getNegativePercentage(cellValue);
+                    return `linear-gradient(to left, transparent 0% ${negativeStartingPoint}%,
+                    ${this.formatColors.error} ${negativeStartingPoint}% ${negativeStartingPoint + gradientPercents}%,
+                    transparent ${gradientPercents}% 100%)`;
+                }
+                else {
+                    gradientPercents = this.getPositivePercentage(cellValue);
+                    return `linear-gradient(to right, transparent 0% ${treshold}%,
+                    ${this.formatColors.success} ${treshold}% ${treshold + gradientPercents}%,
+                    transparent ${treshold + gradientPercents}% 100%)`;
+                }
+            },
+            backgroundSize: '100% 80%',
+            backgroundRepeat: 'no-repeat',
+            backgroundPositionY: 'center'
+        };
+        this.top10Percent = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)
+                    && cellValue > this.top10PercentTreshold) {
+                    return this.formatColors.info;
+                }
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)
+                    && cellValue > this.top10PercentTreshold) {
+                    return this.formatColors.text;
+                }
+            }
+        };
+        this.greaterThan = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)
+                    && cellValue > this.avgValue) {
+                    return this.formatColors.info;
+                }
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)
+                    && cellValue > this.avgValue) {
+                    return this.formatColors.text;
+                }
+            }
+        };
+        this.empty = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (this.isWithInFormattedRange(rowIndex, colname) && cellValue === undefined) {
+                    return this.formatColors.info;
+                }
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (this.isWithInFormattedRange(rowIndex, colname) && cellValue === undefined) {
+                    return this.formatColors.text;
+                }
+            }
+        };
+        this.duplicates = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (!this.isWithInFormattedRange(rowIndex, colname)) {
+                    return;
+                }
+                const arr = typeof cellValue === 'number' ? this.numericData : this.textData;
+                return arr.indexOf(cellValue) !== arr.lastIndexOf(cellValue) ? this.formatColors.info : '';
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (!this.isWithInFormattedRange(rowIndex, colname)) {
+                    return;
+                }
+                const arr = typeof cellValue === 'number' ? this.numericData : this.textData;
+                return arr.indexOf(cellValue) !== arr.lastIndexOf(cellValue) ? this.formatColors.text : '';
+            }
+        };
+        this.textContains = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'string' && this.isWithInFormattedRange(rowIndex, colname) &&
+                    cellValue.toLowerCase().indexOf(this._valueForComparison.toLowerCase()) !== -1) {
+                    return this.formatColors.info;
+                }
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (typeof cellValue === 'string' && this.isWithInFormattedRange(rowIndex, colname) &&
+                    cellValue.toLowerCase().indexOf(this._valueForComparison.toLowerCase()) !== -1) {
+                    return this.formatColors.text;
+                }
+            }
+        };
+        this.uniques = {
+            backgroundColor: (rowData, colname, cellValue, rowIndex) => {
+                if (!this.isWithInFormattedRange(rowIndex, colname)) {
+                    return;
+                }
+                const arr = typeof cellValue === 'number' ? this.numericData : this.textData;
+                return arr.indexOf(cellValue) === arr.lastIndexOf(cellValue) ? this.formatColors.info : '';
+            },
+            color: (rowData, colname, cellValue, rowIndex) => {
+                if (!this.isWithInFormattedRange(rowIndex, colname)) {
+                    return;
+                }
+                const arr = typeof cellValue === 'number' ? this.numericData : this.textData;
+                return arr.indexOf(cellValue) === arr.lastIndexOf(cellValue) ? this.formatColors.text : '';
+            }
+        };
+        this._formatColors = {
+            success: '#4EB862',
+            error: '#FF134A',
+            warning: '#FBB13C',
+            info: '#1377D5',
+            text: '#FFF'
+        };
+        this._numericFormatters = ['Data Bars', 'Color Scale', 'Top 10', 'Greater Than'];
+        this._textFormatters = ['Text Contains'];
+        this._commonFormattersName = ['Duplicate Values', 'Unique Values', 'Empty'];
+        this._selectedData = [];
+        this._formattersData = new Map();
+        this.destroy$ = new Subject();
+        this.formatedRange = new Map();
+        this._formattersData.set('Data Bars', this.dataBars);
+        this._formattersData.set('Color Scale', this.colorScale);
+        this._formattersData.set('Top 10', this.top10Percent);
+        this._formattersData.set('Greater Than', this.greaterThan);
+        this._formattersData.set('Text Contains', this.textContains);
+        this._formattersData.set('Duplicate Values', this.duplicates);
+        this._formattersData.set('Unique Values', this.uniques);
+        this._formattersData.set('Empty', this.empty);
+    }
+    ngAfterViewInit() {
+        this.grid.rangeSelected.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.determineFormatters();
+        });
+        this.grid.cellEdit.pipe(takeUntil(this.destroy$)).subscribe((args) => {
+            if ((args.newValue === args.oldValue || !this.formatter)) {
+                return;
+            }
+            if (this.isWithInFormattedRange(args.cellID.rowIndex, args.cellID.columnID - 1)) {
+                const value = Number(args.newValue);
+                const valueToBeAdded = !Number.isNaN(value) && Number.isFinite(value) ? value : args.newValue;
+                this.selectedData.splice(this.selectedData.indexOf(args.oldValue), 1, valueToBeAdded);
+                this.recalcCachedValues();
+                this.formatCells(this.formatter, undefined, false);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+    formatCells(formatterName, formatRange, reset = true) {
+        if (reset) {
+            this.resetRange(formatRange);
+        }
+        this.clearFormatting();
+        this.formatter = formatterName;
+        this.grid.visibleColumns.forEach(c => {
+            if (c.visibleIndex >= this._startColumn && c.visibleIndex <= this._endColumn) {
+                c.cellStyles = this._formattersData.get(this.formatter);
+                this.grid.notifyChanges();
+            }
+        });
+    }
+    clearFormatting() {
+        this.formatter = undefined;
+        this.grid.visibleColumns.forEach(c => {
+            c.cellStyles = undefined;
+            this.grid.cdr.detectChanges();
+        });
+    }
+    determineFormatters() {
+        const numericData = this.toArray(this.grid.getSelectedData()).some(rec => typeof rec === 'number');
+        const textData = this.toArray(this.grid.getSelectedData()).some(rec => typeof rec === 'string');
+        const formatters = Array.of(...this._commonFormattersName);
+        if (!(numericData) && textData) {
+            formatters.splice(0, 0, ...this._textFormatters);
+        }
+        else if (numericData && !textData) {
+            formatters.splice(0, 0, ...this._numericFormatters);
+        }
+        else {
+            formatters.splice(0, 0, ...['Data Bars', 'Color Scale', 'Text Contains']);
+        }
+        this.onFormattersReady.emit(formatters);
+    }
+    recalcCachedValues(clearAll = false) {
+        if (clearAll) {
+            this._startColumn = Math.min(...this.grid.getSelectedRanges().map(r => Number(r.columnStart)));
+            this._endColumn = Math.max(...this.grid.getSelectedRanges().map(r => Number(r.columnEnd)));
+            this._selectedData = [];
+        }
+        this._valueForComparison = this.textData[0];
+        this._maxValue = Math.max(...this.numericData);
+        this._minValue = Math.min(...this.numericData.filter(value => value < 0)) | 0;
+    }
+    isWithInFormattedRange(rowIndex, colID) {
+        const visibleIndex = typeof colID === 'string' ? this.grid.getColumnByName(colID).visibleIndex : colID;
+        if (!this.formatedRange.size) {
+            return false;
+        }
+        return this.formatedRange.has(rowIndex) && this.formatedRange.get(rowIndex).has(visibleIndex);
+    }
+    get middleTresholdValue() { return 0.66 * Math.ceil(this._maxValue); }
+    get lowTresholdValue() { return 0.33 * Math.ceil(this._maxValue); }
+    get top10PercentTreshold() { return 0.9 * Math.ceil(this._maxValue); }
+    get avgValue() {
+        return Math.ceil((this.numericData.reduce((a, b) => a + b, 0)) / this.numericData.length);
+    }
+    get threshold() {
+        return Math.ceil(Math.abs(this._minValue) / (this._maxValue + Math.abs(this._minValue)) * 100);
+    }
+    getPositivePercentage(val) {
+        const result = (Math.ceil(val) / (this._maxValue + Math.abs(this._minValue))) * 100;
+        return Math.ceil(result);
+    }
+    getNegativePercentage(val) {
+        const result = (Math.abs(val) / (this._maxValue + Math.abs(this._minValue))) * 100;
+        return Math.ceil(result);
+    }
+    resetRange(formatRange) {
+        this.formatedRange.clear();
+        const customRange = formatRange ? formatRange : this.grid.getSelectedRanges();
+        customRange.forEach(range => {
+            for (let ri = range.rowStart; ri <= Number(range.rowEnd); ri++) {
+                for (let ci = Number(range.columnStart); ci <= Number(range.columnEnd); ci++) {
+                    this.addToCache(ri, ci);
+                }
+            }
+        });
+        this.recalcCachedValues(true);
+    }
+    addToCache(rowIndex, colIndex, selection = true) {
+        this.formatedRange.has(rowIndex) ? this.formatedRange.get(rowIndex).add(colIndex) :
+            this.formatedRange.set(rowIndex, new Set()).get(rowIndex).add(colIndex);
+    }
+    toArray(data) {
+        let result = [];
+        data.forEach(rec => result = result.concat(Object.values(rec)));
+        return result;
+    }
+}
+IgxConditionalFormattingDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxConditionalFormattingDirective, deps: [{ token: IgxGridComponent }], target: i0.ɵɵFactoryTarget.Directive });
+IgxConditionalFormattingDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: IgxConditionalFormattingDirective, selector: "[igxConditionalFormatting]", inputs: { formatter: "formatter", formatColors: "formatColors" }, outputs: { onFormattersReady: "onFormattersReady" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxConditionalFormattingDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igxConditionalFormatting]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IgxGridComponent, decorators: [{
+                    type: Inject,
+                    args: [IgxGridComponent]
+                }] }]; }, propDecorators: { formatter: [{
+                type: Input
+            }], formatColors: [{
+                type: Input
+            }], onFormattersReady: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conditional-formatting.directive.js","sourceRoot":"","sources":["../../../../../../projects/igniteui-angular-extras/src/lib/directives/conditional-formatting/conditional-formatting.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, EventEmitter, Inject, Input, OnDestroy, Output } from '@angular/core';\r\nimport { IgxGridComponent } from '@infragistics/igniteui-angular';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\n\r\nexport enum ConditionalFormattingType {\r\n    dataBars = 'Data Bars',\r\n    colorScale = 'Color Scale',\r\n    top10 = 'Top 10',\r\n    textContains = 'Text Contains',\r\n    single = 'Duplicate Values',\r\n    unique = 'Unique Values',\r\n    empty = 'Empty'\r\n}\r\nexport interface IFormatColors {\r\n    success: string;\r\n    error: string;\r\n    info: string;\r\n    warning: string;\r\n    text: string;\r\n}\r\n\r\n@Directive({\r\n    selector: '[igxConditionalFormatting]'\r\n})\r\nexport class IgxConditionalFormattingDirective implements AfterViewInit, OnDestroy {\r\n    @Input()\r\n    public formatter: string | ConditionalFormattingType;\r\n\r\n    @Input()\r\n    public set formatColors(val: IFormatColors)  {\r\n        this._formatColors = val;\r\n    }\r\n    public get formatColors() {\r\n        return this._formatColors;\r\n    }\r\n\r\n    @Output()\r\n    public onFormattersReady = new EventEmitter<string[]>();\r\n\r\n    public colorScale = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!(typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname))) { return; }\r\n            return this.lowTresholdValue >= cellValue ? this.formatColors.error :\r\n                this.middleTresholdValue >= cellValue ? this.formatColors.warning :  this.formatColors.success;\r\n        }\r\n    };\r\n\r\n    public dataBars = {\r\n        backgroundImage: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!(typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname))) { return; }\r\n            const treshold = this.threshold;\r\n            let gradientPercents;\r\n            if (cellValue < 0) {\r\n                const negativeStartingPoint = 100 - treshold;\r\n                gradientPercents = this.getNegativePercentage(cellValue);\r\n                return `linear-gradient(to left, transparent 0% ${negativeStartingPoint}%,\r\n                    ${ this.formatColors.error} ${negativeStartingPoint}% ${negativeStartingPoint + gradientPercents}%,\r\n                    transparent ${gradientPercents}% 100%)`;\r\n            } else {\r\n                gradientPercents = this.getPositivePercentage(cellValue);\r\n                return `linear-gradient(to right, transparent 0% ${treshold}%,\r\n                    ${ this.formatColors.success} ${treshold}% ${treshold + gradientPercents}%,\r\n                    transparent ${treshold + gradientPercents}% 100%)`;\r\n            }\r\n        },\r\n        backgroundSize: '100% 80%',\r\n        backgroundRepeat: 'no-repeat',\r\n        backgroundPositionY: 'center'\r\n    };\r\n\r\n    public top10Percent = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)\r\n                && cellValue > this.top10PercentTreshold) {\r\n                return  this.formatColors.info;\r\n            }\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)\r\n                && cellValue > this.top10PercentTreshold) {\r\n                return  this.formatColors.text;\r\n            }\r\n        }\r\n    };\r\n\r\n    public greaterThan = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)\r\n            && cellValue > this.avgValue) {\r\n                return  this.formatColors.info;\r\n            }\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'number' && this.isWithInFormattedRange(rowIndex, colname)\r\n            && cellValue > this.avgValue) {\r\n                return  this.formatColors.text;\r\n            }\r\n        }\r\n    };\r\n\r\n    public empty = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (this.isWithInFormattedRange(rowIndex, colname) && cellValue === undefined) {\r\n                return  this.formatColors.info;\r\n            }\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (this.isWithInFormattedRange(rowIndex, colname) && cellValue === undefined) {\r\n                return  this.formatColors.text;\r\n            }\r\n        }\r\n    };\r\n\r\n    public duplicates = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!this.isWithInFormattedRange(rowIndex, colname)) { return; }\r\n            const arr: any[] = typeof cellValue === 'number' ? this.numericData : this.textData;\r\n            return arr.indexOf(cellValue) !== arr.lastIndexOf(cellValue) ?  this.formatColors.info : '';\r\n\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!this.isWithInFormattedRange(rowIndex, colname)) { return; }\r\n            const arr: any[] = typeof cellValue === 'number' ? this.numericData : this.textData;\r\n            return arr.indexOf(cellValue) !== arr.lastIndexOf(cellValue) ?  this.formatColors.text : '';\r\n        }\r\n    };\r\n\r\n    public textContains = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'string' && this.isWithInFormattedRange(rowIndex, colname) &&\r\n                cellValue.toLowerCase().indexOf(this._valueForComparison.toLowerCase()) !== -1) {\r\n                return  this.formatColors.info;\r\n            }\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (typeof cellValue === 'string' && this.isWithInFormattedRange(rowIndex, colname) &&\r\n                cellValue.toLowerCase().indexOf(this._valueForComparison.toLowerCase()) !== -1) {\r\n                return  this.formatColors.text;\r\n            }\r\n        }\r\n    };\r\n\r\n    public uniques = {\r\n        backgroundColor: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!this.isWithInFormattedRange(rowIndex, colname)) { return; }\r\n            const arr: any[] = typeof cellValue === 'number' ? this.numericData : this.textData;\r\n            return arr.indexOf(cellValue) === arr.lastIndexOf(cellValue) ?  this.formatColors.info : '';\r\n        },\r\n        color: (rowData, colname, cellValue, rowIndex) => {\r\n            if (!this.isWithInFormattedRange(rowIndex, colname)) { return; }\r\n            const arr: any[] = typeof cellValue === 'number' ? this.numericData : this.textData;\r\n            return arr.indexOf(cellValue) === arr.lastIndexOf(cellValue) ?  this.formatColors.text : '';\r\n        }\r\n    };\r\n\r\n    private get selectedData() {\r\n        if (!this._selectedData.length) { this._selectedData = this.toArray(this.grid.getSelectedData()); }\r\n        return this._selectedData;\r\n    }\r\n\r\n    private get textData() {\r\n        return this.selectedData.filter(val => typeof val === 'string');\r\n    }\r\n\r\n    private get numericData() {\r\n        return this.selectedData.filter(val => typeof val === 'number');\r\n    }\r\n    private _formatColors: IFormatColors = {\r\n        success: '#4EB862',\r\n        error: '#FF134A',\r\n        warning: '#FBB13C',\r\n        info: '#1377D5',\r\n        text: '#FFF'\r\n    };\r\n    private _numericFormatters = ['Data Bars', 'Color Scale', 'Top 10', 'Greater Than'];\r\n    private _textFormatters = ['Text Contains'];\r\n    private _commonFormattersName = ['Duplicate Values', 'Unique Values', 'Empty'];\r\n    private _selectedData = [];\r\n    private _minValue;\r\n    private _maxValue;\r\n    private _startColumn;\r\n    private _endColumn;\r\n    private _valueForComparison;\r\n    private _formattersData = new Map<string, any>();\r\n    private destroy$ = new Subject<any>();\r\n    private formatedRange: Map<number, Set<number>> = new Map<number, Set<number>>();\r\n\r\n    constructor(@Inject(IgxGridComponent) public grid: IgxGridComponent) {\r\n        this._formattersData.set('Data Bars', this.dataBars);\r\n        this._formattersData.set('Color Scale', this.colorScale);\r\n        this._formattersData.set('Top 10', this.top10Percent);\r\n        this._formattersData.set('Greater Than', this.greaterThan);\r\n        this._formattersData.set('Text Contains', this.textContains);\r\n        this._formattersData.set('Duplicate Values', this.duplicates);\r\n        this._formattersData.set('Unique Values', this.uniques);\r\n        this._formattersData.set('Empty', this.empty);\r\n    }\r\n\r\n    public ngAfterViewInit(): void {\r\n        this.grid.rangeSelected.pipe(takeUntil(this.destroy$)).subscribe(() => {\r\n            this.determineFormatters();\r\n        });\r\n        this.grid.cellEdit.pipe(takeUntil(this.destroy$)).subscribe((args: any) => {\r\n            if ((args.newValue === args.oldValue || !this.formatter)) { return; }\r\n            if (this.isWithInFormattedRange(args.cellID.rowIndex, args.cellID.columnID - 1)) {\r\n                const value = Number(args.newValue);\r\n                const valueToBeAdded = !Number.isNaN(value) && Number.isFinite(value) ? value : args.newValue;\r\n                this.selectedData.splice(this.selectedData.indexOf(args.oldValue), 1, valueToBeAdded);\r\n                this.recalcCachedValues();\r\n                this.formatCells(this.formatter, undefined, false);\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    }\r\n\r\n    public formatCells(formatterName, formatRange?: [], reset = true) {\r\n        if (reset) { this.resetRange(formatRange); }\r\n        this.clearFormatting();\r\n        this.formatter = formatterName;\r\n        this.grid.visibleColumns.forEach(c => {\r\n            if (c.visibleIndex >= this._startColumn && c.visibleIndex <= this._endColumn) {\r\n                c.cellStyles = this._formattersData.get(this.formatter);\r\n                this.grid.notifyChanges();\r\n            }\r\n        });\r\n    }\r\n\r\n    public clearFormatting() {\r\n        this.formatter = undefined;\r\n        this.grid.visibleColumns.forEach(c => {\r\n            c.cellStyles = undefined;\r\n            this.grid.cdr.detectChanges();\r\n        });\r\n    }\r\n\r\n    public determineFormatters() {\r\n        const numericData = this.toArray(this.grid.getSelectedData()).some(rec => typeof rec === 'number');\r\n        const textData = this.toArray(this.grid.getSelectedData()).some(rec => typeof rec === 'string');\r\n        const formatters =  Array.of(...this._commonFormattersName);\r\n        if (!(numericData) && textData) {\r\n            formatters.splice(0, 0, ...this._textFormatters);\r\n        } else if (numericData && !textData) {\r\n            formatters.splice(0, 0, ...this._numericFormatters);\r\n        } else {\r\n            formatters.splice(0, 0, ...['Data Bars', 'Color Scale', 'Text Contains']);\r\n        }\r\n        this.onFormattersReady.emit(formatters);\r\n    }\r\n\r\n    public recalcCachedValues(clearAll = false) {\r\n        if (clearAll) {\r\n            this._startColumn = Math.min(...this.grid.getSelectedRanges().map(r => Number(r.columnStart)));\r\n            this._endColumn = Math.max(...this.grid.getSelectedRanges().map(r => Number(r.columnEnd)));\r\n            this._selectedData = [];\r\n        }\r\n        this._valueForComparison = this.textData[0];\r\n        this._maxValue = Math.max(...this.numericData);\r\n        this._minValue = Math.min(...this.numericData.filter(value => value < 0)) | 0;\r\n    }\r\n\r\n    public isWithInFormattedRange(rowIndex, colID) {\r\n        const visibleIndex = typeof colID === 'string' ? this.grid.getColumnByName(colID).visibleIndex : colID;\r\n        if (!this.formatedRange.size) { return false; }\r\n        return this.formatedRange.has(rowIndex) && this.formatedRange.get(rowIndex).has(visibleIndex);\r\n    }\r\n\r\n    private get middleTresholdValue() { return 0.66 * Math.ceil(this._maxValue); }\r\n\r\n    private get lowTresholdValue() { return 0.33 * Math.ceil(this._maxValue); }\r\n\r\n    private get top10PercentTreshold() { return 0.9 * Math.ceil(this._maxValue); }\r\n\r\n    private get avgValue() {\r\n        return Math.ceil((this.numericData.reduce((a, b) => a + b, 0)) / this.numericData.length);\r\n    }\r\n\r\n    private get threshold() {\r\n        return Math.ceil(Math.abs(this._minValue) / (this._maxValue + Math.abs(this._minValue)) * 100);\r\n    }\r\n\r\n    private getPositivePercentage(val) {\r\n        const result = (Math.ceil(val) / (this._maxValue + Math.abs(this._minValue))) * 100;\r\n        return Math.ceil(result);\r\n    }\r\n\r\n    private getNegativePercentage(val) {\r\n        const result = (Math.abs(val) / (this._maxValue + Math.abs(this._minValue))) * 100;\r\n        return Math.ceil(result);\r\n    }\r\n\r\n    private resetRange(formatRange?: []) {\r\n        this.formatedRange.clear();\r\n        const customRange = formatRange ? formatRange : this.grid.getSelectedRanges();\r\n        customRange.forEach(range => {\r\n            for (let ri = range.rowStart; ri <= Number(range.rowEnd); ri++) {\r\n                for (let ci = Number(range.columnStart); ci <= Number(range.columnEnd); ci++) {\r\n                    this.addToCache(ri, ci);\r\n                }\r\n            }\r\n        });\r\n        this.recalcCachedValues(true);\r\n    }\r\n\r\n    private addToCache(rowIndex, colIndex, selection = true) {\r\n        this.formatedRange.has(rowIndex) ? this.formatedRange.get(rowIndex).add(colIndex) :\r\n        this.formatedRange.set(rowIndex, new Set<number>()).get(rowIndex).add(colIndex);\r\n    }\r\n\r\n    private toArray(data: any[]) {\r\n        let result = [];\r\n        data.forEach(rec => result = result.concat(Object.values(rec)));\r\n        return result;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/igniteui-angular-extras.module.mjs

@@ -0,0 +1,104 @@
+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+// tslint:disable-next-line: max-line-length
+import { IgxButtonModule, IgxDividerModule, IgxGridModule, IgxTabsModule, IgxToggleModule, IgxIconModule } from '@infragistics/igniteui-angular';
+import { IgxBarSeriesModule, IgxCategoryChartModule, IgxCategoryXAxisModule, IgxDataChartCategoryModule, IgxDataChartCoreModule, IgxDataChartInteractivityModule, IgxDataChartScatterModule, IgxDataChartStackedModule, IgxItemLegendModule, IgxLegendModule, IgxNumericXAxisModule, IgxNumericYAxisModule } from 'igniteui-angular-charts';
+import { IgxPieChartModule } from 'igniteui-angular-charts';
+import { IgxChartMenuComponent } from './context-menu/chart-dialog/chart-dialog.component';
+import { IgxContextMenuComponent } from './context-menu/context-menu.component';
+import { IgxContextMenuDirective } from './context-menu/igx-context-menu.directive';
+import { IgxChartIntegrationDirective } from './directives/chart-integration/chart-integration.directive';
+import { IgxConditionalFormattingDirective } from './directives/conditional-formatting/conditional-formatting.directive';
+import { SvgPipe } from './pipes/svg.pipe';
+import * as i0 from "@angular/core";
+export class IgxExtrasModule {
+}
+IgxExtrasModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxExtrasModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+IgxExtrasModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.3", ngImport: i0, type: IgxExtrasModule, declarations: [IgxConditionalFormattingDirective,
+        IgxChartIntegrationDirective,
+        IgxContextMenuDirective,
+        IgxContextMenuComponent,
+        IgxChartMenuComponent,
+        SvgPipe], imports: [IgxButtonModule,
+        IgxDividerModule,
+        IgxGridModule,
+        IgxTabsModule,
+        IgxToggleModule,
+        IgxDataChartCategoryModule,
+        IgxDataChartCoreModule,
+        IgxLegendModule,
+        IgxDataChartInteractivityModule,
+        IgxNumericXAxisModule,
+        IgxNumericYAxisModule,
+        IgxCategoryXAxisModule,
+        IgxItemLegendModule,
+        IgxPieChartModule,
+        IgxDataChartStackedModule,
+        IgxDividerModule,
+        IgxDataChartScatterModule,
+        IgxBarSeriesModule,
+        IgxIconModule,
+        IgxCategoryChartModule], exports: [IgxConditionalFormattingDirective,
+        IgxChartIntegrationDirective,
+        IgxContextMenuDirective] });
+IgxExtrasModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxExtrasModule, imports: [IgxButtonModule,
+        IgxDividerModule,
+        IgxGridModule,
+        IgxTabsModule,
+        IgxToggleModule,
+        IgxDataChartCategoryModule,
+        IgxDataChartCoreModule,
+        IgxLegendModule,
+        IgxDataChartInteractivityModule,
+        IgxNumericXAxisModule,
+        IgxNumericYAxisModule,
+        IgxCategoryXAxisModule,
+        IgxItemLegendModule,
+        IgxPieChartModule,
+        IgxDataChartStackedModule,
+        IgxDividerModule,
+        IgxDataChartScatterModule,
+        IgxBarSeriesModule,
+        IgxIconModule,
+        IgxCategoryChartModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: IgxExtrasModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        IgxConditionalFormattingDirective,
+                        IgxChartIntegrationDirective,
+                        IgxContextMenuDirective,
+                        IgxContextMenuComponent,
+                        IgxChartMenuComponent,
+                        SvgPipe
+                    ],
+                    imports: [
+                        IgxButtonModule,
+                        IgxDividerModule,
+                        IgxGridModule,
+                        IgxTabsModule,
+                        IgxToggleModule,
+                        IgxDataChartCategoryModule,
+                        IgxDataChartCoreModule,
+                        IgxLegendModule,
+                        IgxDataChartInteractivityModule,
+                        IgxNumericXAxisModule,
+                        IgxNumericYAxisModule,
+                        IgxCategoryXAxisModule,
+                        IgxItemLegendModule,
+                        IgxPieChartModule,
+                        IgxDataChartStackedModule,
+                        IgxDividerModule,
+                        IgxDataChartScatterModule,
+                        IgxBarSeriesModule,
+                        IgxIconModule,
+                        IgxCategoryChartModule
+                    ],
+                    exports: [
+                        IgxConditionalFormattingDirective,
+                        IgxChartIntegrationDirective,
+                        IgxContextMenuDirective
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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