@po-ui/ng-components 5.22.3 → 6.2.0

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

@@ -0,0 +1,310 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { PoChartGridLines, PoChartPadding, PoChartPlotAreaPaddingTop } from '../../helpers/po-chart-default-values.constant';
+import { PoChartType } from '../../enums/po-chart-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/po-chart-maths.service";
+import * as i2 from "./po-chart-axis-path/po-chart-axis-path.component";
+import * as i3 from "./po-chart-axis-label/po-chart-axis-label.component";
+const _c0 = ["po-chart-axis", ""];
+export class PoChartAxisComponent {
+    constructor(mathsService) {
+        this.mathsService = mathsService;
+        this.alignByTheCorners = false;
+        this.categoriesCoordinates = new EventEmitter();
+        this.axisXLabels = [];
+        this.axisYLabels = [];
+        this.gridLines = PoChartGridLines;
+        this.seriesLength = 0;
+        this._categories = [];
+        this._containerSize = {};
+        this._series = [];
+    }
+    set series(seriesList) {
+        const seriesDataArrayFilter = seriesList.filter(serie => Array.isArray(serie.data));
+        if (seriesDataArrayFilter.length) {
+            this._series = seriesDataArrayFilter;
+            this.seriesLength = this.mathsService.seriesGreaterLength(this.series);
+            this.checkAxisOptions(this.axisOptions);
+            this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+            this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+        }
+        else {
+            this._series = [];
+            this.cleanUpCoordinates();
+        }
+    }
+    get series() {
+        return this._series;
+    }
+    set categories(value) {
+        this._categories = value;
+        if (this.type === PoChartType.Bar) {
+            this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+        }
+        else {
+            this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+        }
+    }
+    get categories() {
+        return this._categories;
+    }
+    set containerSize(value) {
+        this._containerSize = value;
+        this.checkAxisOptions(this.axisOptions);
+        this.setAxisXCoordinates(this.gridLines, this.seriesLength, this._containerSize, this.range, this.type);
+        this.setAxisYCoordinates(this.gridLines, this.seriesLength, this._containerSize, this.range, this.type);
+    }
+    get containerSize() {
+        return this._containerSize;
+    }
+    set axisOptions(value) {
+        this._axisOptions = value;
+        this.checkAxisOptions(this._axisOptions);
+        if (this.type === PoChartType.Bar) {
+            this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+        }
+        else {
+            this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);
+        }
+    }
+    get axisOptions() {
+        return this._axisOptions;
+    }
+    setAxisXCoordinates(gridLines, seriesLength, containerSize, minMaxAxisValues, type) {
+        if (seriesLength) {
+            const amountOfAxisLabels = type === PoChartType.Bar ? seriesLength : gridLines;
+            this.calculateAxisXLabelCoordinates(amountOfAxisLabels, containerSize, minMaxAxisValues, type);
+        }
+        const amountOfAxisXLines = this.amountOfAxisXLines(seriesLength, gridLines, type);
+        this.calculateAxisXCoordinates(amountOfAxisXLines, containerSize, minMaxAxisValues);
+    }
+    amountOfAxisXLines(seriesLength, gridLines, type) {
+        if (type === PoChartType.Bar) {
+            return seriesLength <= 1 ? 2 : seriesLength + 1;
+        }
+        return gridLines === 0 ? 1 : gridLines;
+    }
+    setAxisYCoordinates(gridLines, seriesLength, containerSize, minMaxAxisValues, type) {
+        const amountOfAxisY = type === PoChartType.Bar ? gridLines : seriesLength;
+        if (seriesLength) {
+            this.calculateAxisYLabelCoordinates(amountOfAxisY, containerSize, minMaxAxisValues, type);
+        }
+        if (type === PoChartType.Area) {
+            this.getCategoriesRangeForMouseMove(amountOfAxisY, containerSize);
+        }
+        this.calculateAxisYCoordinates(amountOfAxisY, containerSize, type, minMaxAxisValues);
+    }
+    calculateAxisXCoordinates(amountOfAxisX, containerSize, range) {
+        const startX = containerSize.axisXLabelWidth;
+        const endX = containerSize.svgWidth;
+        let coordinatesReferedToZero;
+        let coordinatesList = [...Array(amountOfAxisX)].map((_, index) => {
+            const yCoordinate = this.calculateAxisXCoordinateY(amountOfAxisX, containerSize, index);
+            const coordinates = `M${startX} ${yCoordinate} L${endX}, ${yCoordinate}`;
+            return { coordinates };
+        });
+        // Avalia a necessidade de adicionar a linha referente ao valor zero em gráficos do tipo `column`, `area` e `line`.
+        if (this.type !== PoChartType.Bar && range.minValue < 0 && !this.axisXLabels.includes('0')) {
+            coordinatesReferedToZero = this.getCoordinatesRelatedToZero(containerSize, range, startX, endX);
+            coordinatesList = [...coordinatesList, coordinatesReferedToZero];
+        }
+        this.axisXCoordinates = coordinatesList;
+    }
+    getCoordinatesRelatedToZero(containerSize, range, start, end, isAxisY = false) {
+        const type = isAxisY ? PoChartType.Bar : PoChartType.Column;
+        const basePosition = this.axisCoordinatesForValueZero(range, 0, containerSize, isAxisY);
+        const coordinates = {
+            column: {
+                startX: start,
+                endX: end,
+                startY: basePosition,
+                endY: basePosition
+            },
+            bar: {
+                startX: basePosition,
+                endX: basePosition,
+                startY: start,
+                endY: end
+            }
+        };
+        return {
+            coordinates: `M${coordinates[type].startX} ${coordinates[type].startY} L${coordinates[type].endX} ${coordinates[type].endY}`
+        };
+    }
+    axisCoordinatesForValueZero(range, data, containerSize, isAxisY) {
+        const { axisXLabelWidth, svgWidth, svgPlottingAreaHeight } = containerSize;
+        const ratio = this.mathsService.getSeriePercentage(range, data);
+        return Math.floor(isAxisY
+            ? axisXLabelWidth + (svgWidth - axisXLabelWidth) * ratio
+            : svgPlottingAreaHeight - svgPlottingAreaHeight * ratio + PoChartPlotAreaPaddingTop);
+    }
+    calculateAxisXLabelCoordinates(amountOfAxisX, containerSize, minMaxAxisValues, type) {
+        this.axisXLabels = this.getAxisXLabels(type, minMaxAxisValues, amountOfAxisX);
+        this.axisXLabelCoordinates = [...Array(amountOfAxisX)].map((_, index) => {
+            const label = this.axisXLabels[index];
+            const xCoordinate = this.calculateAxisXLabelXCoordinate(containerSize.axisXLabelWidth);
+            const yCoordinate = this.calculateAxisXLabelYCoordinate(amountOfAxisX, containerSize, type, index);
+            return { label, xCoordinate, yCoordinate };
+        });
+    }
+    calculateAxisYCoordinates(amountOfAxisY, containerSize, type, range) {
+        const startY = PoChartPlotAreaPaddingTop;
+        const endY = containerSize.svgPlottingAreaHeight + PoChartPlotAreaPaddingTop;
+        // tratamento necessário para criar uma linha a mais para fechar o gráfico
+        const length = amountOfAxisY === 0 || type === PoChartType.Bar ? amountOfAxisY : amountOfAxisY + 1;
+        let coordinatesReferedToZero;
+        let coordinatesList = [...Array(length)].map((_, index) => {
+            const xCoordinate = this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index);
+            const coordinates = `M${xCoordinate} ${startY} L${xCoordinate}, ${endY}`;
+            return { coordinates };
+        });
+        // Avalia a necessidade de adicionar a linha referente ao valor zero em gráficos do tipo `bar`.
+        if (type === PoChartType.Bar && range.minValue < 0 && !this.axisYLabels.includes('0')) {
+            coordinatesReferedToZero = this.getCoordinatesRelatedToZero(containerSize, range, startY, endY, true);
+            coordinatesList = [...coordinatesList, coordinatesReferedToZero];
+        }
+        this.axisYCoordinates = [...coordinatesList];
+    }
+    calculateAxisYLabelCoordinates(amountOfAxisY, containerSize, minMaxAxisValues, type) {
+        this.axisYLabels = this.getAxisYLabels(type, minMaxAxisValues, amountOfAxisY);
+        this.axisYLabelCoordinates = [...Array(amountOfAxisY)].map((_, index) => {
+            const label = this.axisYLabels[index];
+            const xCoordinate = this.getAxisXCoordinates(containerSize, amountOfAxisY, type, index);
+            const yCoordinate = this.calculateAxisYLabelYCoordinate(containerSize);
+            return { label, xCoordinate, yCoordinate };
+        });
+    }
+    calculateAxisXLabelXCoordinate(axisXLabelWidth) {
+        const labelPoChartPadding = PoChartPadding / 3;
+        return axisXLabelWidth - labelPoChartPadding;
+    }
+    calculateAxisXLabelYCoordinate(amountOfAxisX, containerSize, type, index) {
+        const amountOfLines = type === PoChartType.Bar ? amountOfAxisX : amountOfAxisX - 1;
+        const yRatio = index / amountOfLines;
+        if (type !== PoChartType.Bar) {
+            return (containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop);
+        }
+        const halfCategoryHeight = containerSize.svgPlottingAreaHeight / amountOfAxisX / 2;
+        return (containerSize.svgPlottingAreaHeight -
+            halfCategoryHeight -
+            containerSize.svgPlottingAreaHeight * yRatio +
+            PoChartPlotAreaPaddingTop);
+    }
+    calculateAxisXCoordinateY(amountOfAxisX, containerSize, index) {
+        const yRatio = index / (amountOfAxisX - 1);
+        return (containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop);
+    }
+    calculateAxisYLabelYCoordinate(containerSize) {
+        const textPoChartPadding = PoChartPadding / 3;
+        return containerSize.svgHeight - textPoChartPadding;
+    }
+    centeredInCategoryArea(containerSize, amountOfAxisY, type, index) {
+        const amountOfLines = type === PoChartType.Bar ? amountOfAxisY - 1 : amountOfAxisY;
+        const xRatio = index / amountOfLines;
+        if (type === PoChartType.Bar) {
+            return Math.round(containerSize.axisXLabelWidth + (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio);
+        }
+        const halfCategoryWidth = (containerSize.svgWidth - containerSize.axisXLabelWidth) / amountOfAxisY / 2;
+        return Math.round(containerSize.axisXLabelWidth +
+            halfCategoryWidth +
+            (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio);
+    }
+    calculateAxisYCoordinateX(containerSize, amountOfAxisY, index, subtractCategoryWidth = false) {
+        const amountOfLines = this.alignByTheCorners ? amountOfAxisY - 1 : amountOfAxisY;
+        const halfCategoryWidth = this.alignByTheCorners && subtractCategoryWidth
+            ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / (amountOfAxisY - 1) / 2
+            : 0;
+        const divideIndexByAmountOfLines = index / amountOfLines;
+        const xRatio = divideIndexByAmountOfLines === Infinity ? 0 : divideIndexByAmountOfLines;
+        return Math.round(containerSize.axisXLabelWidth +
+            (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio -
+            halfCategoryWidth);
+    }
+    checkAxisOptions(options = {}) {
+        this.gridLines =
+            options.gridLines && this.isValidGridLinesLengthOption(options.gridLines) ? options.gridLines : PoChartGridLines;
+    }
+    cleanUpCoordinates() {
+        this.axisXCoordinates = [];
+        this.axisYCoordinates = [];
+        this.axisXLabelCoordinates = [];
+        this.axisYLabelCoordinates = [];
+        this.seriesLength = 0;
+    }
+    getAxisXCoordinates(containerSize, amountOfAxisY, type, index) {
+        return this.alignByTheCorners
+            ? this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index)
+            : this.centeredInCategoryArea(containerSize, amountOfAxisY, type, index);
+    }
+    getCategoriesRangeForMouseMove(amountOfAxisY, containerSize) {
+        const categoriesCoordinates = [...Array(amountOfAxisY)].map((_, index) => this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index, true));
+        this.categoriesCoordinates.emit(categoriesCoordinates);
+    }
+    isValidGridLinesLengthOption(gridLines) {
+        return gridLines >= 2 && gridLines <= 10;
+    }
+    getAxisXLabels(type, minMaxAxisValues, amountOfAxisX) {
+        if (type === PoChartType.Bar) {
+            const axisXLabelsList = this.formatCategoriesLabels(amountOfAxisX, this.categories);
+            return axisXLabelsList.reverse();
+        }
+        return this.generateAverageOfLabels(minMaxAxisValues, amountOfAxisX);
+    }
+    getAxisYLabels(type, minMaxAxisValues, amountOfAxisX) {
+        return type === PoChartType.Bar
+            ? this.generateAverageOfLabels(minMaxAxisValues, amountOfAxisX)
+            : this.formatCategoriesLabels(amountOfAxisX, this.categories);
+    }
+    formatCategoriesLabels(amountOfAxisX, categories = []) {
+        return [...Array(amountOfAxisX)].map((_, index) => categories[index] ?? '-');
+    }
+    generateAverageOfLabels(minMaxAxisValues, amountOfAxisLines) {
+        const averageLabelsList = this.mathsService.range(minMaxAxisValues, amountOfAxisLines);
+        return averageLabelsList.map(label => {
+            const formattedDigit = label.toFixed(label % 1 && 2);
+            // Remove dígitos com zero.
+            // Também trata caso quando o valor retornado era -0, substituindo-o por 0.
+            const removeZeroDigits = formattedDigit.replace(/\.00$/, '').replace(/\-0$/, 0);
+            return removeZeroDigits.toString();
+        });
+    }
+}
+PoChartAxisComponent.ɵfac = function PoChartAxisComponent_Factory(t) { return new (t || PoChartAxisComponent)(i0.ɵɵdirectiveInject(i1.PoChartMathsService)); };
+PoChartAxisComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartAxisComponent, selectors: [["", "po-chart-axis", ""]], inputs: { alignByTheCorners: ["p-align-by-the-corners", "alignByTheCorners"], type: ["p-type", "type"], range: ["p-range", "range"], series: ["p-series", "series"], categories: ["p-categories", "categories"], containerSize: ["p-container-size", "containerSize"], axisOptions: ["p-options", "axisOptions"] }, outputs: { categoriesCoordinates: "p-categories-coordinates" }, attrs: _c0, decls: 2, vars: 6, consts: [["po-chart-axis-path", "", 3, "p-axis-x-coordinates", "p-axis-y-coordinates"], ["po-chart-axis-label", "", 3, "p-align-by-the-corners", "p-axis-x-label-coordinates", "p-axis-y-label-coordinates", "p-type"]], template: function PoChartAxisComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelement(0, "g", 0);
+        i0.ɵɵelement(1, "g", 1);
+    } if (rf & 2) {
+        i0.ɵɵproperty("p-axis-x-coordinates", ctx.axisXCoordinates)("p-axis-y-coordinates", ctx.axisYCoordinates);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("p-align-by-the-corners", ctx.alignByTheCorners)("p-axis-x-label-coordinates", ctx.axisXLabelCoordinates)("p-axis-y-label-coordinates", ctx.axisYLabelCoordinates)("p-type", ctx.type);
+    } }, directives: [i2.PoChartAxisPathComponent, i3.PoChartAxisLabelComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartAxisComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-axis]', template: "<svg:g po-chart-axis-path [p-axis-x-coordinates]=\"axisXCoordinates\" [p-axis-y-coordinates]=\"axisYCoordinates\"></svg:g>\n\n<svg:g po-chart-axis-label \n  [p-align-by-the-corners]=\"alignByTheCorners\" \n  [p-axis-x-label-coordinates]=\"axisXLabelCoordinates\" \n  [p-axis-y-label-coordinates]=\"axisYLabelCoordinates\" \n  [p-type]=\"type\"\n  >\n</svg:g>" }]
+    }], function () { return [{ type: i1.PoChartMathsService }]; }, { alignByTheCorners: [{
+            type: Input,
+            args: ['p-align-by-the-corners']
+        }], type: [{
+            type: Input,
+            args: ['p-type']
+        }], range: [{
+            type: Input,
+            args: ['p-range']
+        }], categoriesCoordinates: [{
+            type: Output,
+            args: ['p-categories-coordinates']
+        }], series: [{
+            type: Input,
+            args: ['p-series']
+        }], categories: [{
+            type: Input,
+            args: ['p-categories']
+        }], containerSize: [{
+            type: Input,
+            args: ['p-container-size']
+        }], axisOptions: [{
+            type: Input,
+            args: ['p-options']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-axis.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-axis/po-chart-axis.component.ts","../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-axis/po-chart-axis.component.svg"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\n\nimport {\n  PoChartGridLines,\n  PoChartPadding,\n  PoChartPlotAreaPaddingTop\n} from '../../helpers/po-chart-default-values.constant';\n\nimport { PoChartMathsService } from '../../services/po-chart-maths.service';\nimport { PoChartContainerSize } from '../../interfaces/po-chart-container-size.interface';\nimport { PoChartMinMaxValues } from '../../interfaces/po-chart-min-max-values.interface';\nimport { PoChartPathCoordinates } from '../../interfaces/po-chart-path-coordinates.interface';\nimport { PoChartLabelCoordinates } from '../../interfaces/po-chart-label-coordinates.interface';\nimport { PoChartAxisOptions } from '../../interfaces/po-chart-axis-options.interface';\nimport { PoChartType } from '../../enums/po-chart-type.enum';\n\n@Component({\n  selector: '[po-chart-axis]',\n  templateUrl: './po-chart-axis.component.svg'\n})\nexport class PoChartAxisComponent {\n  @Input('p-align-by-the-corners') alignByTheCorners: boolean = false;\n\n  @Input('p-type') type: PoChartType;\n\n  @Input('p-range') range: PoChartMinMaxValues;\n\n  @Output('p-categories-coordinates') categoriesCoordinates: EventEmitter<Array<number>> = new EventEmitter();\n\n  axisXCoordinates: Array<PoChartPathCoordinates>;\n  axisXLabelCoordinates: Array<PoChartLabelCoordinates>;\n  axisYCoordinates: Array<PoChartPathCoordinates>;\n  axisYLabelCoordinates: Array<PoChartLabelCoordinates>;\n\n  private axisXLabels: Array<string> = [];\n  private axisYLabels: Array<string> = [];\n  private gridLines: number = PoChartGridLines;\n  private seriesLength: number = 0;\n\n  private _axisOptions: PoChartAxisOptions;\n  private _categories: Array<string> = [];\n  private _containerSize: PoChartContainerSize = {};\n  private _series: Array<any> = [];\n\n  @Input('p-series') set series(seriesList: Array<any>) {\n    const seriesDataArrayFilter = seriesList.filter(serie => Array.isArray(serie.data));\n\n    if (seriesDataArrayFilter.length) {\n      this._series = seriesDataArrayFilter;\n\n      this.seriesLength = this.mathsService.seriesGreaterLength(this.series);\n      this.checkAxisOptions(this.axisOptions);\n      this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n      this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n    } else {\n      this._series = [];\n      this.cleanUpCoordinates();\n    }\n  }\n\n  get series() {\n    return this._series;\n  }\n\n  @Input('p-categories') set categories(value: Array<string>) {\n    this._categories = value;\n\n    if (this.type === PoChartType.Bar) {\n      this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n    } else {\n      this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n    }\n  }\n\n  get categories() {\n    return this._categories;\n  }\n\n  @Input('p-container-size') set containerSize(value: PoChartContainerSize) {\n    this._containerSize = value;\n\n    this.checkAxisOptions(this.axisOptions);\n    this.setAxisXCoordinates(this.gridLines, this.seriesLength, this._containerSize, this.range, this.type);\n    this.setAxisYCoordinates(this.gridLines, this.seriesLength, this._containerSize, this.range, this.type);\n  }\n\n  get containerSize() {\n    return this._containerSize;\n  }\n\n  @Input('p-options') set axisOptions(value: PoChartAxisOptions) {\n    this._axisOptions = value;\n\n    this.checkAxisOptions(this._axisOptions);\n\n    if (this.type === PoChartType.Bar) {\n      this.setAxisYCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n    } else {\n      this.setAxisXCoordinates(this.gridLines, this.seriesLength, this.containerSize, this.range, this.type);\n    }\n  }\n\n  get axisOptions() {\n    return this._axisOptions;\n  }\n\n  constructor(private mathsService: PoChartMathsService) {}\n\n  private setAxisXCoordinates(\n    gridLines: number,\n    seriesLength: number,\n    containerSize: PoChartContainerSize,\n    minMaxAxisValues: PoChartMinMaxValues,\n    type: PoChartType\n  ) {\n    if (seriesLength) {\n      const amountOfAxisLabels = type === PoChartType.Bar ? seriesLength : gridLines;\n      this.calculateAxisXLabelCoordinates(amountOfAxisLabels, containerSize, minMaxAxisValues, type);\n    }\n\n    const amountOfAxisXLines = this.amountOfAxisXLines(seriesLength, gridLines, type);\n    this.calculateAxisXCoordinates(amountOfAxisXLines, containerSize, minMaxAxisValues);\n  }\n\n  private amountOfAxisXLines(seriesLength: number, gridLines: number, type: PoChartType): number {\n    if (type === PoChartType.Bar) {\n      return seriesLength <= 1 ? 2 : seriesLength + 1;\n    }\n    return gridLines === 0 ? 1 : gridLines;\n  }\n\n  private setAxisYCoordinates(\n    gridLines: number,\n    seriesLength: number,\n    containerSize: PoChartContainerSize,\n    minMaxAxisValues: PoChartMinMaxValues,\n    type: PoChartType\n  ) {\n    const amountOfAxisY = type === PoChartType.Bar ? gridLines : seriesLength;\n\n    if (seriesLength) {\n      this.calculateAxisYLabelCoordinates(amountOfAxisY, containerSize, minMaxAxisValues, type);\n    }\n\n    if (type === PoChartType.Area) {\n      this.getCategoriesRangeForMouseMove(amountOfAxisY, containerSize);\n    }\n\n    this.calculateAxisYCoordinates(amountOfAxisY, containerSize, type, minMaxAxisValues);\n  }\n\n  private calculateAxisXCoordinates(\n    amountOfAxisX: number,\n    containerSize: PoChartContainerSize,\n    range: PoChartMinMaxValues\n  ) {\n    const startX = containerSize.axisXLabelWidth;\n    const endX = containerSize.svgWidth;\n\n    let coordinatesReferedToZero;\n    let coordinatesList = [...Array(amountOfAxisX)].map((_, index: number) => {\n      const yCoordinate = this.calculateAxisXCoordinateY(amountOfAxisX, containerSize, index);\n      const coordinates = `M${startX} ${yCoordinate} L${endX}, ${yCoordinate}`;\n\n      return { coordinates };\n    });\n\n    // Avalia a necessidade de adicionar a linha referente ao valor zero em gráficos do tipo `column`, `area` e `line`.\n    if (this.type !== PoChartType.Bar && range.minValue < 0 && !this.axisXLabels.includes('0')) {\n      coordinatesReferedToZero = this.getCoordinatesRelatedToZero(containerSize, range, startX, endX);\n      coordinatesList = [...coordinatesList, coordinatesReferedToZero];\n    }\n\n    this.axisXCoordinates = coordinatesList;\n  }\n\n  private getCoordinatesRelatedToZero(\n    containerSize: PoChartContainerSize,\n    range: PoChartMinMaxValues,\n    start: number,\n    end: number,\n    isAxisY: boolean = false\n  ) {\n    const type = isAxisY ? PoChartType.Bar : PoChartType.Column;\n    const basePosition = this.axisCoordinatesForValueZero(range, 0, containerSize, isAxisY);\n    const coordinates = {\n      column: {\n        startX: start,\n        endX: end,\n        startY: basePosition,\n        endY: basePosition\n      },\n      bar: {\n        startX: basePosition,\n        endX: basePosition,\n        startY: start,\n        endY: end\n      }\n    };\n\n    return {\n      coordinates: `M${coordinates[type].startX} ${coordinates[type].startY} L${coordinates[type].endX} ${coordinates[type].endY}`\n    };\n  }\n\n  private axisCoordinatesForValueZero(\n    range: PoChartMinMaxValues,\n    data: number,\n    containerSize: PoChartContainerSize,\n    isAxisY: boolean\n  ) {\n    const { axisXLabelWidth, svgWidth, svgPlottingAreaHeight } = containerSize;\n    const ratio = this.mathsService.getSeriePercentage(range, data);\n\n    return Math.floor(\n      isAxisY\n        ? axisXLabelWidth + (svgWidth - axisXLabelWidth) * ratio\n        : svgPlottingAreaHeight - svgPlottingAreaHeight * ratio + PoChartPlotAreaPaddingTop\n    );\n  }\n\n  private calculateAxisXLabelCoordinates(\n    amountOfAxisX: number,\n    containerSize: PoChartContainerSize,\n    minMaxAxisValues: PoChartMinMaxValues,\n    type: PoChartType\n  ) {\n    this.axisXLabels = this.getAxisXLabels(type, minMaxAxisValues, amountOfAxisX);\n\n    this.axisXLabelCoordinates = [...Array(amountOfAxisX)].map((_, index: number) => {\n      const label = this.axisXLabels[index];\n      const xCoordinate = this.calculateAxisXLabelXCoordinate(containerSize.axisXLabelWidth);\n      const yCoordinate = this.calculateAxisXLabelYCoordinate(amountOfAxisX, containerSize, type, index);\n\n      return { label, xCoordinate, yCoordinate };\n    });\n  }\n\n  private calculateAxisYCoordinates(\n    amountOfAxisY: number,\n    containerSize: PoChartContainerSize,\n    type: PoChartType,\n    range: PoChartMinMaxValues\n  ) {\n    const startY = PoChartPlotAreaPaddingTop;\n    const endY = containerSize.svgPlottingAreaHeight + PoChartPlotAreaPaddingTop;\n\n    // tratamento necessário para criar uma linha a mais para fechar o gráfico\n    const length = amountOfAxisY === 0 || type === PoChartType.Bar ? amountOfAxisY : amountOfAxisY + 1;\n\n    let coordinatesReferedToZero;\n    let coordinatesList = [...Array(length)].map((_, index: number) => {\n      const xCoordinate = this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index);\n      const coordinates = `M${xCoordinate} ${startY} L${xCoordinate}, ${endY}`;\n\n      return { coordinates };\n    });\n\n    // Avalia a necessidade de adicionar a linha referente ao valor zero em gráficos do tipo `bar`.\n    if (type === PoChartType.Bar && range.minValue < 0 && !this.axisYLabels.includes('0')) {\n      coordinatesReferedToZero = this.getCoordinatesRelatedToZero(containerSize, range, startY, endY, true);\n      coordinatesList = [...coordinatesList, coordinatesReferedToZero];\n    }\n\n    this.axisYCoordinates = [...coordinatesList];\n  }\n\n  private calculateAxisYLabelCoordinates(\n    amountOfAxisY: number,\n    containerSize: PoChartContainerSize,\n    minMaxAxisValues: PoChartMinMaxValues,\n    type: PoChartType\n  ) {\n    this.axisYLabels = this.getAxisYLabels(type, minMaxAxisValues, amountOfAxisY);\n\n    this.axisYLabelCoordinates = [...Array(amountOfAxisY)].map((_, index: number) => {\n      const label = this.axisYLabels[index];\n\n      const xCoordinate = this.getAxisXCoordinates(containerSize, amountOfAxisY, type, index);\n      const yCoordinate = this.calculateAxisYLabelYCoordinate(containerSize);\n\n      return { label, xCoordinate, yCoordinate };\n    });\n  }\n\n  private calculateAxisXLabelXCoordinate(axisXLabelWidth: number): number {\n    const labelPoChartPadding = PoChartPadding / 3;\n\n    return axisXLabelWidth - labelPoChartPadding;\n  }\n\n  private calculateAxisXLabelYCoordinate(\n    amountOfAxisX: number,\n    containerSize: PoChartContainerSize,\n    type: PoChartType,\n    index: number\n  ): number {\n    const amountOfLines = type === PoChartType.Bar ? amountOfAxisX : amountOfAxisX - 1;\n    const yRatio = index / amountOfLines;\n\n    if (type !== PoChartType.Bar) {\n      return (\n        containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop\n      );\n    }\n\n    const halfCategoryHeight = containerSize.svgPlottingAreaHeight / amountOfAxisX / 2;\n    return (\n      containerSize.svgPlottingAreaHeight -\n      halfCategoryHeight -\n      containerSize.svgPlottingAreaHeight * yRatio +\n      PoChartPlotAreaPaddingTop\n    );\n  }\n\n  private calculateAxisXCoordinateY(amountOfAxisX: number, containerSize: PoChartContainerSize, index: number): number {\n    const yRatio = index / (amountOfAxisX - 1);\n\n    return (\n      containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRatio + PoChartPlotAreaPaddingTop\n    );\n  }\n\n  private calculateAxisYLabelYCoordinate(containerSize: PoChartContainerSize): number {\n    const textPoChartPadding = PoChartPadding / 3;\n\n    return containerSize.svgHeight - textPoChartPadding;\n  }\n\n  private centeredInCategoryArea(\n    containerSize: PoChartContainerSize,\n    amountOfAxisY: number,\n    type: PoChartType,\n    index: number\n  ): number {\n    const amountOfLines = type === PoChartType.Bar ? amountOfAxisY - 1 : amountOfAxisY;\n    const xRatio = index / amountOfLines;\n\n    if (type === PoChartType.Bar) {\n      return Math.round(\n        containerSize.axisXLabelWidth + (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio\n      );\n    }\n\n    const halfCategoryWidth = (containerSize.svgWidth - containerSize.axisXLabelWidth) / amountOfAxisY / 2;\n    return Math.round(\n      containerSize.axisXLabelWidth +\n        halfCategoryWidth +\n        (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio\n    );\n  }\n\n  private calculateAxisYCoordinateX(\n    containerSize: PoChartContainerSize,\n    amountOfAxisY: number,\n    index: number,\n    subtractCategoryWidth: boolean = false\n  ): number {\n    const amountOfLines = this.alignByTheCorners ? amountOfAxisY - 1 : amountOfAxisY;\n    const halfCategoryWidth =\n      this.alignByTheCorners && subtractCategoryWidth\n        ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / (amountOfAxisY - 1) / 2\n        : 0;\n    const divideIndexByAmountOfLines = index / amountOfLines;\n    const xRatio = divideIndexByAmountOfLines === Infinity ? 0 : divideIndexByAmountOfLines;\n\n    return Math.round(\n      containerSize.axisXLabelWidth +\n        (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio -\n        halfCategoryWidth\n    );\n  }\n\n  private checkAxisOptions(options: PoChartAxisOptions = {}): void {\n    this.gridLines =\n      options.gridLines && this.isValidGridLinesLengthOption(options.gridLines) ? options.gridLines : PoChartGridLines;\n  }\n\n  private cleanUpCoordinates() {\n    this.axisXCoordinates = [];\n    this.axisYCoordinates = [];\n    this.axisXLabelCoordinates = [];\n    this.axisYLabelCoordinates = [];\n    this.seriesLength = 0;\n  }\n\n  private getAxisXCoordinates(\n    containerSize: PoChartContainerSize,\n    amountOfAxisY: number,\n    type: PoChartType,\n    index: number\n  ): number {\n    return this.alignByTheCorners\n      ? this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index)\n      : this.centeredInCategoryArea(containerSize, amountOfAxisY, type, index);\n  }\n\n  private getCategoriesRangeForMouseMove(amountOfAxisY: number, containerSize: PoChartContainerSize) {\n    const categoriesCoordinates = [...Array(amountOfAxisY)].map((_, index: number) =>\n      this.calculateAxisYCoordinateX(containerSize, amountOfAxisY, index, true)\n    );\n\n    this.categoriesCoordinates.emit(categoriesCoordinates);\n  }\n\n  private isValidGridLinesLengthOption(gridLines: number): boolean {\n    return gridLines >= 2 && gridLines <= 10;\n  }\n\n  private getAxisXLabels(type: PoChartType, minMaxAxisValues: PoChartMinMaxValues, amountOfAxisX: number) {\n    if (type === PoChartType.Bar) {\n      const axisXLabelsList = this.formatCategoriesLabels(amountOfAxisX, this.categories);\n      return axisXLabelsList.reverse();\n    }\n\n    return this.generateAverageOfLabels(minMaxAxisValues, amountOfAxisX);\n  }\n\n  private getAxisYLabels(type: PoChartType, minMaxAxisValues: PoChartMinMaxValues, amountOfAxisX: number) {\n    return type === PoChartType.Bar\n      ? this.generateAverageOfLabels(minMaxAxisValues, amountOfAxisX)\n      : this.formatCategoriesLabels(amountOfAxisX, this.categories);\n  }\n\n  private formatCategoriesLabels(amountOfAxisX: number, categories: Array<string> = []) {\n    return [...Array(amountOfAxisX)].map((_, index: number) => categories[index] ?? '-');\n  }\n\n  private generateAverageOfLabels(minMaxAxisValues: PoChartMinMaxValues, amountOfAxisLines: number) {\n    const averageLabelsList = this.mathsService.range(minMaxAxisValues, amountOfAxisLines);\n\n    return averageLabelsList.map(label => {\n      const formattedDigit = label.toFixed(label % 1 && 2);\n      // Remove dígitos com zero.\n      // Também trata caso quando o valor retornado era -0, substituindo-o por 0.\n      const removeZeroDigits = formattedDigit.replace(/\\.00$/, '').replace(/\\-0$/, 0);\n\n      return removeZeroDigits.toString();\n    });\n  }\n}\n","<svg:g po-chart-axis-path [p-axis-x-coordinates]=\"axisXCoordinates\" [p-axis-y-coordinates]=\"axisYCoordinates\"></svg:g>\n\n<svg:g po-chart-axis-label \n  [p-align-by-the-corners]=\"alignByTheCorners\" \n  [p-axis-x-label-coordinates]=\"axisXLabelCoordinates\" \n  [p-axis-y-label-coordinates]=\"axisYLabelCoordinates\" \n  [p-type]=\"type\"\n  >\n</svg:g>"]}

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

@@ -0,0 +1,103 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/po-chart-maths.service";
+export class PoChartBarBaseComponent {
+    constructor(mathsService) {
+        this.mathsService = mathsService;
+        this.barClick = new EventEmitter();
+        this.barHover = new EventEmitter();
+        this._containerSize = {};
+        this._range = {};
+        this._series = [];
+    }
+    set range(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._range = value;
+            this.calculateSeriesPathsCoordinates(this.containerSize, this._series, this._range);
+        }
+    }
+    get range() {
+        return this._range;
+    }
+    set containerSize(value) {
+        this._containerSize = value;
+        this.calculateSeriesPathsCoordinates(this._containerSize, this.series, this.range);
+    }
+    get containerSize() {
+        return this._containerSize;
+    }
+    set series(seriesList) {
+        const seriesDataArrayFilter = seriesList.filter(serie => Array.isArray(serie.data));
+        if (seriesDataArrayFilter.length) {
+            this._series = seriesDataArrayFilter;
+            this.seriesGreaterLength = this.mathsService.seriesGreaterLength(this.series);
+            this.calculateSeriesPathsCoordinates(this.containerSize, seriesDataArrayFilter, this.range);
+        }
+        else {
+            this._series = [];
+        }
+    }
+    get series() {
+        return this._series;
+    }
+    onSerieBarClick(selectedItem) {
+        this.barClick.emit(selectedItem);
+    }
+    onSerieBarHover(selectedItem) {
+        this.barHover.emit(selectedItem);
+    }
+    trackBy(index) {
+        return index;
+    }
+    calculateSeriesPathsCoordinates(containerSize, series, range) {
+        this.seriesPathsCoordinates = series.map((serie, seriesIndex) => {
+            if (Array.isArray(serie.data)) {
+                let pathCoordinates = [];
+                serie.data.forEach((data, serieDataIndex) => {
+                    if (this.mathsService.verifyIfFloatOrInteger(data)) {
+                        const coordinates = this.barCoordinates(seriesIndex, serieDataIndex, containerSize, range, data);
+                        const category = this.serieCategory(serieDataIndex, this.categories);
+                        const label = serie['label'];
+                        const color = serie['color'];
+                        const tooltip = serie['tooltip'];
+                        const tooltipLabel = this.getTooltipLabel(data, label, tooltip);
+                        pathCoordinates = [...pathCoordinates, { category, color, label, tooltipLabel, data, coordinates }];
+                    }
+                });
+                return pathCoordinates;
+            }
+        });
+    }
+    getTooltipLabel(data, label, tooltipLabel) {
+        const dataLabel = label ? `${label}: ` : '';
+        const dataValue = data.toString();
+        return tooltipLabel || `${dataLabel}${dataValue}`;
+    }
+    serieCategory(index, categories = []) {
+        return categories[index] ?? undefined;
+    }
+}
+PoChartBarBaseComponent.ɵfac = function PoChartBarBaseComponent_Factory(t) { return new (t || PoChartBarBaseComponent)(i0.ɵɵdirectiveInject(i1.PoChartMathsService)); };
+PoChartBarBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoChartBarBaseComponent, inputs: { categories: ["p-categories", "categories"], range: ["p-range", "range"], containerSize: ["p-container-size", "containerSize"], series: ["p-series", "series"] }, outputs: { barClick: "p-bar-click", barHover: "p-bar-hover" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartBarBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.PoChartMathsService }]; }, { categories: [{
+            type: Input,
+            args: ['p-categories']
+        }], barClick: [{
+            type: Output,
+            args: ['p-bar-click']
+        }], barHover: [{
+            type: Output,
+            args: ['p-bar-hover']
+        }], range: [{
+            type: Input,
+            args: ['p-range']
+        }], containerSize: [{
+            type: Input,
+            args: ['p-container-size']
+        }], series: [{
+            type: Input,
+            args: ['p-series']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-bar-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-bar/po-chart-bar-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EventEmitter, Input, Output } from '@angular/core';\n\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';\nimport { PoChartBarCoordinates } from '../../interfaces/po-chart-bar-coordinates.interface';\nimport { PoChartSerie } from '../../interfaces/po-chart-serie.interface';\n\n@Directive()\nexport abstract class PoChartBarBaseComponent {\n  @Input('p-categories') categories: Array<string>;\n\n  @Output('p-bar-click') barClick = new EventEmitter<any>();\n\n  @Output('p-bar-hover') barHover = new EventEmitter<any>();\n\n  seriesPathsCoordinates: Array<Array<PoChartBarCoordinates>>;\n\n  protected seriesGreaterLength: number;\n\n  private _containerSize: PoChartContainerSize = {};\n  private _range: PoChartMinMaxValues = {};\n  private _series: Array<PoChartSerie> = [];\n\n  @Input('p-range') set range(value: PoChartMinMaxValues) {\n    if (value instanceof Object && !(value instanceof Array)) {\n      this._range = value;\n\n      this.calculateSeriesPathsCoordinates(this.containerSize, this._series, this._range);\n    }\n  }\n\n  get range() {\n    return this._range;\n  }\n\n  @Input('p-container-size') set containerSize(value: PoChartContainerSize) {\n    this._containerSize = value;\n\n    this.calculateSeriesPathsCoordinates(this._containerSize, this.series, this.range);\n  }\n\n  get containerSize() {\n    return this._containerSize;\n  }\n\n  @Input('p-series') set series(seriesList: Array<PoChartSerie>) {\n    const seriesDataArrayFilter = seriesList.filter(serie => Array.isArray(serie.data));\n\n    if (seriesDataArrayFilter.length) {\n      this._series = seriesDataArrayFilter;\n      this.seriesGreaterLength = this.mathsService.seriesGreaterLength(this.series);\n      this.calculateSeriesPathsCoordinates(this.containerSize, seriesDataArrayFilter, this.range);\n    } else {\n      this._series = [];\n    }\n  }\n\n  get series() {\n    return this._series;\n  }\n\n  constructor(protected mathsService: PoChartMathsService) {}\n\n  onSerieBarClick(selectedItem: any) {\n    this.barClick.emit(selectedItem);\n  }\n\n  onSerieBarHover(selectedItem: any) {\n    this.barHover.emit(selectedItem);\n  }\n\n  trackBy(index) {\n    return index;\n  }\n\n  private calculateSeriesPathsCoordinates(\n    containerSize: PoChartContainerSize,\n    series: Array<PoChartSerie>,\n    range: PoChartMinMaxValues\n  ) {\n    this.seriesPathsCoordinates = series.map((serie: PoChartSerie, seriesIndex) => {\n      if (Array.isArray(serie.data)) {\n        let pathCoordinates: Array<PoChartBarCoordinates> = [];\n\n        serie.data.forEach((data, serieDataIndex) => {\n          if (this.mathsService.verifyIfFloatOrInteger(data)) {\n            const coordinates = this.barCoordinates(seriesIndex, serieDataIndex, containerSize, range, data);\n\n            const category = this.serieCategory(serieDataIndex, this.categories);\n            const label = serie['label'];\n            const color = serie['color'];\n            const tooltip = serie['tooltip'];\n            const tooltipLabel = this.getTooltipLabel(data, label, tooltip);\n\n            pathCoordinates = [...pathCoordinates, { category, color, label, tooltipLabel, data, coordinates }];\n          }\n        });\n\n        return pathCoordinates;\n      }\n    });\n  }\n\n  private getTooltipLabel(data: number, label: string, tooltipLabel: string) {\n    const dataLabel = label ? `${label}: ` : '';\n    const dataValue = data.toString();\n\n    return tooltipLabel || `${dataLabel}${dataValue}`;\n  }\n\n  private serieCategory(index: number, categories: Array<string> = []) {\n    return categories[index] ?? undefined;\n  }\n\n  protected abstract barCoordinates(\n    seriesIndex: number,\n    serieDataIndex: number,\n    containerSize: PoChartContainerSize,\n    range: PoChartMinMaxValues,\n    serieValue: number\n  );\n}\n"]}

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

@@ -0,0 +1,61 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../../directives/po-tooltip/po-tooltip.directive";
+const _c0 = ["po-chart-bar-path", ""];
+function PoChartBarPathComponent__svg_path_0_Template(rf, ctx) { if (rf & 1) {
+    const _r3 = i0.ɵɵgetCurrentView();
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "path", 1);
+    i0.ɵɵlistener("mouseenter", function PoChartBarPathComponent__svg_path_0_Template__svg_path_mouseenter_0_listener() { const restoredCtx = i0.ɵɵrestoreView(_r3); const item_r1 = restoredCtx.$implicit; const ctx_r2 = i0.ɵɵnextContext(); return ctx_r2.onMouseEnter(item_r1); })("click", function PoChartBarPathComponent__svg_path_0_Template__svg_path_click_0_listener() { const restoredCtx = i0.ɵɵrestoreView(_r3); const item_r1 = restoredCtx.$implicit; const ctx_r4 = i0.ɵɵnextContext(); return ctx_r4.onClick(item_r1); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r1 = ctx.$implicit;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵclassMap((ctx_r0.color == null ? null : ctx_r0.color.includes("po-color")) ? ctx_r0.color : "");
+    i0.ɵɵproperty("p-tooltip", item_r1.tooltipLabel)("p-tooltip-position", ctx_r0.tooltipPosition)("p-append-in-body", true);
+    i0.ɵɵattribute("fill", ctx_r0.color)("d", item_r1.coordinates);
+} }
+export class PoChartBarPathComponent {
+    constructor() {
+        this.barClick = new EventEmitter();
+        this.barHover = new EventEmitter();
+    }
+    trackBy(index) {
+        return index;
+    }
+    onClick(item) {
+        const selectedItem = { label: item.label, data: item.data, category: item.category };
+        this.barClick.emit(selectedItem);
+    }
+    onMouseEnter(item) {
+        const selectedItem = { label: item.label, data: item.data, category: item.category };
+        this.barHover.emit(selectedItem);
+    }
+}
+PoChartBarPathComponent.ɵfac = function PoChartBarPathComponent_Factory(t) { return new (t || PoChartBarPathComponent)(); };
+PoChartBarPathComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartBarPathComponent, selectors: [["", "po-chart-bar-path", ""]], inputs: { color: ["p-color", "color"], coordinates: ["p-coordinates", "coordinates"], tooltipPosition: ["p-tooltip-position", "tooltipPosition"] }, outputs: { barClick: "p-bar-click", barHover: "p-bar-hover" }, attrs: _c0, decls: 1, vars: 2, consts: [["class", "po-chart-bar-path", 3, "p-tooltip", "p-tooltip-position", "p-append-in-body", "class", "mouseenter", "click", 4, "ngFor", "ngForOf", "ngForTrackBy"], [1, "po-chart-bar-path", 3, "p-tooltip", "p-tooltip-position", "p-append-in-body", "mouseenter", "click"]], template: function PoChartBarPathComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, PoChartBarPathComponent__svg_path_0_Template, 1, 7, "path", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngForOf", ctx.coordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i1.NgForOf, i2.PoTooltipDirective], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartBarPathComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-bar-path]', template: "<svg:path *ngFor=\"let item of coordinates; trackBy: trackBy\"\n  [p-tooltip]=\"item.tooltipLabel\"\n  [p-tooltip-position]=\"tooltipPosition\"\n  [p-append-in-body]='true'\n  class=\"po-chart-bar-path\"\n  [class]=\"color?.includes('po-color') ? color : ''\"\n  [attr.fill]=\"color\"\n  [attr.d]=\"item.coordinates\"\n  (mouseenter)=\"onMouseEnter(item)\"\n  (click)=\"onClick(item)\">\n</svg:path> \n" }]
+    }], function () { return []; }, { color: [{
+            type: Input,
+            args: ['p-color']
+        }], coordinates: [{
+            type: Input,
+            args: ['p-coordinates']
+        }], tooltipPosition: [{
+            type: Input,
+            args: ['p-tooltip-position']
+        }], barClick: [{
+            type: Output,
+            args: ['p-bar-click']
+        }], barHover: [{
+            type: Output,
+            args: ['p-bar-hover']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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