@po-ui/ng-components 5.22.0 → 6.0.0

package/esm2020/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-circular.component.mjs

@@ -0,0 +1,161 @@
+import { Directive, EventEmitter, Input, Output, ViewChildren } from '@angular/core';
+import { PoChartStartAngle, PoChartCompleteCircle, PoChartAngleStepInterval } from '../../helpers/po-chart-default-values.constant';
+import * as i0 from "@angular/core";
+const _c0 = ["svgPaths"];
+const _c1 = ["svgLabels"];
+export class PoChartCircularComponent {
+    constructor(ngZone, changeDetector) {
+        this.ngZone = ngZone;
+        this.changeDetector = changeDetector;
+        this.circularClick = new EventEmitter();
+        this.circularHover = new EventEmitter();
+        this.canDisplayLabels = false;
+        this.seriesLabels = [];
+        this.showLabels = false;
+    }
+    set options(value) {
+        if (!isNaN(value?.innerRadius)) {
+            this._options = value;
+            this.innerRadius = Math.min(Math.max(this._options.innerRadius, 0), 100);
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    set series(value) {
+        this._series = value;
+        this.animate = true;
+    }
+    get series() {
+        return this._series;
+    }
+    onSerieClick(selectedItem) {
+        this.circularClick.emit(selectedItem);
+    }
+    onSerieHover(selectedItem) {
+        this.circularHover.emit(selectedItem);
+    }
+    calculateAngle(data, totalValue) {
+        return (data / totalValue) * (Math.PI * 2);
+    }
+    drawSeries(series = [], height) {
+        this.seriesList = [];
+        this.showLabels = false;
+        this.totalValue = this.calculateTotalValue(series);
+        if (this.totalValue && this.totalValue > 0) {
+            this.seriesList = this.validateSeries(series);
+            this.changeDetector.detectChanges();
+            if (this.seriesList.length && this.svgPaths) {
+                this.initDrawPaths(this.seriesList, this.totalValue, height);
+            }
+        }
+    }
+    calculateTotalValue(series) {
+        return series.reduce((previousValue, serie) => {
+            const data = serie.data ? serie.data : serie.value;
+            return previousValue + (data > 0 ? data : 0);
+        }, 0);
+    }
+    calculateSerieCoordinates(series, totalValue, height) {
+        let startRadianAngle;
+        let endRadianAngle = PoChartStartAngle;
+        series.forEach((serie, index) => {
+            startRadianAngle = endRadianAngle;
+            endRadianAngle = startRadianAngle + this.calculateAngle(serie.data, totalValue) - PoChartCompleteCircle;
+            const coordinates = this.calculateCoordinates(height, startRadianAngle, endRadianAngle);
+            this.svgPaths.toArray()[index].applyCoordinates(coordinates);
+            this.showLabels = this.canDisplayLabels;
+        });
+    }
+    calculateCoordinatesWithAnimation(series, totalValue, height, startRadianAngle, endRadianAngle, currentRadianAngle = 0, seriesIndex = 0) {
+        const finishedCurrentSerie = currentRadianAngle > endRadianAngle;
+        const finishedAllSeries = seriesIndex === series.length;
+        if (finishedAllSeries) {
+            this.animate = false;
+            return;
+        }
+        if (finishedCurrentSerie) {
+            this.setSerieLabelCoordinates(seriesIndex);
+            currentRadianAngle = 0;
+            seriesIndex++;
+            startRadianAngle = startRadianAngle + endRadianAngle;
+            endRadianAngle =
+                seriesIndex < series.length ? this.calculateAngle(series[seriesIndex].data, totalValue) : undefined;
+        }
+        else {
+            currentRadianAngle += PoChartAngleStepInterval;
+            const currentEndRadianAngle = this.calculateCurrentEndAngle(currentRadianAngle, startRadianAngle, endRadianAngle);
+            const coordinates = this.calculateCoordinates(height, startRadianAngle, currentEndRadianAngle);
+            this.svgPaths.toArray()[seriesIndex].applyCoordinates(coordinates);
+        }
+        window.requestAnimationFrame(this.calculateCoordinatesWithAnimation.bind(this, series, totalValue, height, startRadianAngle, endRadianAngle, currentRadianAngle, seriesIndex));
+    }
+    calculateCurrentEndAngle(currentRadianAngle, startRadianAngle, endRadianAngle) {
+        const isSerieDrawCompleted = startRadianAngle + currentRadianAngle > startRadianAngle + endRadianAngle;
+        return isSerieDrawCompleted
+            ? startRadianAngle + endRadianAngle - PoChartCompleteCircle
+            : startRadianAngle + currentRadianAngle;
+    }
+    initDrawPaths(seriesList, totalValue, height) {
+        if (!this.animate) {
+            this.calculateSerieCoordinates(seriesList, totalValue, height);
+        }
+        else {
+            const startRadianAngle = PoChartStartAngle;
+            const endRadianAngle = this.calculateAngle(seriesList[0].data, totalValue);
+            this.ngZone.runOutsideAngular(() => this.calculateCoordinatesWithAnimation(seriesList, totalValue, height, startRadianAngle, endRadianAngle));
+        }
+    }
+    setSerieLabelCoordinates(index) {
+        if (this.svgLabels.toArray().length) {
+            this.svgLabels.toArray()[index].applyCoordinates(this.seriesLabels[index]);
+        }
+    }
+    validateSeries(series) {
+        return series.reduce((seriesList, serie) => {
+            const data = serie.data ?? serie.value;
+            if (data && data > 0) {
+                const color = serie.color;
+                const label = serie.label;
+                const tooltip = serie.tooltip;
+                const tooltipLabel = this.getTooltipLabel(data, label, tooltip);
+                seriesList = [...seriesList, { data, color, label, tooltipLabel }];
+            }
+            return seriesList;
+        }, []);
+    }
+}
+PoChartCircularComponent.ɵfac = function PoChartCircularComponent_Factory(t) { return new (t || PoChartCircularComponent)(i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoChartCircularComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoChartCircularComponent, viewQuery: function PoChartCircularComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+        i0.ɵɵviewQuery(_c1, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.svgPaths = _t);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.svgLabels = _t);
+    } }, inputs: { containerSize: ["p-container-size", "containerSize"], options: ["p-options", "options"], series: ["p-series", "series"] }, outputs: { circularClick: "p-circular-click", circularHover: "p-circular-hover" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartCircularComponent, [{
+        type: Directive
+    }], function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, { containerSize: [{
+            type: Input,
+            args: ['p-container-size']
+        }], circularClick: [{
+            type: Output,
+            args: ['p-circular-click']
+        }], circularHover: [{
+            type: Output,
+            args: ['p-circular-hover']
+        }], svgPaths: [{
+            type: ViewChildren,
+            args: ['svgPaths']
+        }], svgLabels: [{
+            type: ViewChildren,
+            args: ['svgLabels']
+        }], options: [{
+            type: Input,
+            args: ['p-options']
+        }], series: [{
+            type: Input,
+            args: ['p-series']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-circular.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-circular.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  EventEmitter,\n  Input,\n  NgZone,\n  Output,\n  QueryList,\n  ViewChildren\n} from '@angular/core';\n\nimport {\n  PoChartStartAngle,\n  PoChartCompleteCircle,\n  PoChartAngleStepInterval\n} from '../../helpers/po-chart-default-values.constant';\n\nimport { PoChartCircularLabelComponent } from './po-chart-circular-label/po-chart-circular-label.component';\nimport { PoChartCircularPathComponent } from './po-chart-circular-path/po-chart-circular-path.component';\nimport { PoChartContainerSize } from '../../interfaces/po-chart-container-size.interface';\nimport { PoChartLabelCoordinates } from '../../interfaces/po-chart-label-coordinates.interface';\nimport { PoChartOptions } from '../../interfaces/po-chart-options.interface';\nimport { PoChartPathCoordinates } from '../../interfaces/po-chart-path-coordinates.interface';\nimport { PoChartSerie } from '../../interfaces/po-chart-serie.interface';\n\n@Directive()\nexport abstract class PoChartCircularComponent {\n  @Input('p-container-size') containerSize: PoChartContainerSize;\n\n  @Output('p-circular-click') circularClick = new EventEmitter<any>();\n\n  @Output('p-circular-hover') circularHover = new EventEmitter<any>();\n\n  @ViewChildren('svgPaths') private svgPaths: QueryList<PoChartCircularPathComponent>;\n\n  @ViewChildren('svgLabels') private svgLabels: QueryList<PoChartCircularLabelComponent>;\n\n  canDisplayLabels: boolean = false;\n  seriesLabels: Array<PoChartLabelCoordinates> = [];\n  seriesList: Array<PoChartPathCoordinates>;\n  showLabels: boolean = false;\n\n  protected innerRadius: number;\n  protected totalValue: number;\n\n  private _options: PoChartOptions;\n  private _series: Array<PoChartSerie>;\n\n  private animate: boolean;\n\n  @Input('p-options') set options(value: PoChartOptions) {\n    if (!isNaN(value?.innerRadius)) {\n      this._options = value;\n      this.innerRadius = Math.min(Math.max(this._options.innerRadius, 0), 100);\n    }\n  }\n\n  get options() {\n    return this._options;\n  }\n\n  @Input('p-series') set series(value: Array<PoChartSerie>) {\n    this._series = value;\n\n    this.animate = true;\n  }\n\n  get series() {\n    return this._series;\n  }\n\n  constructor(private ngZone: NgZone, private changeDetector: ChangeDetectorRef) {}\n\n  onSerieClick(selectedItem: any) {\n    this.circularClick.emit(selectedItem);\n  }\n\n  onSerieHover(selectedItem: any) {\n    this.circularHover.emit(selectedItem);\n  }\n\n  protected calculateAngle(data: number, totalValue: number) {\n    return (data / totalValue) * (Math.PI * 2);\n  }\n\n  protected drawSeries(series: Array<PoChartSerie> = [], height: number) {\n    this.seriesList = [];\n    this.showLabels = false;\n    this.totalValue = this.calculateTotalValue(series);\n    if (this.totalValue && this.totalValue > 0) {\n      this.seriesList = this.validateSeries(series);\n      this.changeDetector.detectChanges();\n\n      if (this.seriesList.length && this.svgPaths) {\n        this.initDrawPaths(this.seriesList, this.totalValue, height);\n      }\n    }\n  }\n\n  private calculateTotalValue(series: Array<PoChartSerie>) {\n    return series.reduce((previousValue, serie: any) => {\n      const data = serie.data ? serie.data : serie.value;\n\n      return previousValue + (data > 0 ? data : 0);\n    }, 0);\n  }\n\n  private calculateSerieCoordinates(series: Array<PoChartPathCoordinates>, totalValue: number, height: number) {\n    let startRadianAngle;\n    let endRadianAngle = PoChartStartAngle;\n\n    series.forEach((serie: any, index) => {\n      startRadianAngle = endRadianAngle;\n      endRadianAngle = startRadianAngle + this.calculateAngle(serie.data, totalValue) - PoChartCompleteCircle;\n\n      const coordinates = this.calculateCoordinates(height, startRadianAngle, endRadianAngle);\n\n      this.svgPaths.toArray()[index].applyCoordinates(coordinates);\n      this.showLabels = this.canDisplayLabels;\n    });\n  }\n\n  private calculateCoordinatesWithAnimation(\n    series: Array<PoChartPathCoordinates>,\n    totalValue: number,\n    height: number,\n    startRadianAngle: number,\n    endRadianAngle: number,\n    currentRadianAngle: number = 0,\n    seriesIndex: number = 0\n  ) {\n    const finishedCurrentSerie = currentRadianAngle > endRadianAngle;\n    const finishedAllSeries = seriesIndex === series.length;\n\n    if (finishedAllSeries) {\n      this.animate = false;\n      return;\n    }\n\n    if (finishedCurrentSerie) {\n      this.setSerieLabelCoordinates(seriesIndex);\n      currentRadianAngle = 0;\n      seriesIndex++;\n      startRadianAngle = startRadianAngle + endRadianAngle;\n      endRadianAngle =\n        seriesIndex < series.length ? this.calculateAngle(series[seriesIndex].data, totalValue) : undefined;\n    } else {\n      currentRadianAngle += PoChartAngleStepInterval;\n\n      const currentEndRadianAngle = this.calculateCurrentEndAngle(currentRadianAngle, startRadianAngle, endRadianAngle);\n      const coordinates = this.calculateCoordinates(height, startRadianAngle, currentEndRadianAngle);\n\n      this.svgPaths.toArray()[seriesIndex].applyCoordinates(coordinates);\n    }\n\n    window.requestAnimationFrame(\n      this.calculateCoordinatesWithAnimation.bind(\n        this,\n        series,\n        totalValue,\n        height,\n        startRadianAngle,\n        endRadianAngle,\n        currentRadianAngle,\n        seriesIndex\n      )\n    );\n  }\n\n  private calculateCurrentEndAngle(currentRadianAngle: number, startRadianAngle: number, endRadianAngle: number) {\n    const isSerieDrawCompleted = startRadianAngle + currentRadianAngle > startRadianAngle + endRadianAngle;\n\n    return isSerieDrawCompleted\n      ? startRadianAngle + endRadianAngle - PoChartCompleteCircle\n      : startRadianAngle + currentRadianAngle;\n  }\n\n  private initDrawPaths(seriesList: Array<PoChartPathCoordinates>, totalValue: number, height: number) {\n    if (!this.animate) {\n      this.calculateSerieCoordinates(seriesList, totalValue, height);\n    } else {\n      const startRadianAngle = PoChartStartAngle;\n      const endRadianAngle = this.calculateAngle(seriesList[0].data, totalValue);\n\n      this.ngZone.runOutsideAngular(() =>\n        this.calculateCoordinatesWithAnimation(seriesList, totalValue, height, startRadianAngle, endRadianAngle)\n      );\n    }\n  }\n\n  private setSerieLabelCoordinates(index: number) {\n    if (this.svgLabels.toArray().length) {\n      this.svgLabels.toArray()[index].applyCoordinates(this.seriesLabels[index]);\n    }\n  }\n\n  private validateSeries(series: Array<PoChartSerie>) {\n    return series.reduce((seriesList, serie: any) => {\n      const data = serie.data ?? serie.value;\n      if (data && data > 0) {\n        const color = serie.color;\n        const label = serie.label;\n        const tooltip = serie.tooltip;\n        const tooltipLabel = this.getTooltipLabel(data, label, tooltip);\n\n        seriesList = [...seriesList, { data, color, label, tooltipLabel }];\n      }\n\n      return seriesList;\n    }, []);\n  }\n\n  protected abstract calculateCoordinates(height, startRadianAngle, currentEndRadianAngle);\n  protected abstract getTooltipLabel(data, label, tooltip);\n}\n"]}

package/esm2020/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-donut/po-chart-donut.component.mjs

@@ -0,0 +1,165 @@
+import { Component } from '@angular/core';
+import { convertNumberToDecimal } from '../../../../../utils/util';
+import { PoDefaultColorsTextBlack } from '../../../../../services/po-color/po-colors.constant';
+import { PoChartDonutDefaultThickness, PoChartStartAngle } from '../../../helpers/po-chart-default-values.constant';
+import { PoChartCircularComponent } from '../po-chart-circular.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../po-chart-circular-path/po-chart-circular-path.component";
+import * as i3 from "../po-chart-circular-label/po-chart-circular-label.component";
+const _c0 = ["po-chart-donut", ""];
+function PoChartDonutComponent__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelementStart(1, "g", 2, 3);
+    i0.ɵɵlistener("p-on-click", function PoChartDonutComponent__svg_g_1_Template__svg_g_p_on_click_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.onSerieClick($event); })("p-on-hover", function PoChartDonutComponent__svg_g_1_Template__svg_g_p_on_hover_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r7 = i0.ɵɵnextContext(); return ctx_r7.onSerieHover($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r2 = ctx.$implicit;
+    const i_r3 = ctx.index;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-serie", item_r2);
+    i0.ɵɵattribute("key", "po-chart-circular-path-" + i_r3);
+} }
+function PoChartDonutComponent__svg_g_2__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelement(1, "g", 4, 5);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r9 = ctx.$implicit;
+    const i_r10 = ctx.index;
+    const ctx_r8 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-serie", item_r9)("p-show-label", ctx_r8.showLabels);
+    i0.ɵɵattribute("key", "po-chart-circular-label-" + i_r10);
+} }
+function PoChartDonutComponent__svg_g_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵtemplate(1, PoChartDonutComponent__svg_g_2__svg_g_1_Template, 3, 3, "g", 0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r1.seriesLabels);
+} }
+export class PoChartDonutComponent extends PoChartCircularComponent {
+    /* istanbul ignore next */
+    constructor(ngZone, changeDetector) {
+        super(ngZone, changeDetector);
+        this.poChartBlackColor = '#000000';
+        this.poChartWhiteColor = '#ffffff';
+    }
+    ngOnChanges(changes) {
+        if (changes.series || changes.containerSize || changes.options) {
+            this.drawSeries(this.series, this.containerSize.svgHeight);
+            this.applySeriesLabels(this.seriesList, this.containerSize.svgHeight);
+        }
+    }
+    calculateCoordinates(height, startRadianAngle, endRadianAngle) {
+        const radius = height / 2;
+        const innerRadius = this.getInnerRadius(radius);
+        const sinAlpha = Math.sin(startRadianAngle);
+        const cosAlpha = Math.cos(startRadianAngle);
+        const sinBeta = Math.sin(endRadianAngle);
+        const cosBeta = Math.cos(endRadianAngle);
+        const startX = radius + cosAlpha * radius;
+        const startY = radius + sinAlpha * radius;
+        const endX = radius + cosBeta * radius;
+        const endY = radius + sinBeta * radius;
+        const startInnerX = radius + cosAlpha * innerRadius;
+        const startInnerY = radius + sinAlpha * innerRadius;
+        const endInnerX = radius + cosBeta * innerRadius;
+        const endInnerY = radius + sinBeta * innerRadius;
+        const largeArc = endRadianAngle - startRadianAngle > Math.PI;
+        this.verifyDisplayLabels(radius, innerRadius);
+        return [
+            'M',
+            startX,
+            startY,
+            'A',
+            radius,
+            radius,
+            0,
+            largeArc ? '1,1' : '0,1',
+            endX,
+            endY,
+            'L',
+            endInnerX,
+            endInnerY,
+            'A',
+            innerRadius,
+            innerRadius,
+            0,
+            largeArc ? '1,0' : '0,0',
+            startInnerX,
+            startInnerY,
+            'Z'
+        ].join(' ');
+    }
+    getTooltipLabel(data, label, tooltipLabel) {
+        const dataLabel = label ? `${label}: ` : '';
+        const dataValue = this.getPercentValue(data, this.totalValue) + '%';
+        return tooltipLabel || `${dataLabel}${dataValue}`;
+    }
+    applySeriesLabels(seriesList, height) {
+        let startRadianAngle = PoChartStartAngle;
+        let endRadianAngle = PoChartStartAngle;
+        this.seriesLabels = seriesList.map(serie => {
+            startRadianAngle = endRadianAngle;
+            endRadianAngle = startRadianAngle + this.calculateAngle(serie.data, this.totalValue);
+            const label = this.getPercentValue(serie.data, this.totalValue) + '% ';
+            const color = this.getTextColor(serie.color);
+            const coordinates = this.calculateLabelCoordinates(height, startRadianAngle, endRadianAngle);
+            return { ...coordinates, label, color };
+        });
+    }
+    calculateLabelCoordinates(height, startRadianAngle, endRadianAngle) {
+        const radius = height / 2;
+        const innerRadius = this.getInnerRadius(radius);
+        const sliceCenterAngle = (startRadianAngle + endRadianAngle) / 2;
+        const labelRadius = innerRadius + (radius - innerRadius) / 2;
+        const xCoordinate = labelRadius * Math.cos(sliceCenterAngle) + radius;
+        const yCoordinate = labelRadius * Math.sin(sliceCenterAngle) + radius;
+        return { xCoordinate, yCoordinate };
+    }
+    getInnerRadius(radius) {
+        const defaultInnerRadius = radius - PoChartDonutDefaultThickness;
+        return this.innerRadius >= 0 ? (this.innerRadius / 100) * radius : defaultInnerRadius;
+    }
+    getPercentValue(value, totalValue) {
+        const percentValue = (value / totalValue) * 100;
+        const floatPercentValue = convertNumberToDecimal(percentValue, 2);
+        return String(floatPercentValue).replace('.', ',');
+    }
+    getTextColor(color) {
+        if (PoDefaultColorsTextBlack.includes(color)) {
+            return this.poChartBlackColor;
+        }
+        return this.poChartWhiteColor;
+    }
+    verifyDisplayLabels(radius, innerRadius) {
+        this.canDisplayLabels = radius - innerRadius >= radius - (radius - PoChartDonutDefaultThickness);
+    }
+}
+PoChartDonutComponent.ɵfac = function PoChartDonutComponent_Factory(t) { return new (t || PoChartDonutComponent)(i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoChartDonutComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartDonutComponent, selectors: [["", "po-chart-donut", ""]], features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 3, vars: 2, consts: [[4, "ngFor", "ngForOf"], [4, "ngIf"], ["po-chart-circular-path", "", 3, "p-serie", "p-on-click", "p-on-hover"], ["svgPaths", ""], ["po-chart-circular-label", "", 3, "p-serie", "p-show-label"], ["svgLabels", ""]], template: function PoChartDonutComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartDonutComponent__svg_g_1_Template, 3, 2, "g", 0);
+        i0.ɵɵtemplate(2, PoChartDonutComponent__svg_g_2_Template, 2, 1, "g", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.seriesList);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.canDisplayLabels);
+    } }, directives: [i1.NgForOf, i1.NgIf, i2.PoChartCircularPathComponent, i3.PoChartCircularLabelComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartDonutComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-donut]', template: "<svg:g>\n  <!-- SERIES PATHS -->\n  <svg:g *ngFor=\"let item of seriesList; let i = index\">\n    <svg:g #svgPaths po-chart-circular-path\n      [attr.key]=\"'po-chart-circular-path-' + i\"\n      [p-serie]=\"item\"\n      (p-on-click)=\"onSerieClick($event)\"\n      (p-on-hover)=\"onSerieHover($event)\">\n    </svg:g>\n  </svg:g>\n\n  <!-- SERIES LABELS -->\n  <svg:g *ngIf=\"canDisplayLabels\">\n    <svg:g *ngFor=\"let item of seriesLabels; let i = index\">\n      <svg:g #svgLabels po-chart-circular-label\n        [attr.key]=\"'po-chart-circular-label-' + i\"\n        [p-serie]=\"item\"\n        [p-show-label]=\"showLabels\">\n      </svg:g>\n    </svg:g>\n  </svg:g>\n</svg:g>\n\n" }]
+    }], function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-donut.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-donut/po-chart-donut.component.ts","../../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-circular.component.svg"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, NgZone, OnChanges, SimpleChanges } from '@angular/core';\n\nimport { convertNumberToDecimal } from '../../../../../utils/util';\nimport { PoDefaultColorsTextBlack } from '../../../../../services/po-color/po-colors.constant';\nimport { PoChartDonutDefaultThickness, PoChartStartAngle } from '../../../helpers/po-chart-default-values.constant';\n\nimport { PoChartCircularComponent } from '../po-chart-circular.component';\n\n@Component({\n  selector: '[po-chart-donut]',\n  templateUrl: '../po-chart-circular.component.svg'\n})\nexport class PoChartDonutComponent extends PoChartCircularComponent implements OnChanges {\n  private readonly poChartBlackColor = '#000000';\n  private readonly poChartWhiteColor = '#ffffff';\n\n  /* istanbul ignore next */\n  constructor(ngZone: NgZone, changeDetector: ChangeDetectorRef) {\n    super(ngZone, changeDetector);\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.series || changes.containerSize || changes.options) {\n      this.drawSeries(this.series, this.containerSize.svgHeight);\n      this.applySeriesLabels(this.seriesList, this.containerSize.svgHeight);\n    }\n  }\n\n  protected calculateCoordinates(height: number, startRadianAngle: number, endRadianAngle: number) {\n    const radius = height / 2;\n\n    const innerRadius = this.getInnerRadius(radius);\n\n    const sinAlpha = Math.sin(startRadianAngle);\n    const cosAlpha = Math.cos(startRadianAngle);\n\n    const sinBeta = Math.sin(endRadianAngle);\n    const cosBeta = Math.cos(endRadianAngle);\n\n    const startX = radius + cosAlpha * radius;\n    const startY = radius + sinAlpha * radius;\n\n    const endX = radius + cosBeta * radius;\n    const endY = radius + sinBeta * radius;\n\n    const startInnerX = radius + cosAlpha * innerRadius;\n    const startInnerY = radius + sinAlpha * innerRadius;\n\n    const endInnerX = radius + cosBeta * innerRadius;\n    const endInnerY = radius + sinBeta * innerRadius;\n\n    const largeArc = endRadianAngle - startRadianAngle > Math.PI;\n\n    this.verifyDisplayLabels(radius, innerRadius);\n\n    return [\n      'M',\n      startX,\n      startY,\n      'A',\n      radius,\n      radius,\n      0,\n      largeArc ? '1,1' : '0,1',\n      endX,\n      endY,\n      'L',\n      endInnerX,\n      endInnerY,\n      'A',\n      innerRadius,\n      innerRadius,\n      0,\n      largeArc ? '1,0' : '0,0',\n      startInnerX,\n      startInnerY,\n      'Z'\n    ].join(' ');\n  }\n\n  protected getTooltipLabel(data: number, label?: string, tooltipLabel?: string) {\n    const dataLabel = label ? `${label}: ` : '';\n    const dataValue = this.getPercentValue(data, this.totalValue) + '%';\n\n    return tooltipLabel || `${dataLabel}${dataValue}`;\n  }\n\n  private applySeriesLabels(seriesList: Array<any>, height: number) {\n    let startRadianAngle = PoChartStartAngle;\n    let endRadianAngle = PoChartStartAngle;\n\n    this.seriesLabels = seriesList.map(serie => {\n      startRadianAngle = endRadianAngle;\n      endRadianAngle = startRadianAngle + this.calculateAngle(serie.data, this.totalValue);\n\n      const label = this.getPercentValue(serie.data, this.totalValue) + '% ';\n      const color = this.getTextColor(serie.color);\n      const coordinates = this.calculateLabelCoordinates(height, startRadianAngle, endRadianAngle);\n\n      return { ...coordinates, label, color };\n    });\n  }\n\n  private calculateLabelCoordinates(height: number, startRadianAngle: number, endRadianAngle: number) {\n    const radius = height / 2;\n    const innerRadius = this.getInnerRadius(radius);\n\n    const sliceCenterAngle = (startRadianAngle + endRadianAngle) / 2;\n    const labelRadius = innerRadius + (radius - innerRadius) / 2;\n\n    const xCoordinate = labelRadius * Math.cos(sliceCenterAngle) + radius;\n    const yCoordinate = labelRadius * Math.sin(sliceCenterAngle) + radius;\n\n    return { xCoordinate, yCoordinate };\n  }\n\n  private getInnerRadius(radius: number): number {\n    const defaultInnerRadius = radius - PoChartDonutDefaultThickness;\n\n    return this.innerRadius >= 0 ? (this.innerRadius / 100) * radius : defaultInnerRadius;\n  }\n\n  private getPercentValue(value: number, totalValue: number) {\n    const percentValue = (value / totalValue) * 100;\n    const floatPercentValue = convertNumberToDecimal(percentValue, 2);\n\n    return String(floatPercentValue).replace('.', ',');\n  }\n\n  private getTextColor(color: string) {\n    if (PoDefaultColorsTextBlack.includes(color)) {\n      return this.poChartBlackColor;\n    }\n\n    return this.poChartWhiteColor;\n  }\n\n  private verifyDisplayLabels(radius: number, innerRadius: number): void {\n    this.canDisplayLabels = radius - innerRadius >= radius - (radius - PoChartDonutDefaultThickness);\n  }\n}\n","<svg:g>\n  <!-- SERIES PATHS -->\n  <svg:g *ngFor=\"let item of seriesList; let i = index\">\n    <svg:g #svgPaths po-chart-circular-path\n      [attr.key]=\"'po-chart-circular-path-' + i\"\n      [p-serie]=\"item\"\n      (p-on-click)=\"onSerieClick($event)\"\n      (p-on-hover)=\"onSerieHover($event)\">\n    </svg:g>\n  </svg:g>\n\n  <!-- SERIES LABELS -->\n  <svg:g *ngIf=\"canDisplayLabels\">\n    <svg:g *ngFor=\"let item of seriesLabels; let i = index\">\n      <svg:g #svgLabels po-chart-circular-label\n        [attr.key]=\"'po-chart-circular-label-' + i\"\n        [p-serie]=\"item\"\n        [p-show-label]=\"showLabels\">\n      </svg:g>\n    </svg:g>\n  </svg:g>\n</svg:g>\n\n"]}

package/esm2020/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-pie/po-chart-pie.component.mjs

@@ -0,0 +1,107 @@
+import { Component } from '@angular/core';
+import { PoChartCircularComponent } from '../po-chart-circular.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../po-chart-circular-path/po-chart-circular-path.component";
+import * as i3 from "../po-chart-circular-label/po-chart-circular-label.component";
+const _c0 = ["po-chart-pie", ""];
+function PoChartPieComponent__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelementStart(1, "g", 2, 3);
+    i0.ɵɵlistener("p-on-click", function PoChartPieComponent__svg_g_1_Template__svg_g_p_on_click_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.onSerieClick($event); })("p-on-hover", function PoChartPieComponent__svg_g_1_Template__svg_g_p_on_hover_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r7 = i0.ɵɵnextContext(); return ctx_r7.onSerieHover($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r2 = ctx.$implicit;
+    const i_r3 = ctx.index;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-serie", item_r2);
+    i0.ɵɵattribute("key", "po-chart-circular-path-" + i_r3);
+} }
+function PoChartPieComponent__svg_g_2__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelement(1, "g", 4, 5);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r9 = ctx.$implicit;
+    const i_r10 = ctx.index;
+    const ctx_r8 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-serie", item_r9)("p-show-label", ctx_r8.showLabels);
+    i0.ɵɵattribute("key", "po-chart-circular-label-" + i_r10);
+} }
+function PoChartPieComponent__svg_g_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵtemplate(1, PoChartPieComponent__svg_g_2__svg_g_1_Template, 3, 3, "g", 0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r1.seriesLabels);
+} }
+export class PoChartPieComponent extends PoChartCircularComponent {
+    /* istanbul ignore next */
+    constructor(ngZone, changeDetector) {
+        super(ngZone, changeDetector);
+    }
+    ngOnChanges(changes) {
+        if (changes.series || changes.containerSize) {
+            this.drawSeries(this.series, this.containerSize.svgHeight);
+        }
+    }
+    calculateCoordinates(height, startRadianAngle, endRadianAngle) {
+        const radius = height / 2;
+        const sinAlpha = Math.sin(startRadianAngle);
+        const cosAlpha = Math.cos(startRadianAngle);
+        const sinBeta = Math.sin(endRadianAngle);
+        const cosBeta = Math.cos(endRadianAngle);
+        const startX = radius + cosAlpha * radius;
+        const startY = radius + sinAlpha * radius;
+        const endX = radius + cosBeta * radius;
+        const endY = radius + sinBeta * radius;
+        const largeArc = endRadianAngle - startRadianAngle > Math.PI;
+        return [
+            'M',
+            startX,
+            startY,
+            'A',
+            radius,
+            radius,
+            0,
+            largeArc ? '1,1' : '0,1',
+            endX,
+            endY,
+            'L',
+            radius,
+            radius,
+            'Z'
+        ].join(' ');
+    }
+    getTooltipLabel(data, label, tooltipLabel) {
+        const dataLabel = label ? `${label}: ` : '';
+        const dataValue = data.toString();
+        return tooltipLabel || `${dataLabel}${dataValue}`;
+    }
+}
+PoChartPieComponent.ɵfac = function PoChartPieComponent_Factory(t) { return new (t || PoChartPieComponent)(i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoChartPieComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartPieComponent, selectors: [["", "po-chart-pie", ""]], features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 3, vars: 2, consts: [[4, "ngFor", "ngForOf"], [4, "ngIf"], ["po-chart-circular-path", "", 3, "p-serie", "p-on-click", "p-on-hover"], ["svgPaths", ""], ["po-chart-circular-label", "", 3, "p-serie", "p-show-label"], ["svgLabels", ""]], template: function PoChartPieComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartPieComponent__svg_g_1_Template, 3, 2, "g", 0);
+        i0.ɵɵtemplate(2, PoChartPieComponent__svg_g_2_Template, 2, 1, "g", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.seriesList);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.canDisplayLabels);
+    } }, directives: [i1.NgForOf, i1.NgIf, i2.PoChartCircularPathComponent, i3.PoChartCircularLabelComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartPieComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-pie]', template: "<svg:g>\n  <!-- SERIES PATHS -->\n  <svg:g *ngFor=\"let item of seriesList; let i = index\">\n    <svg:g #svgPaths po-chart-circular-path\n      [attr.key]=\"'po-chart-circular-path-' + i\"\n      [p-serie]=\"item\"\n      (p-on-click)=\"onSerieClick($event)\"\n      (p-on-hover)=\"onSerieHover($event)\">\n    </svg:g>\n  </svg:g>\n\n  <!-- SERIES LABELS -->\n  <svg:g *ngIf=\"canDisplayLabels\">\n    <svg:g *ngFor=\"let item of seriesLabels; let i = index\">\n      <svg:g #svgLabels po-chart-circular-label\n        [attr.key]=\"'po-chart-circular-label-' + i\"\n        [p-serie]=\"item\"\n        [p-show-label]=\"showLabels\">\n      </svg:g>\n    </svg:g>\n  </svg:g>\n</svg:g>\n\n" }]
+    }], function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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