@po-ui/ng-components 5.22.3 → 5.22.6

package/esm2015/lib/components/po-chart/po-chart-container/po-chart-line/po-chart-line-base.component.js

@@ -1,151 +1,151 @@
-import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild } from '@angular/core';
-import { PoChartType } from '../../enums/po-chart-type.enum';
-import { PoChartPlotAreaPaddingTop } from '../../helpers/po-chart-default-values.constant';
-import { PoChartMathsService } from '../../services/po-chart-maths.service';
-export class PoChartLineBaseComponent {
-    constructor(mathsService, renderer, elementRef) {
-        this.mathsService = mathsService;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.alignByTheCorners = false;
-        this.pointClick = new EventEmitter();
-        this.pointHover = new EventEmitter();
-        this.animate = true;
-        this.seriesPointsCoordinates = [];
-        this._containerSize = {};
-        this._range = {};
-        this._series = [];
-    }
-    set range(value) {
-        if (value instanceof Object && !(value instanceof Array)) {
-            this._range = value;
-            this.seriePathPointsDefinition(this.containerSize, this._series, this._range);
-        }
-    }
-    get range() {
-        return this._range;
-    }
-    set containerSize(value) {
-        this._containerSize = value;
-        this.seriePathPointsDefinition(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.animate = true;
-            this.seriesLength = this.mathsService.seriesGreaterLength(this.series);
-            this.chartType = this._series[0].type;
-            this.seriePathPointsDefinition(this.containerSize, seriesDataArrayFilter, this.range);
-        }
-        else {
-            this._series = [];
-        }
-    }
-    get series() {
-        return this._series;
-    }
-    onSeriePointClick(selectedItem) {
-        this.pointClick.emit(selectedItem);
-    }
-    trackBy(index) {
-        return index;
-    }
-    getTooltipLabel(data, label, tooltipLabel) {
-        const dataLabel = label ? `${label}: ` : '';
-        const dataValue = data.toString();
-        return tooltipLabel || `${dataLabel}${dataValue}`;
-    }
-    svgPathCommand() {
-        const command = this.firstValidItemFromSerieArray ? 'M' : 'L';
-        // firstValidItemFromSerieArray: tratamento para permitir ao usuário definir o primeiro valor como null para que seja ignorado;
-        this.firstValidItemFromSerieArray = false;
-        return command;
-    }
-    xCoordinate(index, containerSize) {
-        const halfCategoryWidth = !this.alignByTheCorners
-            ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / this.seriesLength / 2
-            : 0;
-        const divideIndexBySeriesLength = index / (this.alignByTheCorners ? this.seriesLength - 1 : this.seriesLength);
-        const xRatio = isNaN(divideIndexBySeriesLength) ? 0 : divideIndexBySeriesLength;
-        return Math.floor(containerSize.axisXLabelWidth +
-            halfCategoryWidth +
-            (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio);
-    }
-    serieCategory(index, categories = []) {
-        var _a;
-        return (_a = categories[index]) !== null && _a !== void 0 ? _a : undefined;
-    }
-    seriePathPointsDefinition(containerSize, series, range) {
-        this.seriesPointsCoordinates = [];
-        this.seriesPathsCoordinates = series.map((serie) => {
-            if (Array.isArray(serie.data)) {
-                let pathCoordinates = '';
-                let pointCoordinates = [];
-                const color = serie.color;
-                this.firstValidItemFromSerieArray = true;
-                serie.data.forEach((data, index) => {
-                    if (this.mathsService.verifyIfFloatOrInteger(data)) {
-                        const svgPathCommand = this.svgPathCommand();
-                        const xCoordinate = this.xCoordinate(index, containerSize);
-                        const yCoordinate = this.yCoordinate(range, data, containerSize);
-                        const category = this.serieCategory(index, this.categories);
-                        const label = serie.label;
-                        const tooltip = serie.tooltip;
-                        const tooltipLabel = this.getTooltipLabel(data, label, tooltip);
-                        const isActive = this.chartType === PoChartType.Line;
-                        pointCoordinates = [
-                            ...pointCoordinates,
-                            { category, label, tooltipLabel, data: data, xCoordinate, yCoordinate, color, isActive }
-                        ];
-                        pathCoordinates += ` ${svgPathCommand}${xCoordinate} ${yCoordinate}`;
-                    }
-                });
-                pathCoordinates = this.verifyIfClosePath(pathCoordinates, serie.data.length - 1, range, 0, containerSize);
-                this.seriesPointsCoordinates = [...this.seriesPointsCoordinates, pointCoordinates];
-                return { coordinates: pathCoordinates, color, isActive: true };
-            }
-        });
-    }
-    verifyIfClosePath(pathCoordinates, lastIndex, range, data, containerSize) {
-        const { axisXLabelWidth, svgWidth } = containerSize;
-        if (this.chartType === PoChartType.Area) {
-            const xLastPosition = this.xCoordinate(lastIndex, containerSize);
-            const baseYCoordinate = this.yCoordinate(range, data, containerSize);
-            const xInitialPosition = Math.floor(this.alignByTheCorners
-                ? axisXLabelWidth
-                : axisXLabelWidth + (svgWidth - axisXLabelWidth) / this.seriesLength / 2);
-            return `${pathCoordinates} ${xLastPosition} ${baseYCoordinate} L${xInitialPosition} ${baseYCoordinate} Z`;
-        }
-        return pathCoordinates;
-    }
-    yCoordinate(range, data, containerSize) {
-        const yRratio = this.mathsService.getSeriePercentage(range, data);
-        const yCoordinate = containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRratio + PoChartPlotAreaPaddingTop;
-        return Math.floor(yCoordinate);
-    }
-}
-PoChartLineBaseComponent.decorators = [
-    { type: Directive }
-];
-PoChartLineBaseComponent.ctorParameters = () => [
-    { type: PoChartMathsService },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-PoChartLineBaseComponent.propDecorators = {
-    alignByTheCorners: [{ type: Input, args: ['p-align-by-the-corners',] }],
-    categories: [{ type: Input, args: ['p-categories',] }],
-    categoriesCoordinates: [{ type: Input, args: ['p-categories-coordinates',] }],
-    svgSpace: [{ type: Input, args: ['p-svg-space',] }],
-    pointClick: [{ type: Output, args: ['p-point-click',] }],
-    pointHover: [{ type: Output, args: ['p-point-hover',] }],
-    chartLine: [{ type: ViewChild, args: ['chartLine',] }],
-    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-line-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-line/po-chart-line-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild } from '@angular/core';\r\n\r\nimport { PoChartType } from '../../enums/po-chart-type.enum';\r\nimport { PoChartPlotAreaPaddingTop } from '../../helpers/po-chart-default-values.constant';\r\n\r\nimport { PoChartContainerSize } from '../../interfaces/po-chart-container-size.interface';\r\nimport { PoChartMathsService } from '../../services/po-chart-maths.service';\r\nimport { PoChartMinMaxValues } from '../../interfaces/po-chart-min-max-values.interface';\r\nimport { PoChartPathCoordinates } from '../../interfaces/po-chart-path-coordinates.interface';\r\nimport { PoChartPointsCoordinates } from '../../interfaces/po-chart-points-coordinates.interface';\r\nimport { PoChartSerie } from '../../interfaces/po-chart-serie.interface';\r\n\r\n@Directive()\r\nexport abstract class PoChartLineBaseComponent {\r\n  @Input('p-align-by-the-corners') alignByTheCorners: boolean = false;\r\n\r\n  @Input('p-categories') categories: Array<string>;\r\n\r\n  @Input('p-categories-coordinates') categoriesCoordinates: Array<number>;\r\n\r\n  @Input('p-svg-space') svgSpace;\r\n\r\n  @Output('p-point-click') pointClick = new EventEmitter<any>();\r\n\r\n  @Output('p-point-hover') pointHover = new EventEmitter<any>();\r\n\r\n  @ViewChild('chartLine') chartLine: ElementRef;\r\n\r\n  activeTooltip: boolean;\r\n  animate: boolean = true;\r\n  chartType: PoChartType;\r\n  seriesPathsCoordinates: Array<PoChartPathCoordinates>;\r\n  seriesPointsCoordinates: Array<Array<PoChartPointsCoordinates>> = [];\r\n\r\n  protected firstValidItemFromSerieArray: boolean;\r\n  protected seriesLength: number;\r\n\r\n  private _containerSize: PoChartContainerSize = {};\r\n  private _range: PoChartMinMaxValues = {};\r\n  private _series: Array<PoChartSerie> = [];\r\n\r\n  @Input('p-range') set range(value: PoChartMinMaxValues) {\r\n    if (value instanceof Object && !(value instanceof Array)) {\r\n      this._range = value;\r\n\r\n      this.seriePathPointsDefinition(this.containerSize, this._series, this._range);\r\n    }\r\n  }\r\n\r\n  get range() {\r\n    return this._range;\r\n  }\r\n\r\n  @Input('p-container-size') set containerSize(value: PoChartContainerSize) {\r\n    this._containerSize = value;\r\n\r\n    this.seriePathPointsDefinition(this._containerSize, this.series, this.range);\r\n  }\r\n\r\n  get containerSize() {\r\n    return this._containerSize;\r\n  }\r\n\r\n  @Input('p-series') set series(seriesList: Array<PoChartSerie>) {\r\n    const seriesDataArrayFilter = seriesList.filter(serie => Array.isArray(serie.data));\r\n\r\n    if (seriesDataArrayFilter.length) {\r\n      this._series = seriesDataArrayFilter;\r\n      this.animate = true;\r\n      this.seriesLength = this.mathsService.seriesGreaterLength(this.series);\r\n      this.chartType = this._series[0].type;\r\n      this.seriePathPointsDefinition(this.containerSize, seriesDataArrayFilter, this.range);\r\n    } else {\r\n      this._series = [];\r\n    }\r\n  }\r\n\r\n  get series() {\r\n    return this._series;\r\n  }\r\n\r\n  constructor(\r\n    protected mathsService: PoChartMathsService,\r\n    protected renderer: Renderer2,\r\n    protected elementRef: ElementRef\r\n  ) {}\r\n\r\n  onSeriePointClick(selectedItem: any) {\r\n    this.pointClick.emit(selectedItem);\r\n  }\r\n\r\n  trackBy(index) {\r\n    return index;\r\n  }\r\n\r\n  private getTooltipLabel(data: number, label: string, tooltipLabel: string) {\r\n    const dataLabel = label ? `${label}: ` : '';\r\n    const dataValue = data.toString();\r\n\r\n    return tooltipLabel || `${dataLabel}${dataValue}`;\r\n  }\r\n\r\n  private svgPathCommand() {\r\n    const command = this.firstValidItemFromSerieArray ? 'M' : 'L';\r\n    // firstValidItemFromSerieArray: tratamento para permitir ao usuário definir o primeiro valor como null para que seja ignorado;\r\n    this.firstValidItemFromSerieArray = false;\r\n\r\n    return command;\r\n  }\r\n\r\n  private xCoordinate(index: number, containerSize: PoChartContainerSize) {\r\n    const halfCategoryWidth = !this.alignByTheCorners\r\n      ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / this.seriesLength / 2\r\n      : 0;\r\n\r\n    const divideIndexBySeriesLength = index / (this.alignByTheCorners ? this.seriesLength - 1 : this.seriesLength);\r\n    const xRatio = isNaN(divideIndexBySeriesLength) ? 0 : divideIndexBySeriesLength;\r\n\r\n    return Math.floor(\r\n      containerSize.axisXLabelWidth +\r\n        halfCategoryWidth +\r\n        (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio\r\n    );\r\n  }\r\n\r\n  private serieCategory(index: number, categories: Array<string> = []) {\r\n    return categories[index] ?? undefined;\r\n  }\r\n\r\n  private seriePathPointsDefinition(\r\n    containerSize: PoChartContainerSize,\r\n    series: Array<PoChartSerie>,\r\n    range: PoChartMinMaxValues\r\n  ) {\r\n    this.seriesPointsCoordinates = [];\r\n\r\n    this.seriesPathsCoordinates = series.map((serie: PoChartSerie) => {\r\n      if (Array.isArray(serie.data)) {\r\n        let pathCoordinates: string = '';\r\n        let pointCoordinates: Array<PoChartPointsCoordinates> = [];\r\n        const color = serie.color;\r\n        this.firstValidItemFromSerieArray = true;\r\n\r\n        serie.data.forEach((data, index) => {\r\n          if (this.mathsService.verifyIfFloatOrInteger(data)) {\r\n            const svgPathCommand = this.svgPathCommand();\r\n            const xCoordinate = this.xCoordinate(index, containerSize);\r\n            const yCoordinate = this.yCoordinate(range, data, containerSize);\r\n            const category = this.serieCategory(index, this.categories);\r\n            const label = serie.label;\r\n            const tooltip = serie.tooltip;\r\n            const tooltipLabel = this.getTooltipLabel(data, label, tooltip);\r\n            const isActive = this.chartType === PoChartType.Line;\r\n            pointCoordinates = [\r\n              ...pointCoordinates,\r\n              { category, label, tooltipLabel, data: data, xCoordinate, yCoordinate, color, isActive }\r\n            ];\r\n            pathCoordinates += ` ${svgPathCommand}${xCoordinate} ${yCoordinate}`;\r\n          }\r\n        });\r\n\r\n        pathCoordinates = this.verifyIfClosePath(pathCoordinates, serie.data.length - 1, range, 0, containerSize);\r\n\r\n        this.seriesPointsCoordinates = [...this.seriesPointsCoordinates, pointCoordinates];\r\n\r\n        return { coordinates: pathCoordinates, color, isActive: true };\r\n      }\r\n    });\r\n  }\r\n\r\n  private verifyIfClosePath(pathCoordinates, lastIndex, range, data, containerSize) {\r\n    const { axisXLabelWidth, svgWidth } = containerSize;\r\n\r\n    if (this.chartType === PoChartType.Area) {\r\n      const xLastPosition = this.xCoordinate(lastIndex, containerSize);\r\n      const baseYCoordinate = this.yCoordinate(range, data, containerSize);\r\n      const xInitialPosition = Math.floor(\r\n        this.alignByTheCorners\r\n          ? axisXLabelWidth\r\n          : axisXLabelWidth + (svgWidth - axisXLabelWidth) / this.seriesLength / 2\r\n      );\r\n\r\n      return `${pathCoordinates} ${xLastPosition} ${baseYCoordinate} L${xInitialPosition} ${baseYCoordinate} Z`;\r\n    }\r\n\r\n    return pathCoordinates;\r\n  }\r\n\r\n  private yCoordinate(range: PoChartMinMaxValues, data: number, containerSize: PoChartContainerSize) {\r\n    const yRratio = this.mathsService.getSeriePercentage(range, data);\r\n    const yCoordinate =\r\n      containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRratio + PoChartPlotAreaPaddingTop;\r\n\r\n    return Math.floor(yCoordinate);\r\n  }\r\n}\r\n"]}
+import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild } from '@angular/core';
+import { PoChartType } from '../../enums/po-chart-type.enum';
+import { PoChartPlotAreaPaddingTop } from '../../helpers/po-chart-default-values.constant';
+import { PoChartMathsService } from '../../services/po-chart-maths.service';
+export class PoChartLineBaseComponent {
+    constructor(mathsService, renderer, elementRef) {
+        this.mathsService = mathsService;
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.alignByTheCorners = false;
+        this.pointClick = new EventEmitter();
+        this.pointHover = new EventEmitter();
+        this.animate = true;
+        this.seriesPointsCoordinates = [];
+        this._containerSize = {};
+        this._range = {};
+        this._series = [];
+    }
+    set range(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._range = value;
+            this.seriePathPointsDefinition(this.containerSize, this._series, this._range);
+        }
+    }
+    get range() {
+        return this._range;
+    }
+    set containerSize(value) {
+        this._containerSize = value;
+        this.seriePathPointsDefinition(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.animate = true;
+            this.seriesLength = this.mathsService.seriesGreaterLength(this.series);
+            this.chartType = this._series[0].type;
+            this.seriePathPointsDefinition(this.containerSize, seriesDataArrayFilter, this.range);
+        }
+        else {
+            this._series = [];
+        }
+    }
+    get series() {
+        return this._series;
+    }
+    onSeriePointClick(selectedItem) {
+        this.pointClick.emit(selectedItem);
+    }
+    trackBy(index) {
+        return index;
+    }
+    getTooltipLabel(data, label, tooltipLabel) {
+        const dataLabel = label ? `${label}: ` : '';
+        const dataValue = data.toString();
+        return tooltipLabel || `${dataLabel}${dataValue}`;
+    }
+    svgPathCommand() {
+        const command = this.firstValidItemFromSerieArray ? 'M' : 'L';
+        // firstValidItemFromSerieArray: tratamento para permitir ao usuário definir o primeiro valor como null para que seja ignorado;
+        this.firstValidItemFromSerieArray = false;
+        return command;
+    }
+    xCoordinate(index, containerSize) {
+        const halfCategoryWidth = !this.alignByTheCorners
+            ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / this.seriesLength / 2
+            : 0;
+        const divideIndexBySeriesLength = index / (this.alignByTheCorners ? this.seriesLength - 1 : this.seriesLength);
+        const xRatio = isNaN(divideIndexBySeriesLength) ? 0 : divideIndexBySeriesLength;
+        return Math.floor(containerSize.axisXLabelWidth +
+            halfCategoryWidth +
+            (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio);
+    }
+    serieCategory(index, categories = []) {
+        var _a;
+        return (_a = categories[index]) !== null && _a !== void 0 ? _a : undefined;
+    }
+    seriePathPointsDefinition(containerSize, series, range) {
+        this.seriesPointsCoordinates = [];
+        this.seriesPathsCoordinates = series.map((serie) => {
+            if (Array.isArray(serie.data)) {
+                let pathCoordinates = '';
+                let pointCoordinates = [];
+                const color = serie.color;
+                this.firstValidItemFromSerieArray = true;
+                serie.data.forEach((data, index) => {
+                    if (this.mathsService.verifyIfFloatOrInteger(data)) {
+                        const svgPathCommand = this.svgPathCommand();
+                        const xCoordinate = this.xCoordinate(index, containerSize);
+                        const yCoordinate = this.yCoordinate(range, data, containerSize);
+                        const category = this.serieCategory(index, this.categories);
+                        const label = serie.label;
+                        const tooltip = serie.tooltip;
+                        const tooltipLabel = this.getTooltipLabel(data, label, tooltip);
+                        const isActive = this.chartType === PoChartType.Line;
+                        pointCoordinates = [
+                            ...pointCoordinates,
+                            { category, label, tooltipLabel, data: data, xCoordinate, yCoordinate, color, isActive }
+                        ];
+                        pathCoordinates += ` ${svgPathCommand}${xCoordinate} ${yCoordinate}`;
+                    }
+                });
+                pathCoordinates = this.verifyIfClosePath(pathCoordinates, serie.data.length - 1, range, 0, containerSize);
+                this.seriesPointsCoordinates = [...this.seriesPointsCoordinates, pointCoordinates];
+                return { coordinates: pathCoordinates, color, isActive: true };
+            }
+        });
+    }
+    verifyIfClosePath(pathCoordinates, lastIndex, range, data, containerSize) {
+        const { axisXLabelWidth, svgWidth } = containerSize;
+        if (this.chartType === PoChartType.Area) {
+            const xLastPosition = this.xCoordinate(lastIndex, containerSize);
+            const baseYCoordinate = this.yCoordinate(range, data, containerSize);
+            const xInitialPosition = Math.floor(this.alignByTheCorners
+                ? axisXLabelWidth
+                : axisXLabelWidth + (svgWidth - axisXLabelWidth) / this.seriesLength / 2);
+            return `${pathCoordinates} ${xLastPosition} ${baseYCoordinate} L${xInitialPosition} ${baseYCoordinate} Z`;
+        }
+        return pathCoordinates;
+    }
+    yCoordinate(range, data, containerSize) {
+        const yRratio = this.mathsService.getSeriePercentage(range, data);
+        const yCoordinate = containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRratio + PoChartPlotAreaPaddingTop;
+        return Math.floor(yCoordinate);
+    }
+}
+PoChartLineBaseComponent.decorators = [
+    { type: Directive }
+];
+PoChartLineBaseComponent.ctorParameters = () => [
+    { type: PoChartMathsService },
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+PoChartLineBaseComponent.propDecorators = {
+    alignByTheCorners: [{ type: Input, args: ['p-align-by-the-corners',] }],
+    categories: [{ type: Input, args: ['p-categories',] }],
+    categoriesCoordinates: [{ type: Input, args: ['p-categories-coordinates',] }],
+    svgSpace: [{ type: Input, args: ['p-svg-space',] }],
+    pointClick: [{ type: Output, args: ['p-point-click',] }],
+    pointHover: [{ type: Output, args: ['p-point-hover',] }],
+    chartLine: [{ type: ViewChild, args: ['chartLine',] }],
+    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-line-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-chart/po-chart-container/po-chart-line/po-chart-line-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild } from '@angular/core';\n\nimport { PoChartType } from '../../enums/po-chart-type.enum';\nimport { PoChartPlotAreaPaddingTop } from '../../helpers/po-chart-default-values.constant';\n\nimport { PoChartContainerSize } from '../../interfaces/po-chart-container-size.interface';\nimport { PoChartMathsService } from '../../services/po-chart-maths.service';\nimport { PoChartMinMaxValues } from '../../interfaces/po-chart-min-max-values.interface';\nimport { PoChartPathCoordinates } from '../../interfaces/po-chart-path-coordinates.interface';\nimport { PoChartPointsCoordinates } from '../../interfaces/po-chart-points-coordinates.interface';\nimport { PoChartSerie } from '../../interfaces/po-chart-serie.interface';\n\n@Directive()\nexport abstract class PoChartLineBaseComponent {\n  @Input('p-align-by-the-corners') alignByTheCorners: boolean = false;\n\n  @Input('p-categories') categories: Array<string>;\n\n  @Input('p-categories-coordinates') categoriesCoordinates: Array<number>;\n\n  @Input('p-svg-space') svgSpace;\n\n  @Output('p-point-click') pointClick = new EventEmitter<any>();\n\n  @Output('p-point-hover') pointHover = new EventEmitter<any>();\n\n  @ViewChild('chartLine') chartLine: ElementRef;\n\n  activeTooltip: boolean;\n  animate: boolean = true;\n  chartType: PoChartType;\n  seriesPathsCoordinates: Array<PoChartPathCoordinates>;\n  seriesPointsCoordinates: Array<Array<PoChartPointsCoordinates>> = [];\n\n  protected firstValidItemFromSerieArray: boolean;\n  protected seriesLength: 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.seriePathPointsDefinition(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.seriePathPointsDefinition(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.animate = true;\n      this.seriesLength = this.mathsService.seriesGreaterLength(this.series);\n      this.chartType = this._series[0].type;\n      this.seriePathPointsDefinition(this.containerSize, seriesDataArrayFilter, this.range);\n    } else {\n      this._series = [];\n    }\n  }\n\n  get series() {\n    return this._series;\n  }\n\n  constructor(\n    protected mathsService: PoChartMathsService,\n    protected renderer: Renderer2,\n    protected elementRef: ElementRef\n  ) {}\n\n  onSeriePointClick(selectedItem: any) {\n    this.pointClick.emit(selectedItem);\n  }\n\n  trackBy(index) {\n    return index;\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 svgPathCommand() {\n    const command = this.firstValidItemFromSerieArray ? 'M' : 'L';\n    // firstValidItemFromSerieArray: tratamento para permitir ao usuário definir o primeiro valor como null para que seja ignorado;\n    this.firstValidItemFromSerieArray = false;\n\n    return command;\n  }\n\n  private xCoordinate(index: number, containerSize: PoChartContainerSize) {\n    const halfCategoryWidth = !this.alignByTheCorners\n      ? (containerSize.svgWidth - containerSize.axisXLabelWidth) / this.seriesLength / 2\n      : 0;\n\n    const divideIndexBySeriesLength = index / (this.alignByTheCorners ? this.seriesLength - 1 : this.seriesLength);\n    const xRatio = isNaN(divideIndexBySeriesLength) ? 0 : divideIndexBySeriesLength;\n\n    return Math.floor(\n      containerSize.axisXLabelWidth +\n        halfCategoryWidth +\n        (containerSize.svgWidth - containerSize.axisXLabelWidth) * xRatio\n    );\n  }\n\n  private serieCategory(index: number, categories: Array<string> = []) {\n    return categories[index] ?? undefined;\n  }\n\n  private seriePathPointsDefinition(\n    containerSize: PoChartContainerSize,\n    series: Array<PoChartSerie>,\n    range: PoChartMinMaxValues\n  ) {\n    this.seriesPointsCoordinates = [];\n\n    this.seriesPathsCoordinates = series.map((serie: PoChartSerie) => {\n      if (Array.isArray(serie.data)) {\n        let pathCoordinates: string = '';\n        let pointCoordinates: Array<PoChartPointsCoordinates> = [];\n        const color = serie.color;\n        this.firstValidItemFromSerieArray = true;\n\n        serie.data.forEach((data, index) => {\n          if (this.mathsService.verifyIfFloatOrInteger(data)) {\n            const svgPathCommand = this.svgPathCommand();\n            const xCoordinate = this.xCoordinate(index, containerSize);\n            const yCoordinate = this.yCoordinate(range, data, containerSize);\n            const category = this.serieCategory(index, this.categories);\n            const label = serie.label;\n            const tooltip = serie.tooltip;\n            const tooltipLabel = this.getTooltipLabel(data, label, tooltip);\n            const isActive = this.chartType === PoChartType.Line;\n            pointCoordinates = [\n              ...pointCoordinates,\n              { category, label, tooltipLabel, data: data, xCoordinate, yCoordinate, color, isActive }\n            ];\n            pathCoordinates += ` ${svgPathCommand}${xCoordinate} ${yCoordinate}`;\n          }\n        });\n\n        pathCoordinates = this.verifyIfClosePath(pathCoordinates, serie.data.length - 1, range, 0, containerSize);\n\n        this.seriesPointsCoordinates = [...this.seriesPointsCoordinates, pointCoordinates];\n\n        return { coordinates: pathCoordinates, color, isActive: true };\n      }\n    });\n  }\n\n  private verifyIfClosePath(pathCoordinates, lastIndex, range, data, containerSize) {\n    const { axisXLabelWidth, svgWidth } = containerSize;\n\n    if (this.chartType === PoChartType.Area) {\n      const xLastPosition = this.xCoordinate(lastIndex, containerSize);\n      const baseYCoordinate = this.yCoordinate(range, data, containerSize);\n      const xInitialPosition = Math.floor(\n        this.alignByTheCorners\n          ? axisXLabelWidth\n          : axisXLabelWidth + (svgWidth - axisXLabelWidth) / this.seriesLength / 2\n      );\n\n      return `${pathCoordinates} ${xLastPosition} ${baseYCoordinate} L${xInitialPosition} ${baseYCoordinate} Z`;\n    }\n\n    return pathCoordinates;\n  }\n\n  private yCoordinate(range: PoChartMinMaxValues, data: number, containerSize: PoChartContainerSize) {\n    const yRratio = this.mathsService.getSeriePercentage(range, data);\n    const yCoordinate =\n      containerSize.svgPlottingAreaHeight - containerSize.svgPlottingAreaHeight * yRratio + PoChartPlotAreaPaddingTop;\n\n    return Math.floor(yCoordinate);\n  }\n}\n"]}

package/esm2015/lib/components/po-chart/po-chart-container/po-chart-line/po-chart-line.component.js

@@ -1,41 +1,41 @@
-import { __rest } from "tslib";
-import { Component, ElementRef, Renderer2 } from '@angular/core';
-import { PoChartLineBaseComponent } from './po-chart-line-base.component';
-import { PoChartMathsService } from '../../services/po-chart-maths.service';
-export class PoChartLineComponent extends PoChartLineBaseComponent {
-    constructor(mathsService, renderer, elementRef) {
-        super(mathsService, renderer, elementRef);
-        this.mathsService = mathsService;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-    }
-    onEnter(serieIndex) {
-        return null;
-    }
-    onLeave(serieIndex) {
-        return null;
-    }
-    onSeriePointHover(selectedItem) {
-        const { relativeTo } = selectedItem, item = __rest(selectedItem, ["relativeTo"]);
-        this.reorderSVGGroup(relativeTo);
-        this.pointHover.emit(item);
-    }
-    // É necessário reordenar os svgs on hover pois eventualmente os elemntos svg ficam por trás de outros. Não há z-index para svgElement.
-    reorderSVGGroup(pathGroup) {
-        const pathGroupElement = this.elementRef.nativeElement.querySelectorAll(`.${pathGroup}`);
-        this.animate = false;
-        this.renderer.appendChild(this.chartLine.nativeElement, pathGroupElement[0]);
-    }
-}
-PoChartLineComponent.decorators = [
-    { type: Component, args: [{
-                selector: '[po-chart-line]',
-                template: "<svg:g #chartLine>\r\n\r\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\r\n    [class]=\"'po-chart-line-path-group-' + i\"\r\n    (mouseenter)=\"onEnter(i)\"\r\n    (mouseleave)=\"onLeave(i)\"\r\n  >\r\n    <!-- SERIES PATHS -->\r\n    <svg:g po-chart-path\r\n      [p-chart-line]=\"chartType === 'line'\"\r\n      [attr.key]=\"'po-chart-line-path-' + i\"\r\n      [p-animate]=\"animate\"\r\n      [p-color]=\"item.color\" \r\n      [p-coordinates]=\"item?.coordinates\"\r\n      [p-is-active]=\"item.isActive\"\r\n      >\r\n      </svg:g>\r\n\r\n    <!-- SERIES POINTS -->\r\n    <svg:g po-chart-series-point\r\n      [p-animate]=\"animate\"\r\n      [p-chart-line]=\"chartType === 'line'\"\r\n      [p-color]=\"item.color\"\r\n      [p-coordinates]=\"seriesPointsCoordinates[i]\"\r\n      [p-is-active]=\"activeTooltip\"\r\n      [p-relative-to]=\"'po-chart-line-path-group-' + i\" \r\n      [attr.key]=\"'po-chart-line-path-points-group-' + i\"\r\n      (p-point-click)=\"onSeriePointClick($event)\"\r\n      (p-point-hover)=\"onSeriePointHover($event)\"\r\n      ></svg:g>\r\n  </svg:g>\r\n\r\n</svg:g>"
-            },] }
-];
-PoChartLineComponent.ctorParameters = () => [
-    { type: PoChartMathsService },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-//# sourceMappingURL=data:application/json;base64,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
+import { __rest } from "tslib";
+import { Component, ElementRef, Renderer2 } from '@angular/core';
+import { PoChartLineBaseComponent } from './po-chart-line-base.component';
+import { PoChartMathsService } from '../../services/po-chart-maths.service';
+export class PoChartLineComponent extends PoChartLineBaseComponent {
+    constructor(mathsService, renderer, elementRef) {
+        super(mathsService, renderer, elementRef);
+        this.mathsService = mathsService;
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    onEnter(serieIndex) {
+        return null;
+    }
+    onLeave(serieIndex) {
+        return null;
+    }
+    onSeriePointHover(selectedItem) {
+        const { relativeTo } = selectedItem, item = __rest(selectedItem, ["relativeTo"]);
+        this.reorderSVGGroup(relativeTo);
+        this.pointHover.emit(item);
+    }
+    // É necessário reordenar os svgs on hover pois eventualmente os elemntos svg ficam por trás de outros. Não há z-index para svgElement.
+    reorderSVGGroup(pathGroup) {
+        const pathGroupElement = this.elementRef.nativeElement.querySelectorAll(`.${pathGroup}`);
+        this.animate = false;
+        this.renderer.appendChild(this.chartLine.nativeElement, pathGroupElement[0]);
+    }
+}
+PoChartLineComponent.decorators = [
+    { type: Component, args: [{
+                selector: '[po-chart-line]',
+                template: "<svg:g #chartLine>\n\n  <svg:g *ngFor=\"let item of seriesPathsCoordinates; let i = index; trackBy: trackBy\"\n    [class]=\"'po-chart-line-path-group-' + i\"\n    (mouseenter)=\"onEnter(i)\"\n    (mouseleave)=\"onLeave(i)\"\n  >\n    <!-- SERIES PATHS -->\n    <svg:g po-chart-path\n      [p-chart-line]=\"chartType === 'line'\"\n      [attr.key]=\"'po-chart-line-path-' + i\"\n      [p-animate]=\"animate\"\n      [p-color]=\"item.color\" \n      [p-coordinates]=\"item?.coordinates\"\n      [p-is-active]=\"item.isActive\"\n      >\n      </svg:g>\n\n    <!-- SERIES POINTS -->\n    <svg:g po-chart-series-point\n      [p-animate]=\"animate\"\n      [p-chart-line]=\"chartType === 'line'\"\n      [p-color]=\"item.color\"\n      [p-coordinates]=\"seriesPointsCoordinates[i]\"\n      [p-is-active]=\"activeTooltip\"\n      [p-relative-to]=\"'po-chart-line-path-group-' + i\" \n      [attr.key]=\"'po-chart-line-path-points-group-' + i\"\n      (p-point-click)=\"onSeriePointClick($event)\"\n      (p-point-hover)=\"onSeriePointHover($event)\"\n      ></svg:g>\n  </svg:g>\n\n</svg:g>"
+            },] }
+];
+PoChartLineComponent.ctorParameters = () => [
+    { type: PoChartMathsService },
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtbGluZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvcG8tY2hhcnQtY29udGFpbmVyL3BvLWNoYXJ0LWxpbmUvcG8tY2hhcnQtbGluZS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVqRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMxRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQU01RSxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsd0JBQXdCO0lBQ2hFLFlBQ1ksWUFBaUMsRUFDakMsUUFBbUIsRUFDbkIsVUFBc0I7UUFFaEMsS0FBSyxDQUFDLFlBQVksRUFBRSxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFKaEMsaUJBQVksR0FBWixZQUFZLENBQXFCO1FBQ2pDLGFBQVEsR0FBUixRQUFRLENBQVc7UUFDbkIsZUFBVSxHQUFWLFVBQVUsQ0FBWTtJQUdsQyxDQUFDO0lBRUQsT0FBTyxDQUFDLFVBQWtCO1FBQ3hCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNELE9BQU8sQ0FBQyxVQUFrQjtRQUN4QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxpQkFBaUIsQ0FBQyxZQUFpQjtRQUNqQyxNQUFNLEVBQUUsVUFBVSxLQUFjLFlBQVksRUFBckIsSUFBSSxVQUFLLFlBQVksRUFBdEMsY0FBdUIsQ0FBZSxDQUFDO1FBRTdDLElBQUksQ0FBQyxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDakMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUVELHVJQUF1STtJQUMvSCxlQUFlLENBQUMsU0FBaUI7UUFDdkMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFFekYsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDckIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMvRSxDQUFDOzs7WUFqQ0YsU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSxpQkFBaUI7Z0JBQzNCLHlrQ0FBNEM7YUFDN0M7OztZQUxRLG1CQUFtQjtZQUhJLFNBQVM7WUFBckIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgRWxlbWVudFJlZiwgUmVuZGVyZXIyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBvQ2hhcnRMaW5lQmFzZUNvbXBvbmVudCB9IGZyb20gJy4vcG8tY2hhcnQtbGluZS1iYXNlLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQb0NoYXJ0TWF0aHNTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvcG8tY2hhcnQtbWF0aHMuc2VydmljZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ1twby1jaGFydC1saW5lXScsXG4gIHRlbXBsYXRlVXJsOiAnLi9wby1jaGFydC1saW5lLmNvbXBvbmVudC5zdmcnXG59KVxuZXhwb3J0IGNsYXNzIFBvQ2hhcnRMaW5lQ29tcG9uZW50IGV4dGVuZHMgUG9DaGFydExpbmVCYXNlQ29tcG9uZW50IHtcbiAgY29uc3RydWN0b3IoXG4gICAgcHJvdGVjdGVkIG1hdGhzU2VydmljZTogUG9DaGFydE1hdGhzU2VydmljZSxcbiAgICBwcm90ZWN0ZWQgcmVuZGVyZXI6IFJlbmRlcmVyMixcbiAgICBwcm90ZWN0ZWQgZWxlbWVudFJlZjogRWxlbWVudFJlZlxuICApIHtcbiAgICBzdXBlcihtYXRoc1NlcnZpY2UsIHJlbmRlcmVyLCBlbGVtZW50UmVmKTtcbiAgfVxuXG4gIG9uRW50ZXIoc2VyaWVJbmRleDogbnVtYmVyKSB7XG4gICAgcmV0dXJuIG51bGw7XG4gIH1cbiAgb25MZWF2ZShzZXJpZUluZGV4OiBudW1iZXIpIHtcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxuXG4gIG9uU2VyaWVQb2ludEhvdmVyKHNlbGVjdGVkSXRlbTogYW55KSB7XG4gICAgY29uc3QgeyByZWxhdGl2ZVRvLCAuLi5pdGVtIH0gPSBzZWxlY3RlZEl0ZW07XG5cbiAgICB0aGlzLnJlb3JkZXJTVkdHcm91cChyZWxhdGl2ZVRvKTtcbiAgICB0aGlzLnBvaW50SG92ZXIuZW1pdChpdGVtKTtcbiAgfVxuXG4gIC8vIMOJIG5lY2Vzc8OhcmlvIHJlb3JkZW5hciBvcyBzdmdzIG9uIGhvdmVyIHBvaXMgZXZlbnR1YWxtZW50ZSBvcyBlbGVtbnRvcyBzdmcgZmljYW0gcG9yIHRyw6FzIGRlIG91dHJvcy4gTsOjbyBow6Egei1pbmRleCBwYXJhIHN2Z0VsZW1lbnQuXG4gIHByaXZhdGUgcmVvcmRlclNWR0dyb3VwKHBhdGhHcm91cDogc3RyaW5nKSB7XG4gICAgY29uc3QgcGF0aEdyb3VwRWxlbWVudCA9IHRoaXMuZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LnF1ZXJ5U2VsZWN0b3JBbGwoYC4ke3BhdGhHcm91cH1gKTtcblxuICAgIHRoaXMuYW5pbWF0ZSA9IGZhbHNlO1xuICAgIHRoaXMucmVuZGVyZXIuYXBwZW5kQ2hpbGQodGhpcy5jaGFydExpbmUubmF0aXZlRWxlbWVudCwgcGF0aEdyb3VwRWxlbWVudFswXSk7XG4gIH1cbn1cbiJdfQ==