@po-ui/ng-components 5.22.3 → 6.2.0

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

@@ -0,0 +1,84 @@
+import { Component } from '@angular/core';
+import { PoChartPlotAreaPaddingTop } from './../../helpers/po-chart-default-values.constant';
+import { PoChartBarBaseComponent } from './po-chart-bar-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./../../services/po-chart-maths.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./po-chart-bar-path/po-chart-bar-path.component";
+const _c0 = ["po-chart-bar", ""];
+function PoChartBarComponent__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelementStart(1, "g", 1);
+    i0.ɵɵlistener("p-bar-click", function PoChartBarComponent__svg_g_1_Template__svg_g_p_bar_click_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r3 = i0.ɵɵnextContext(); return ctx_r3.onSerieBarClick($event); })("p-bar-hover", function PoChartBarComponent__svg_g_1_Template__svg_g_p_bar_hover_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.onSerieBarHover($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r1 = ctx.$implicit;
+    const i_r2 = ctx.index;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵclassMap("po-chart-bar-group-" + i_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-color", item_r1[0] == null ? null : item_r1[0].color)("p-coordinates", item_r1)("p-tooltip-position", ctx_r0.tooltipPosition);
+    i0.ɵɵattribute("key", "po-chart-bar-path-" + i_r2);
+} }
+export class PoChartBarComponent extends PoChartBarBaseComponent {
+    constructor(mathsService) {
+        super(mathsService);
+        this.mathsService = mathsService;
+        this.tooltipPosition = 'right';
+    }
+    barCoordinates(seriesIndex, serieItemDataIndex, containerSize, minMaxSeriesValues, serieValue) {
+        const { svgPlottingAreaWidth, barHeight, spaceBetweenBars } = this.calculateElementsMeasurements(containerSize);
+        const { x1, x2 } = this.xCoordinates(minMaxSeriesValues, svgPlottingAreaWidth, containerSize.axisXLabelWidth, containerSize.svgWidth, serieValue);
+        const { y1, y2 } = this.yCoordinates(seriesIndex, serieItemDataIndex, containerSize.svgPlottingAreaHeight, barHeight, spaceBetweenBars);
+        return ['M', x1, y2, 'L', x2, y2, 'L', x2, y1, 'L', x1, y1, 'z'].join(' ');
+    }
+    calculateElementsMeasurements(containerSize) {
+        const { svgWidth, svgPlottingAreaHeight, axisXLabelWidth } = containerSize;
+        // Fração das séries em relação à largura da categoria. Incrementa + 2 na extensão das séries pois se trata da área de margem entre as categorias.
+        const svgPlottingAreaWidth = svgWidth - axisXLabelWidth;
+        const categoryHeight = svgPlottingAreaHeight / this.seriesGreaterLength;
+        const columnFraction = categoryHeight / (this.series.length + 2);
+        // Área entre as colunas: retorna zero se houver apenas uma série.
+        const spaceBetweenBars = this.series.length > 1 ? columnFraction / (this.series.length + 2) : 0;
+        // Subtrai a fração das séries pelo espaço entre as colunas.
+        const barHeight = columnFraction - (spaceBetweenBars * (this.series.length - 1)) / (this.series.length + 2);
+        return { svgPlottingAreaWidth, barHeight, spaceBetweenBars };
+    }
+    xCoordinates(minMaxSeriesValues, svgPlottingAreaWidth, axisXLabelWidth, svgWidth, serieValue) {
+        const { minValue } = minMaxSeriesValues;
+        const valueZeroPercentage = this.mathsService.getSeriePercentage(minMaxSeriesValues, minValue < 0 ? 0 : minValue);
+        const x1 = axisXLabelWidth + (svgWidth - axisXLabelWidth) * valueZeroPercentage;
+        const xRatio = this.mathsService.getSeriePercentage(minMaxSeriesValues, serieValue);
+        const x2 = Math.round(svgPlottingAreaWidth * xRatio + axisXLabelWidth);
+        return { x1, x2 };
+    }
+    yCoordinates(seriesIndex, serieItemDataIndex, svgPlottingAreaHeight, barHeight, spaceBetweenBars) {
+        const spaceBetweenAxisAndBars = barHeight;
+        const yRatio = serieItemDataIndex / this.seriesGreaterLength;
+        const y1 = Math.round(PoChartPlotAreaPaddingTop +
+            svgPlottingAreaHeight * yRatio +
+            spaceBetweenAxisAndBars +
+            barHeight * seriesIndex +
+            spaceBetweenBars * seriesIndex);
+        const y2 = Math.round(y1 + barHeight);
+        return { y1, y2 };
+    }
+}
+PoChartBarComponent.ɵfac = function PoChartBarComponent_Factory(t) { return new (t || PoChartBarComponent)(i0.ɵɵdirectiveInject(i1.PoChartMathsService)); };
+PoChartBarComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartBarComponent, selectors: [["", "po-chart-bar", ""]], features: [i0.ɵɵInheritDefinitionFeature], attrs: _c0, decls: 2, vars: 2, consts: [[3, "class", 4, "ngFor", "ngForOf", "ngForTrackBy"], ["po-chart-bar-path", "", 3, "p-color", "p-coordinates", "p-tooltip-position", "p-bar-click", "p-bar-hover"]], template: function PoChartBarComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartBarComponent__svg_g_1_Template, 2, 6, "g", 0);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.seriesPathsCoordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i2.NgForOf, i3.PoChartBarPathComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartBarComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-bar]', template: "<svg:g>\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\n    [class]=\"'po-chart-bar-group-' + i\"\n  >\n    <!-- SERIES PATHS -->\n    <svg:g po-chart-bar-path\n      [attr.key]=\"'po-chart-bar-path-' + i\"\n      [p-color]=\"item[0]?.color\" \n      [p-coordinates]=\"item\"\n      [p-tooltip-position]=\"tooltipPosition\"\n      (p-bar-click)=\"onSerieBarClick($event)\"\n      (p-bar-hover)=\"onSerieBarHover($event)\"\n      >\n      </svg:g>\n  </svg:g>\n</svg:g>" }]
+    }], function () { return [{ type: i1.PoChartMathsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-bar.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-bar/po-chart-bar.component.ts","../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-bar/po-chart-bar.component.svg"],"names":[],"mappings":"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","sourcesContent":["import { Component } from '@angular/core';\n\nimport { PoChartPlotAreaPaddingTop } from './../../helpers/po-chart-default-values.constant';\n\nimport { PoChartBarBaseComponent } from './po-chart-bar-base.component';\nimport { PoChartMathsService } from './../../services/po-chart-maths.service';\n\nimport { PoChartContainerSize } from './../../interfaces/po-chart-container-size.interface';\nimport { PoChartMinMaxValues } from './../../interfaces/po-chart-min-max-values.interface';\n\n@Component({\n  selector: '[po-chart-bar]',\n  templateUrl: './po-chart-bar.component.svg'\n})\nexport class PoChartBarComponent extends PoChartBarBaseComponent {\n  readonly tooltipPosition = 'right';\n\n  constructor(protected mathsService: PoChartMathsService) {\n    super(mathsService);\n  }\n\n  protected barCoordinates(\n    seriesIndex: number,\n    serieItemDataIndex: number,\n    containerSize: PoChartContainerSize,\n    minMaxSeriesValues: PoChartMinMaxValues,\n    serieValue: number\n  ) {\n    const { svgPlottingAreaWidth, barHeight, spaceBetweenBars } = this.calculateElementsMeasurements(containerSize);\n\n    const { x1, x2 } = this.xCoordinates(\n      minMaxSeriesValues,\n      svgPlottingAreaWidth,\n      containerSize.axisXLabelWidth,\n      containerSize.svgWidth,\n      serieValue\n    );\n    const { y1, y2 } = this.yCoordinates(\n      seriesIndex,\n      serieItemDataIndex,\n      containerSize.svgPlottingAreaHeight,\n      barHeight,\n      spaceBetweenBars\n    );\n\n    return ['M', x1, y2, 'L', x2, y2, 'L', x2, y1, 'L', x1, y1, 'z'].join(' ');\n  }\n\n  private calculateElementsMeasurements(containerSize: PoChartContainerSize) {\n    const { svgWidth, svgPlottingAreaHeight, axisXLabelWidth } = containerSize;\n\n    // Fração das séries em relação à largura da categoria. Incrementa + 2 na extensão das séries pois se trata da área de margem entre as categorias.\n    const svgPlottingAreaWidth = svgWidth - axisXLabelWidth;\n    const categoryHeight = svgPlottingAreaHeight / this.seriesGreaterLength;\n    const columnFraction = categoryHeight / (this.series.length + 2);\n\n    // Área entre as colunas: retorna zero se houver apenas uma série.\n    const spaceBetweenBars = this.series.length > 1 ? columnFraction / (this.series.length + 2) : 0;\n\n    // Subtrai a fração das séries pelo espaço entre as colunas.\n    const barHeight = columnFraction - (spaceBetweenBars * (this.series.length - 1)) / (this.series.length + 2);\n\n    return { svgPlottingAreaWidth, barHeight, spaceBetweenBars };\n  }\n\n  private xCoordinates(\n    minMaxSeriesValues: PoChartMinMaxValues,\n    svgPlottingAreaWidth: number,\n    axisXLabelWidth: PoChartContainerSize['axisXLabelWidth'],\n    svgWidth: PoChartContainerSize['svgWidth'],\n    serieValue: number\n  ) {\n    const { minValue } = minMaxSeriesValues;\n    const valueZeroPercentage = this.mathsService.getSeriePercentage(minMaxSeriesValues, minValue < 0 ? 0 : minValue);\n    const x1 = axisXLabelWidth + (svgWidth - axisXLabelWidth) * valueZeroPercentage;\n\n    const xRatio = this.mathsService.getSeriePercentage(minMaxSeriesValues, serieValue);\n    const x2 = Math.round(svgPlottingAreaWidth * xRatio + axisXLabelWidth);\n\n    return { x1, x2 };\n  }\n\n  private yCoordinates(\n    seriesIndex: number,\n    serieItemDataIndex: number,\n    svgPlottingAreaHeight: number,\n    barHeight: number,\n    spaceBetweenBars: number\n  ) {\n    const spaceBetweenAxisAndBars = barHeight;\n    const yRatio = serieItemDataIndex / this.seriesGreaterLength;\n\n    const y1 = Math.round(\n      PoChartPlotAreaPaddingTop +\n        svgPlottingAreaHeight * yRatio +\n        spaceBetweenAxisAndBars +\n        barHeight * seriesIndex +\n        spaceBetweenBars * seriesIndex\n    );\n\n    const y2 = Math.round(y1 + barHeight);\n    return { y1, y2 };\n  }\n}\n","<svg:g>\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\n    [class]=\"'po-chart-bar-group-' + i\"\n  >\n    <!-- SERIES PATHS -->\n    <svg:g po-chart-bar-path\n      [attr.key]=\"'po-chart-bar-path-' + i\"\n      [p-color]=\"item[0]?.color\" \n      [p-coordinates]=\"item\"\n      [p-tooltip-position]=\"tooltipPosition\"\n      (p-bar-click)=\"onSerieBarClick($event)\"\n      (p-bar-hover)=\"onSerieBarHover($event)\"\n      >\n      </svg:g>\n  </svg:g>\n</svg:g>"]}

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

@@ -0,0 +1,85 @@
+import { Component } from '@angular/core';
+import { PoChartPlotAreaPaddingTop } from '../../../helpers/po-chart-default-values.constant';
+import { PoChartBarBaseComponent } from '../po-chart-bar-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/po-chart-maths.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../po-chart-bar-path/po-chart-bar-path.component";
+const _c0 = ["po-chart-column", ""];
+function PoChartColumnComponent__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelementStart(1, "g", 1);
+    i0.ɵɵlistener("p-bar-click", function PoChartColumnComponent__svg_g_1_Template__svg_g_p_bar_click_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r3 = i0.ɵɵnextContext(); return ctx_r3.onSerieBarClick($event); })("p-bar-hover", function PoChartColumnComponent__svg_g_1_Template__svg_g_p_bar_hover_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.onSerieBarHover($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r1 = ctx.$implicit;
+    const i_r2 = ctx.index;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵclassMap("po-chart-bar-group-" + i_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-color", item_r1[0] == null ? null : item_r1[0].color)("p-coordinates", item_r1)("p-tooltip-position", ctx_r0.tooltipPosition);
+    i0.ɵɵattribute("key", "po-chart-bar-path-" + i_r2);
+} }
+export class PoChartColumnComponent extends PoChartBarBaseComponent {
+    constructor(mathsService) {
+        super(mathsService);
+        this.mathsService = mathsService;
+        this.tooltipPosition = 'top';
+    }
+    barCoordinates(seriesIndex, serieItemDataIndex, containerSize, minMaxSeriesValues, serieValue) {
+        const { svgWidth, axisXLabelWidth, svgPlottingAreaHeight } = containerSize;
+        const { chartBarPlotArea, barWidth, spaceBetweenBars } = this.calculateElementsMeasurements(svgWidth, axisXLabelWidth);
+        const { x1, x2 } = this.xCoordinates(seriesIndex, serieItemDataIndex, chartBarPlotArea, barWidth, spaceBetweenBars, axisXLabelWidth);
+        const { y1, y2 } = this.yCoordinates(minMaxSeriesValues, svgPlottingAreaHeight, serieValue);
+        return ['M', x1, y2, 'L', x2, y2, 'L', x2, y1, 'L', x1, y1, 'z'].join(' ');
+    }
+    calculateElementsMeasurements(svgWidth, axisXLabelWidth) {
+        // Fração das séries em relação à largura da categoria. Incrementa + 2 na extensão das séries pois se trata da área de margem entre as categorias.
+        const chartBarPlotArea = svgWidth - axisXLabelWidth;
+        const categoryWidth = chartBarPlotArea / this.seriesGreaterLength;
+        const columnFraction = categoryWidth / (this.series.length + 2);
+        // Área entre as colunas: retorna zero se houver apenas uma série.
+        const spaceBetweenBars = this.series.length > 1 ? columnFraction / (this.series.length + 2) : 0;
+        // Subtrai a fração das séries pelo espaço entre as colunas.
+        const barWidth = columnFraction - (spaceBetweenBars * (this.series.length - 1)) / (this.series.length + 2);
+        return { chartBarPlotArea, barWidth, spaceBetweenBars };
+    }
+    xCoordinates(seriesIndex, serieItemDataIndex, chartBarPlotArea, barWidth, spaceBetweenBars, axisXLabelWidth) {
+        // A área lateral entre a coluna e a linha do eixo Y do grid será sempre equivalente à largura da coluna.
+        const spaceBetweenAxisAndBars = barWidth;
+        const xRatio = serieItemDataIndex / this.seriesGreaterLength;
+        const x1 = Math.round(axisXLabelWidth +
+            chartBarPlotArea * xRatio +
+            spaceBetweenAxisAndBars +
+            barWidth * seriesIndex +
+            spaceBetweenBars * seriesIndex);
+        const x2 = Math.round(x1 + barWidth);
+        return { x1, x2 };
+    }
+    yCoordinates(minMaxSeriesValues, svgPlottingAreaHeight, serieValue) {
+        const { minValue } = minMaxSeriesValues;
+        const minValuePercentage = this.mathsService.getSeriePercentage(minMaxSeriesValues, minValue < 0 ? 0 : minValue);
+        const y1 = Math.round(svgPlottingAreaHeight - svgPlottingAreaHeight * minValuePercentage + PoChartPlotAreaPaddingTop);
+        const yRatio = this.mathsService.getSeriePercentage(minMaxSeriesValues, serieValue);
+        const y2 = Math.round(svgPlottingAreaHeight - svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop);
+        return { y1, y2 };
+    }
+}
+PoChartColumnComponent.ɵfac = function PoChartColumnComponent_Factory(t) { return new (t || PoChartColumnComponent)(i0.ɵɵdirectiveInject(i1.PoChartMathsService)); };
+PoChartColumnComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartColumnComponent, selectors: [["", "po-chart-column", ""]], features: [i0.ɵɵInheritDefinitionFeature], attrs: _c0, decls: 2, vars: 2, consts: [[3, "class", 4, "ngFor", "ngForOf", "ngForTrackBy"], ["po-chart-bar-path", "", 3, "p-color", "p-coordinates", "p-tooltip-position", "p-bar-click", "p-bar-hover"]], template: function PoChartColumnComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartColumnComponent__svg_g_1_Template, 2, 6, "g", 0);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.seriesPathsCoordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i2.NgForOf, i3.PoChartBarPathComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartColumnComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-column]', template: "<svg:g>\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\n    [class]=\"'po-chart-bar-group-' + i\"\n  >\n    <!-- SERIES PATHS -->\n    <svg:g po-chart-bar-path\n      [attr.key]=\"'po-chart-bar-path-' + i\"\n      [p-color]=\"item[0]?.color\" \n      [p-coordinates]=\"item\"\n      [p-tooltip-position]=\"tooltipPosition\"\n      (p-bar-click)=\"onSerieBarClick($event)\"\n      (p-bar-hover)=\"onSerieBarHover($event)\"\n      >\n      </svg:g>\n  </svg:g>\n</svg:g>" }]
+    }], function () { return [{ type: i1.PoChartMathsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-column.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-bar/po-chart-column/po-chart-column.component.ts","../../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-bar/po-chart-bar.component.svg"],"names":[],"mappings":"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","sourcesContent":["import { Component } from '@angular/core';\n\nimport { PoChartPlotAreaPaddingTop } from '../../../helpers/po-chart-default-values.constant';\n\nimport { PoChartBarBaseComponent } from '../po-chart-bar-base.component';\nimport { PoChartMathsService } from '../../../services/po-chart-maths.service';\n\nimport { PoChartContainerSize } from '../../../interfaces/po-chart-container-size.interface';\nimport { PoChartMinMaxValues } from '../../../interfaces/po-chart-min-max-values.interface';\n\n@Component({\n  selector: '[po-chart-column]',\n  templateUrl: '../po-chart-bar.component.svg'\n})\nexport class PoChartColumnComponent extends PoChartBarBaseComponent {\n  readonly tooltipPosition = 'top';\n\n  constructor(protected mathsService: PoChartMathsService) {\n    super(mathsService);\n  }\n\n  protected barCoordinates(\n    seriesIndex: number,\n    serieItemDataIndex: number,\n    containerSize: PoChartContainerSize,\n    minMaxSeriesValues: PoChartMinMaxValues,\n    serieValue: number\n  ) {\n    const { svgWidth, axisXLabelWidth, svgPlottingAreaHeight } = containerSize;\n    const { chartBarPlotArea, barWidth, spaceBetweenBars } = this.calculateElementsMeasurements(\n      svgWidth,\n      axisXLabelWidth\n    );\n\n    const { x1, x2 } = this.xCoordinates(\n      seriesIndex,\n      serieItemDataIndex,\n      chartBarPlotArea,\n      barWidth,\n      spaceBetweenBars,\n      axisXLabelWidth\n    );\n    const { y1, y2 } = this.yCoordinates(minMaxSeriesValues, svgPlottingAreaHeight, serieValue);\n\n    return ['M', x1, y2, 'L', x2, y2, 'L', x2, y1, 'L', x1, y1, 'z'].join(' ');\n  }\n\n  private calculateElementsMeasurements(\n    svgWidth: PoChartContainerSize['svgWidth'],\n    axisXLabelWidth: PoChartContainerSize['axisXLabelWidth']\n  ) {\n    // Fração das séries em relação à largura da categoria. Incrementa + 2 na extensão das séries pois se trata da área de margem entre as categorias.\n    const chartBarPlotArea = svgWidth - axisXLabelWidth;\n    const categoryWidth = chartBarPlotArea / this.seriesGreaterLength;\n    const columnFraction = categoryWidth / (this.series.length + 2);\n\n    // Área entre as colunas: retorna zero se houver apenas uma série.\n    const spaceBetweenBars = this.series.length > 1 ? columnFraction / (this.series.length + 2) : 0;\n\n    // Subtrai a fração das séries pelo espaço entre as colunas.\n    const barWidth = columnFraction - (spaceBetweenBars * (this.series.length - 1)) / (this.series.length + 2);\n\n    return { chartBarPlotArea, barWidth, spaceBetweenBars };\n  }\n\n  private xCoordinates(\n    seriesIndex: number,\n    serieItemDataIndex: number,\n    chartBarPlotArea: number,\n    barWidth: number,\n    spaceBetweenBars: number,\n    axisXLabelWidth: PoChartContainerSize['axisXLabelWidth']\n  ) {\n    // A área lateral entre a coluna e a linha do eixo Y do grid será sempre equivalente à largura da coluna.\n    const spaceBetweenAxisAndBars = barWidth;\n    const xRatio = serieItemDataIndex / this.seriesGreaterLength;\n\n    const x1 = Math.round(\n      axisXLabelWidth +\n        chartBarPlotArea * xRatio +\n        spaceBetweenAxisAndBars +\n        barWidth * seriesIndex +\n        spaceBetweenBars * seriesIndex\n    );\n\n    const x2 = Math.round(x1 + barWidth);\n\n    return { x1, x2 };\n  }\n\n  private yCoordinates(minMaxSeriesValues: PoChartMinMaxValues, svgPlottingAreaHeight: number, serieValue: number) {\n    const { minValue } = minMaxSeriesValues;\n    const minValuePercentage = this.mathsService.getSeriePercentage(minMaxSeriesValues, minValue < 0 ? 0 : minValue);\n    const y1 = Math.round(\n      svgPlottingAreaHeight - svgPlottingAreaHeight * minValuePercentage + PoChartPlotAreaPaddingTop\n    );\n\n    const yRatio = this.mathsService.getSeriePercentage(minMaxSeriesValues, serieValue);\n    const y2 = Math.round(svgPlottingAreaHeight - svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop);\n\n    return { y1, y2 };\n  }\n}\n","<svg:g>\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\n    [class]=\"'po-chart-bar-group-' + i\"\n  >\n    <!-- SERIES PATHS -->\n    <svg:g po-chart-bar-path\n      [attr.key]=\"'po-chart-bar-path-' + i\"\n      [p-color]=\"item[0]?.color\" \n      [p-coordinates]=\"item\"\n      [p-tooltip-position]=\"tooltipPosition\"\n      (p-bar-click)=\"onSerieBarClick($event)\"\n      (p-bar-hover)=\"onSerieBarHover($event)\"\n      >\n      </svg:g>\n  </svg:g>\n</svg:g>"]}

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

@@ -0,0 +1,47 @@
+import { Component, ElementRef, Input, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+const _c0 = ["svgLabel"];
+const _c1 = ["po-chart-circular-label", ""];
+export class PoChartCircularLabelComponent {
+    constructor(changeDetection, renderer) {
+        this.changeDetection = changeDetection;
+        this.renderer = renderer;
+    }
+    applyCoordinates(coordinates) {
+        this.renderer.setAttribute(this.svgLabel.nativeElement, 'x', coordinates.xCoordinate.toString());
+        this.renderer.setAttribute(this.svgLabel.nativeElement, 'y', coordinates.yCoordinate.toString());
+        this.showLabel = true;
+        this.changeDetection.detectChanges();
+    }
+}
+PoChartCircularLabelComponent.ɵfac = function PoChartCircularLabelComponent_Factory(t) { return new (t || PoChartCircularLabelComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.Renderer2)); };
+PoChartCircularLabelComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartCircularLabelComponent, selectors: [["", "po-chart-circular-label", ""]], viewQuery: function PoChartCircularLabelComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ElementRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.svgLabel = _t.first);
+    } }, inputs: { serie: ["p-serie", "serie"], showLabel: ["p-show-label", "showLabel"] }, attrs: _c1, decls: 3, vars: 6, consts: [["dominant-baseline", "middle", 1, "po-chart-label"], ["svgLabel", ""]], template: function PoChartCircularLabelComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "text", 0, 1);
+        i0.ɵɵtext(2);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵclassProp("po-invisible", !ctx.showLabel);
+        i0.ɵɵattribute("fill", ctx.serie == null ? null : ctx.serie.color)("x", ctx.serie == null ? null : ctx.serie.xCoordinate)("y", ctx.serie == null ? null : ctx.serie.yCoordinate);
+        i0.ɵɵadvance(2);
+        i0.ɵɵtextInterpolate1(" ", ctx.serie == null ? null : ctx.serie.label, "\n");
+    } }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartCircularLabelComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-circular-label]', template: "<svg:text #svgLabel \n  class=\"po-chart-label\" \n  dominant-baseline=\"middle\"\n  [class.po-invisible]=\"!showLabel\"\n  [attr.fill]=\"serie?.color\"\n  [attr.x]=\"serie?.xCoordinate\"\n  [attr.y]=\"serie?.yCoordinate\">\n  {{ serie?.label }}\n</svg:text> " }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }]; }, { serie: [{
+            type: Input,
+            args: ['p-serie']
+        }], showLabel: [{
+            type: Input,
+            args: ['p-show-label']
+        }], svgLabel: [{
+            type: ViewChild,
+            args: ['svgLabel', { read: ElementRef }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-chart-tooltip.directive";
+const _c0 = ["svgPath"];
+const _c1 = ["po-chart-circular-path", ""];
+export class PoChartCircularPathComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.onClick = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    applyCoordinates(coordinates) {
+        this.renderer.setAttribute(this.svgPath.nativeElement, 'd', coordinates);
+    }
+    onMouseClick() {
+        const { label, data } = this.serie;
+        this.onClick.emit({ label, data });
+    }
+    onMouseEnter() {
+        const { label, data } = this.serie;
+        this.onHover.emit({ label, data });
+    }
+}
+PoChartCircularPathComponent.ɵfac = function PoChartCircularPathComponent_Factory(t) { return new (t || PoChartCircularPathComponent)(i0.ɵɵdirectiveInject(i0.Renderer2)); };
+PoChartCircularPathComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartCircularPathComponent, selectors: [["", "po-chart-circular-path", ""]], viewQuery: function PoChartCircularPathComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ElementRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.svgPath = _t.first);
+    } }, inputs: { serie: ["p-serie", "serie"] }, outputs: { onClick: "p-on-click", onHover: "p-on-hover" }, attrs: _c1, decls: 2, vars: 4, consts: [[1, "po-path-item", 3, "p-chart-tooltip", "click", "mouseenter"], ["svgPath", ""]], template: function PoChartCircularPathComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "path", 0, 1);
+        i0.ɵɵlistener("click", function PoChartCircularPathComponent_Template__svg_path_click_0_listener() { return ctx.onMouseClick(); })("mouseenter", function PoChartCircularPathComponent_Template__svg_path_mouseenter_0_listener() { return ctx.onMouseEnter(); });
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵclassMap((ctx.serie == null ? null : ctx.serie.color.includes("po-color")) ? ctx.serie.color : "");
+        i0.ɵɵproperty("p-chart-tooltip", ctx.serie == null ? null : ctx.serie.tooltipLabel);
+        i0.ɵɵattribute("fill", ctx.serie == null ? null : ctx.serie.color);
+    } }, directives: [i1.PoChartTooltipDirective], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartCircularPathComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-circular-path]', template: "<svg:path #svgPath\n  class=\"po-path-item\"\n  [class]=\"serie?.color.includes('po-color') ? serie.color : ''\"\n  [p-chart-tooltip]=\"serie?.tooltipLabel\"\n  [attr.fill]=\"serie?.color\"\n  (click)=\"onMouseClick()\"\n  (mouseenter)=\"onMouseEnter()\"\n  >\n</svg:path> \n" }]
+    }], function () { return [{ type: i0.Renderer2 }]; }, { serie: [{
+            type: Input,
+            args: ['p-serie']
+        }], onClick: [{
+            type: Output,
+            args: ['p-on-click']
+        }], onHover: [{
+            type: Output,
+            args: ['p-on-hover']
+        }], svgPath: [{
+            type: ViewChild,
+            args: ['svgPath', { read: ElementRef }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-circular-path/po-chart-tooltip.directive.mjs

@@ -0,0 +1,84 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PoChartTooltipDirective {
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+    }
+    onMouseEnter(event) {
+        this.tooltipElement ? this.showTooltip() : this.createTooltip();
+        this.tooltipPosition(event);
+        this.lastTooltipText = this.tooltip;
+    }
+    onMouseLeave() {
+        this.hideTooltip();
+    }
+    onMouseMove(event) {
+        this.tooltipPosition(event);
+    }
+    calculateTooltipPosition(event) {
+        const displacement = 12;
+        return {
+            left: event.clientX - this.tooltipElement.offsetWidth / 2,
+            top: event.clientY - this.tooltipElement.offsetHeight - displacement
+        };
+    }
+    createTooltip() {
+        const chartWrapper = this.elementRef.nativeElement.closest('.po-chart-wrapper');
+        this.tooltipElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.tooltipElement, 'po-chart-tooltip');
+        this.renderer.addClass(this.tooltipElement, 'po-tooltip');
+        const divArrow = this.renderer.createElement('div');
+        this.renderer.addClass(divArrow, 'po-tooltip-arrow');
+        this.renderer.addClass(divArrow, 'po-arrow-bottom');
+        this.tooltipText = this.renderer.createElement('p');
+        this.renderer.addClass(this.tooltipText, 'po-tooltip-content');
+        this.tooltipTextContent = this.renderer.createText(this.tooltip);
+        this.renderer.appendChild(this.tooltipText, this.tooltipTextContent);
+        this.renderer.appendChild(this.tooltipElement, divArrow);
+        this.renderer.appendChild(this.tooltipElement, this.tooltipText);
+        this.renderer.appendChild(chartWrapper, this.tooltipElement);
+    }
+    hideTooltip() {
+        this.renderer.addClass(this.tooltipElement, 'po-invisible');
+    }
+    showTooltip() {
+        this.renderer.removeClass(this.tooltipElement, 'po-invisible');
+        this.updatetooltipTextContent();
+    }
+    tooltipPosition(event) {
+        const tooltipPositions = this.calculateTooltipPosition(event);
+        this.renderer.setStyle(this.tooltipElement, 'left', `${tooltipPositions.left}px`);
+        this.renderer.setStyle(this.tooltipElement, 'top', `${tooltipPositions.top}px`);
+    }
+    updatetooltipTextContent() {
+        if (this.lastTooltipText !== this.tooltip) {
+            this.renderer.removeChild(this.tooltipText, this.tooltipTextContent);
+            this.tooltipTextContent = this.renderer.createText(this.tooltip);
+            this.renderer.appendChild(this.tooltipText, this.tooltipTextContent);
+        }
+    }
+}
+PoChartTooltipDirective.ɵfac = function PoChartTooltipDirective_Factory(t) { return new (t || PoChartTooltipDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.Renderer2)); };
+PoChartTooltipDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoChartTooltipDirective, selectors: [["", "p-chart-tooltip", ""]], hostBindings: function PoChartTooltipDirective_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("mouseenter", function PoChartTooltipDirective_mouseenter_HostBindingHandler($event) { return ctx.onMouseEnter($event); })("mouseleave", function PoChartTooltipDirective_mouseleave_HostBindingHandler() { return ctx.onMouseLeave(); })("mousemove", function PoChartTooltipDirective_mousemove_HostBindingHandler($event) { return ctx.onMouseMove($event); });
+    } }, inputs: { tooltip: ["p-chart-tooltip", "tooltip"] } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartTooltipDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[p-chart-tooltip]'
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, { tooltip: [{
+            type: Input,
+            args: ['p-chart-tooltip']
+        }], onMouseEnter: [{
+            type: HostListener,
+            args: ['mouseenter', ['$event']]
+        }], onMouseLeave: [{
+            type: HostListener,
+            args: ['mouseleave']
+        }], onMouseMove: [{
+            type: HostListener,
+            args: ['mousemove', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-tooltip.directive.js","sourceRoot":"","sources":["../../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-circular/po-chart-circular-path/po-chart-tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, Renderer2 } from '@angular/core';\n\n@Directive({\n  selector: '[p-chart-tooltip]'\n})\nexport class PoChartTooltipDirective {\n  @Input('p-chart-tooltip') tooltip: string;\n\n  private lastTooltipText: string;\n  private tooltipElement;\n  private tooltipText;\n  private tooltipTextContent;\n\n  constructor(private elementRef: ElementRef, private renderer: Renderer2) {}\n\n  @HostListener('mouseenter', ['$event']) onMouseEnter(event: MouseEvent) {\n    this.tooltipElement ? this.showTooltip() : this.createTooltip();\n    this.tooltipPosition(event);\n    this.lastTooltipText = this.tooltip;\n  }\n\n  @HostListener('mouseleave') onMouseLeave() {\n    this.hideTooltip();\n  }\n\n  @HostListener('mousemove', ['$event']) onMouseMove(event: MouseEvent) {\n    this.tooltipPosition(event);\n  }\n\n  private calculateTooltipPosition(event: MouseEvent) {\n    const displacement: number = 12;\n\n    return {\n      left: event.clientX - this.tooltipElement.offsetWidth / 2,\n      top: event.clientY - this.tooltipElement.offsetHeight - displacement\n    };\n  }\n\n  private createTooltip() {\n    const chartWrapper = this.elementRef.nativeElement.closest('.po-chart-wrapper');\n\n    this.tooltipElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.tooltipElement, 'po-chart-tooltip');\n    this.renderer.addClass(this.tooltipElement, 'po-tooltip');\n\n    const divArrow = this.renderer.createElement('div');\n    this.renderer.addClass(divArrow, 'po-tooltip-arrow');\n    this.renderer.addClass(divArrow, 'po-arrow-bottom');\n\n    this.tooltipText = this.renderer.createElement('p');\n    this.renderer.addClass(this.tooltipText, 'po-tooltip-content');\n\n    this.tooltipTextContent = this.renderer.createText(this.tooltip);\n\n    this.renderer.appendChild(this.tooltipText, this.tooltipTextContent);\n    this.renderer.appendChild(this.tooltipElement, divArrow);\n    this.renderer.appendChild(this.tooltipElement, this.tooltipText);\n\n    this.renderer.appendChild(chartWrapper, this.tooltipElement);\n  }\n\n  private hideTooltip() {\n    this.renderer.addClass(this.tooltipElement, 'po-invisible');\n  }\n\n  private showTooltip() {\n    this.renderer.removeClass(this.tooltipElement, 'po-invisible');\n    this.updatetooltipTextContent();\n  }\n\n  private tooltipPosition(event: MouseEvent) {\n    const tooltipPositions = this.calculateTooltipPosition(event);\n\n    this.renderer.setStyle(this.tooltipElement, 'left', `${tooltipPositions.left}px`);\n    this.renderer.setStyle(this.tooltipElement, 'top', `${tooltipPositions.top}px`);\n  }\n\n  private updatetooltipTextContent() {\n    if (this.lastTooltipText !== this.tooltip) {\n      this.renderer.removeChild(this.tooltipText, this.tooltipTextContent);\n      this.tooltipTextContent = this.renderer.createText(this.tooltip);\n      this.renderer.appendChild(this.tooltipText, this.tooltipTextContent);\n    }\n  }\n}\n"]}