@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-gauge/po-gauge-svg/po-gauge-path/po-gauge-path.component.mjs

@@ -0,0 +1,43 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const _c0 = ["po-gauge-path", ""];
+function PoGaugePathComponent__svg_path_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "path");
+} if (rf & 2) {
+    const range_r1 = ctx.$implicit;
+    i0.ɵɵclassMap((range_r1 == null ? null : range_r1.color == null ? null : range_r1.color.includes("po-color")) ? range_r1.color : "");
+    i0.ɵɵattribute("d", range_r1 == null ? null : range_r1.coordinates)("fill", range_r1 == null ? null : range_r1.color);
+} }
+export class PoGaugePathComponent {
+    constructor() { }
+    ngOnInit() { }
+    trackBy(index) {
+        return index;
+    }
+}
+PoGaugePathComponent.ɵfac = function PoGaugePathComponent_Factory(t) { return new (t || PoGaugePathComponent)(); };
+PoGaugePathComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoGaugePathComponent, selectors: [["", "po-gauge-path", ""]], inputs: { baseCoordinates: ["p-base-coordinates", "baseCoordinates"], rangesCoordinates: ["p-ranges-coordinates", "rangesCoordinates"] }, attrs: _c0, decls: 3, vars: 3, consts: [[1, "po-gauge-base"], [3, "class", 4, "ngFor", "ngForOf", "ngForTrackBy"]], template: function PoGaugePathComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵelement(1, "path", 0);
+        i0.ɵɵtemplate(2, PoGaugePathComponent__svg_path_2_Template, 1, 4, "path", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵattribute("d", ctx.baseCoordinates == null ? null : ctx.baseCoordinates.coordinates);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.rangesCoordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i1.NgForOf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugePathComponent, [{
+        type: Component,
+        args: [{ selector: '[po-gauge-path]', template: "<svg:g>\n  <svg:path\n    class=\"po-gauge-base\"\n    [attr.d]=\"baseCoordinates?.coordinates\">\n  </svg:path> \n\n  <svg:path *ngFor=\"let range of rangesCoordinates; trackBy: trackBy\"\n    [class]=\"range?.color?.includes('po-color') ? range.color : ''\"\n    [attr.d]=\"range?.coordinates\"\n    [attr.fill]=\"range?.color\">\n  </svg:path> \n</svg:g>\n" }]
+    }], function () { return []; }, { baseCoordinates: [{
+            type: Input,
+            args: ['p-base-coordinates']
+        }], rangesCoordinates: [{
+            type: Input,
+            args: ['p-ranges-coordinates']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-gauge/po-gauge-svg/po-gauge-pointer/po-gauge-pointer.component.mjs

@@ -0,0 +1,66 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+const _c0 = ["pointer"];
+const _c1 = ["po-gauge-pointer", ""];
+export class PoGaugePointerComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.afterViewInit = false;
+    }
+    set coordinates(value) {
+        this._coordinates = value;
+        if (this._coordinates?.radius) {
+            this.calculateRadiusScale(this.coordinates.radius);
+        }
+        if (this._coordinates?.hasOwnProperty('pointerDegrees') && this.afterViewInit) {
+            this.applyPointerRotation(this.coordinates.pointerDegrees);
+        }
+    }
+    get coordinates() {
+        return this._coordinates;
+    }
+    ngAfterViewInit() {
+        if (this._coordinates?.pointerDegrees) {
+            this.applyPointerRotation(this.coordinates.pointerDegrees);
+        }
+        this.afterViewInit = true;
+    }
+    calculateRadiusScale(radius) {
+        const scale = radius / 20;
+        const maxScaleValue = 24;
+        this.radiusScale = scale < maxScaleValue ? scale : maxScaleValue;
+    }
+    applyPointerRotation(degrees) {
+        this.renderer.setStyle(this.pointer.nativeElement, 'transformOrigin', `${this.coordinates.radius}px ${this.coordinates.radius}px`);
+        this.renderer.setStyle(this.pointer.nativeElement, 'transform', `rotate(${degrees}deg)`);
+    }
+}
+PoGaugePointerComponent.ɵfac = function PoGaugePointerComponent_Factory(t) { return new (t || PoGaugePointerComponent)(i0.ɵɵdirectiveInject(i0.Renderer2)); };
+PoGaugePointerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoGaugePointerComponent, selectors: [["", "po-gauge-pointer", ""]], viewQuery: function PoGaugePointerComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.pointer = _t.first);
+    } }, inputs: { coordinates: ["p-coordinates", "coordinates"] }, attrs: _c1, decls: 4, vars: 4, consts: [[1, "po-gauge-pointer"], ["pointer", ""], [1, "po-gauge-pointer-circle"]], template: function PoGaugePointerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵelement(1, "path", 0, 1);
+        i0.ɵɵelement(3, "circle", 2);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵattribute("d", ctx.coordinates == null ? null : ctx.coordinates.coordinates);
+        i0.ɵɵadvance(2);
+        i0.ɵɵattribute("cx", ctx.coordinates == null ? null : ctx.coordinates.radius)("cy", ctx.coordinates == null ? null : ctx.coordinates.radius)("r", ctx.radiusScale);
+    } }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugePointerComponent, [{
+        type: Component,
+        args: [{ selector: '[po-gauge-pointer]', template: "<svg:g>\n  <svg:path #pointer\n    class=\"po-gauge-pointer\"\n    [attr.d]=\"coordinates?.coordinates\"\n  >\n  </svg:path> \n\n  <svg:circle \n    class=\"po-gauge-pointer-circle\" \n    [attr.cx]=\"coordinates?.radius\" \n    [attr.cy]=\"coordinates?.radius\" \n    [attr.r]=\"radiusScale\"\n  >\n  </svg:circle>\n</svg:g>" }]
+    }], function () { return [{ type: i0.Renderer2 }]; }, { pointer: [{
+            type: ViewChild,
+            args: ['pointer']
+        }], coordinates: [{
+            type: Input,
+            args: ['p-coordinates']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-gauge/po-gauge-svg/po-gauge-svg.component.mjs

@@ -0,0 +1,236 @@
+import { Component, Input } from '@angular/core';
+import { PoGaugePointerEnd, PoGaugeThickness, poGaugeTotalValueDefault } from '../po-gauge-default-values.constant';
+import { PoDefaultColors } from '../../../services/po-color/po-colors.constant';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./po-gauge-path/po-gauge-path.component";
+import * as i3 from "./po-gauge-pointer/po-gauge-pointer.component";
+function PoGaugeSvgComponent__svg_svg_0__svg_g_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "g", 4);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("p-coordinates", ctx_r1.pointerCoordinates);
+} }
+function PoGaugeSvgComponent__svg_svg_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "svg", 1);
+    i0.ɵɵelement(1, "g", 2);
+    i0.ɵɵtemplate(2, PoGaugeSvgComponent__svg_svg_0__svg_g_2_Template, 1, 1, "g", 3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵattribute("viewBox", ctx_r0.viewBox)("height", ctx_r0.container == null ? null : ctx_r0.container.height);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("p-base-coordinates", ctx_r0.baseCoordinates)("p-ranges-coordinates", ctx_r0.coordinates);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.hasRanges);
+} }
+export const poGaugeStartAngle = -Math.PI;
+export class PoGaugeSvgComponent {
+    constructor() {
+        this.addSvgElement = false;
+    }
+    get hasRanges() {
+        return this.ranges.length > 0;
+    }
+    ngOnChanges(changes) {
+        if ((this.container && changes.value) || (this.container && changes.ranges) || this.container) {
+            this.setCoordinates(this.value, this.ranges, this.container);
+        }
+    }
+    setCoordinates(value, ranges, container) {
+        const { height } = container;
+        // Adiciona elemento svg somente após calcular a altura do container pois o svg tem altura default de 150px.
+        this.addSvgElement = true;
+        this.setViewBox(height);
+        this.setBaseCoordinates(height);
+        if (!ranges.length) {
+            this.setSingleRangeCoordinates(height, value);
+            return;
+        }
+        this.setRangesCoordinates(height, value, ranges);
+    }
+    setBaseCoordinates(height) {
+        const endAngleRadian = 0;
+        const coordinates = this.calculateCoordinates(height, poGaugeStartAngle, endAngleRadian);
+        this.baseCoordinates = { coordinates };
+    }
+    setRangesCoordinates(height, value = 0, ranges) {
+        const { minRange, maxRange } = this.calculateMinAndMaxValues(ranges);
+        const minValue = value < minRange ? value : minRange;
+        const maxValue = value > maxRange ? value : maxRange;
+        this.setPointerCoordinates(height, value, maxValue, minValue);
+        // `.reverse()` no término da iteração para tratar a sobreposicão correta das bordas arredondadas dos ranges.
+        const rangesCoordinates = ranges
+            .map((range) => {
+            const from = range.from ?? 0;
+            const to = range.to ?? maxRange;
+            const startAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(from, maxValue, minValue);
+            const endAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(to, maxValue, minValue);
+            const coordinates = this.calculateCoordinates(height, startAngleRadian, endAngleRadian);
+            return { coordinates, color: range.color };
+        })
+            .reverse();
+        this.coordinates = rangesCoordinates;
+    }
+    setSingleRangeCoordinates(height, value) {
+        const verifiedValue = value > 100 ? 100 : value;
+        const endAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(verifiedValue, poGaugeTotalValueDefault);
+        const coordinates = value > 0 ? this.calculateCoordinates(height, poGaugeStartAngle, endAngleRadian) : undefined;
+        const color = PoDefaultColors[0][0];
+        this.coordinates = [{ coordinates, color }];
+    }
+    setPointerCoordinates(height, value, maxValue, minValue) {
+        const coordinates = this.calculatePointerInitialCoordinates(height, poGaugeStartAngle);
+        const pointerDegrees = this.pointerRotation(value, maxValue, minValue);
+        this.pointerCoordinates = { ...coordinates, pointerDegrees };
+    }
+    pointerRotation(value, maxValue, minValue) {
+        const percent = this.convertValueToPercentage(value, maxValue, minValue);
+        // valores referentes às angulações mínimas e máximas do ponteiro.
+        const minRotation = 0;
+        const maxRotation = 180;
+        return (percent * (maxRotation - minRotation)) / 100 + minRotation;
+    }
+    calculatePointerInitialCoordinates(height, startAngleRadian) {
+        const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;
+        // Valor que representa a escala do ponteiro para plotagem.
+        const scale = 40;
+        const pointerScaledWidth = radius / scale;
+        const pointerScaledBorderRadius = radius / (scale * 2);
+        const sinAlpha = Math.sin(startAngleRadian);
+        const cosAlpha = Math.cos(startAngleRadian);
+        const targetX = radius + cosAlpha * radius;
+        const targetY = radius + sinAlpha * radius;
+        const startX = radius;
+        const startY = radius + pointerScaledWidth;
+        const endX = radius;
+        const endY = radius - pointerScaledWidth;
+        const coordinates = [
+            'M',
+            startX,
+            startY,
+            'L',
+            targetX,
+            targetY + pointerScaledBorderRadius,
+            'A',
+            1,
+            1,
+            0,
+            '0,1',
+            targetX,
+            targetY - pointerScaledBorderRadius,
+            'L',
+            endX,
+            endY,
+            'Z'
+        ].join(' ');
+        return { coordinates, radius };
+    }
+    calculateCoordinates(height, startAngleRadian, endAngleRadian) {
+        // Subtrai altura pelo excedente ponteiro em relação ao gráfico, pela metade do valor da coroa circular.
+        const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;
+        const innerRadius = radius - PoGaugeThickness;
+        const sinAlpha = Math.sin(startAngleRadian);
+        const cosAlpha = Math.cos(startAngleRadian);
+        const sinBeta = Math.sin(endAngleRadian);
+        const cosBeta = Math.cos(endAngleRadian);
+        const startX = Math.round(radius + cosAlpha * radius);
+        const startY = Math.round(radius + sinAlpha * radius);
+        const endX = Math.round(radius + cosBeta * radius);
+        const endY = Math.round(radius + sinBeta * radius);
+        const startInnerX = Math.round(radius + cosAlpha * innerRadius);
+        const startInnerY = Math.round(radius + sinAlpha * innerRadius);
+        const endInnerX = Math.round(radius + cosBeta * innerRadius);
+        const endInnerY = Math.round(radius + sinBeta * innerRadius);
+        return [
+            'M',
+            startX,
+            startY,
+            'A',
+            radius,
+            radius,
+            0,
+            '0,1',
+            endX,
+            endY,
+            'A',
+            1,
+            1,
+            0,
+            '0,1',
+            endInnerX,
+            endInnerY,
+            'A',
+            innerRadius,
+            innerRadius,
+            0,
+            '0,0',
+            startInnerX,
+            startInnerY,
+            'A',
+            1,
+            1,
+            0,
+            '0,1',
+            startX,
+            startY,
+            'Z'
+        ].join(' ');
+    }
+    calculateAngleRadius(value, maxValue, minValue = 0) {
+        const angle = ((value - minValue) / (maxValue - minValue)) * (Math.PI * 2);
+        return angle / 2;
+    }
+    convertValueToPercentage(value, maxValue, minValue) {
+        return ((value - minValue) / (maxValue - minValue)) * 100;
+    }
+    setViewBox(height) {
+        const width = this.calculateDiameter(height);
+        this.viewBox = `0 ${-PoGaugePointerEnd} ${width} ${height}`;
+    }
+    calculateDiameter(height) {
+        const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;
+        return radius + Math.cos(0) * radius;
+    }
+    calculateMinAndMaxValues(ranges) {
+        const minRange = this.getDomain(ranges, 'min');
+        const maxRange = this.getDomain(ranges, 'max');
+        return {
+            minRange: this.verifyIfFloatOrInteger(minRange) ? minRange : 0,
+            maxRange: this.verifyIfFloatOrInteger(maxRange) ? maxRange : 100
+        };
+    }
+    verifyIfFloatOrInteger(number) {
+        const notABoolean = typeof number !== 'boolean';
+        const notInfinity = number !== Infinity;
+        const isInteger = Number(number) === number && number % 1 === 0 && notInfinity;
+        const isFloat = Number(number) === number && number % 1 !== 0 && notInfinity;
+        return (notABoolean && isInteger) || (notABoolean && isFloat);
+    }
+    getDomain(ranges, type) {
+        const rangeType = { min: 'from', max: 'to' };
+        return Math[type](...ranges.map(range => range[rangeType[type]]));
+    }
+}
+PoGaugeSvgComponent.ɵfac = function PoGaugeSvgComponent_Factory(t) { return new (t || PoGaugeSvgComponent)(); };
+PoGaugeSvgComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoGaugeSvgComponent, selectors: [["po-gauge-svg"]], inputs: { container: ["p-container", "container"], ranges: ["p-ranges", "ranges"], value: ["p-value", "value"] }, features: [i0.ɵɵNgOnChangesFeature], decls: 1, vars: 1, consts: [["class", "po-gauge-svg", "preserveAspectRatio", "xMidYMax meet", "width", "100%", 4, "ngIf"], ["preserveAspectRatio", "xMidYMax meet", "width", "100%", 1, "po-gauge-svg"], ["po-gauge-path", "", 3, "p-base-coordinates", "p-ranges-coordinates"], ["po-gauge-pointer", "", 3, "p-coordinates", 4, "ngIf"], ["po-gauge-pointer", "", 3, "p-coordinates"]], template: function PoGaugeSvgComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, PoGaugeSvgComponent__svg_svg_0_Template, 3, 5, "svg", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.addSvgElement);
+    } }, directives: [i1.NgIf, i2.PoGaugePathComponent, i3.PoGaugePointerComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugeSvgComponent, [{
+        type: Component,
+        args: [{ selector: 'po-gauge-svg', template: "<svg:svg\n  *ngIf=\"addSvgElement\"\n  class=\"po-gauge-svg\"\n  preserveAspectRatio=\"xMidYMax meet\"\n  width=\"100%\"\n  [attr.viewBox]=\"viewBox\"\n  [attr.height]=\"container?.height\"\n>\n  <!-- GAUGE PATHS -->\n  <svg:g po-gauge-path [p-base-coordinates]=\"baseCoordinates\" [p-ranges-coordinates]=\"coordinates\"></svg:g>\n\n  <!-- GAUGE POINTER -->\n  <svg:g *ngIf=\"hasRanges\" po-gauge-pointer [p-coordinates]=\"pointerCoordinates\"></svg:g>\n</svg:svg>\n" }]
+    }], null, { container: [{
+            type: Input,
+            args: ['p-container']
+        }], ranges: [{
+            type: Input,
+            args: ['p-ranges']
+        }], value: [{
+            type: Input,
+            args: ['p-value']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-gauge-svg.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-gauge/po-gauge-svg/po-gauge-svg.component.ts","../../../../../../../projects/ui/src/lib/components/po-gauge/po-gauge-svg/po-gauge-svg.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';\n\nimport { PoGaugePointerEnd, PoGaugeThickness, poGaugeTotalValueDefault } from '../po-gauge-default-values.constant';\n\nimport { PoDefaultColors } from '../../../services/po-color/po-colors.constant';\n\nimport { PoGaugeCoordinates } from '../interfaces/po-gauge-coordinates.interface';\nimport { PoGaugeRanges } from '../interfaces/po-gauge-ranges.interface';\nimport { PoGaugeSvgContainer } from '../interfaces/po-gauge-svg-container.interface';\n\nexport const poGaugeStartAngle = -Math.PI;\n\n@Component({\n  selector: 'po-gauge-svg',\n  templateUrl: './po-gauge-svg.component.html'\n})\nexport class PoGaugeSvgComponent implements OnChanges {\n  @Input('p-container') container: PoGaugeSvgContainer;\n\n  @Input('p-ranges') ranges: Array<PoGaugeRanges>;\n\n  @Input('p-value') value: number;\n\n  addSvgElement: boolean = false;\n  baseCoordinates: PoGaugeCoordinates;\n  coordinates: Array<PoGaugeCoordinates>;\n  pointerCoordinates: PoGaugeCoordinates;\n  viewBox: string;\n\n  get hasRanges(): boolean {\n    return this.ranges.length > 0;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if ((this.container && changes.value) || (this.container && changes.ranges) || this.container) {\n      this.setCoordinates(this.value, this.ranges, this.container);\n    }\n  }\n\n  private setCoordinates(value: number, ranges: Array<PoGaugeRanges>, container: PoGaugeSvgContainer): void {\n    const { height } = container;\n\n    // Adiciona elemento svg somente após calcular a altura do container pois o svg tem altura default de 150px.\n    this.addSvgElement = true;\n    this.setViewBox(height);\n    this.setBaseCoordinates(height);\n\n    if (!ranges.length) {\n      this.setSingleRangeCoordinates(height, value);\n      return;\n    }\n    this.setRangesCoordinates(height, value, ranges);\n  }\n\n  private setBaseCoordinates(height: PoGaugeSvgContainer['height']): void {\n    const endAngleRadian = 0;\n    const coordinates = this.calculateCoordinates(height, poGaugeStartAngle, endAngleRadian);\n\n    this.baseCoordinates = { coordinates };\n  }\n\n  private setRangesCoordinates(height: number, value: number = 0, ranges: Array<PoGaugeRanges>): void {\n    const { minRange, maxRange } = this.calculateMinAndMaxValues(ranges);\n\n    const minValue = value < minRange ? value : minRange;\n    const maxValue = value > maxRange ? value : maxRange;\n\n    this.setPointerCoordinates(height, value, maxValue, minValue);\n\n    // `.reverse()` no término da iteração para tratar a sobreposicão correta das bordas arredondadas dos ranges.\n    const rangesCoordinates = ranges\n      .map((range: PoGaugeRanges) => {\n        const from = range.from ?? 0;\n        const to = range.to ?? maxRange;\n        const startAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(from, maxValue, minValue);\n        const endAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(to, maxValue, minValue);\n\n        const coordinates = this.calculateCoordinates(height, startAngleRadian, endAngleRadian);\n\n        return { coordinates, color: range.color };\n      })\n      .reverse();\n\n    this.coordinates = rangesCoordinates;\n  }\n\n  private setSingleRangeCoordinates(height: PoGaugeSvgContainer['height'], value: number): void {\n    const verifiedValue = value > 100 ? 100 : value;\n\n    const endAngleRadian = poGaugeStartAngle + this.calculateAngleRadius(verifiedValue, poGaugeTotalValueDefault);\n\n    const coordinates = value > 0 ? this.calculateCoordinates(height, poGaugeStartAngle, endAngleRadian) : undefined;\n    const color = PoDefaultColors[0][0];\n    this.coordinates = [{ coordinates, color }];\n  }\n\n  private setPointerCoordinates(height: number, value: number, maxValue: number, minValue: number) {\n    const coordinates = this.calculatePointerInitialCoordinates(height, poGaugeStartAngle);\n    const pointerDegrees = this.pointerRotation(value, maxValue, minValue);\n\n    this.pointerCoordinates = { ...coordinates, pointerDegrees };\n  }\n\n  private pointerRotation(value: number, maxValue: number, minValue: number) {\n    const percent = this.convertValueToPercentage(value, maxValue, minValue);\n    // valores referentes às angulações mínimas e máximas do ponteiro.\n    const minRotation = 0;\n    const maxRotation = 180;\n\n    return (percent * (maxRotation - minRotation)) / 100 + minRotation;\n  }\n\n  private calculatePointerInitialCoordinates(height: number, startAngleRadian: number) {\n    const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;\n\n    // Valor que representa a escala do ponteiro para plotagem.\n    const scale = 40;\n    const pointerScaledWidth = radius / scale;\n    const pointerScaledBorderRadius = radius / (scale * 2);\n\n    const sinAlpha = Math.sin(startAngleRadian);\n    const cosAlpha = Math.cos(startAngleRadian);\n\n    const targetX = radius + cosAlpha * radius;\n    const targetY = radius + sinAlpha * radius;\n\n    const startX = radius;\n    const startY = radius + pointerScaledWidth;\n\n    const endX = radius;\n    const endY = radius - pointerScaledWidth;\n\n    const coordinates = [\n      'M',\n      startX,\n      startY,\n      'L',\n      targetX,\n      targetY + pointerScaledBorderRadius,\n      'A',\n      1,\n      1,\n      0,\n      '0,1',\n      targetX,\n      targetY - pointerScaledBorderRadius,\n      'L',\n      endX,\n      endY,\n      'Z'\n    ].join(' ');\n\n    return { coordinates, radius };\n  }\n\n  private calculateCoordinates(\n    height: PoGaugeSvgContainer['height'],\n    startAngleRadian: number,\n    endAngleRadian: number\n  ): PoGaugeCoordinates['coordinates'] {\n    // Subtrai altura pelo excedente ponteiro em relação ao gráfico, pela metade do valor da coroa circular.\n    const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;\n    const innerRadius = radius - PoGaugeThickness;\n\n    const sinAlpha = Math.sin(startAngleRadian);\n    const cosAlpha = Math.cos(startAngleRadian);\n\n    const sinBeta = Math.sin(endAngleRadian);\n    const cosBeta = Math.cos(endAngleRadian);\n\n    const startX = Math.round(radius + cosAlpha * radius);\n    const startY = Math.round(radius + sinAlpha * radius);\n\n    const endX = Math.round(radius + cosBeta * radius);\n    const endY = Math.round(radius + sinBeta * radius);\n\n    const startInnerX = Math.round(radius + cosAlpha * innerRadius);\n    const startInnerY = Math.round(radius + sinAlpha * innerRadius);\n\n    const endInnerX = Math.round(radius + cosBeta * innerRadius);\n    const endInnerY = Math.round(radius + sinBeta * innerRadius);\n\n    return [\n      'M',\n      startX,\n      startY,\n      'A',\n      radius,\n      radius,\n      0,\n      '0,1',\n      endX,\n      endY,\n      'A',\n      1,\n      1,\n      0,\n      '0,1',\n      endInnerX,\n      endInnerY,\n      'A',\n      innerRadius,\n      innerRadius,\n      0,\n      '0,0',\n      startInnerX,\n      startInnerY,\n      'A',\n      1,\n      1,\n      0,\n      '0,1',\n      startX,\n      startY,\n      'Z'\n    ].join(' ');\n  }\n\n  private calculateAngleRadius(value: number, maxValue: number, minValue: number = 0): number {\n    const angle = ((value - minValue) / (maxValue - minValue)) * (Math.PI * 2);\n\n    return angle / 2;\n  }\n\n  private convertValueToPercentage(value: number, maxValue: number, minValue): number {\n    return ((value - minValue) / (maxValue - minValue)) * 100;\n  }\n\n  private setViewBox(height: number): void {\n    const width = this.calculateDiameter(height);\n\n    this.viewBox = `0 ${-PoGaugePointerEnd} ${width} ${height}`;\n  }\n\n  private calculateDiameter(height: number): number {\n    const radius = height - PoGaugePointerEnd - PoGaugeThickness / 2;\n\n    return radius + Math.cos(0) * radius;\n  }\n\n  private calculateMinAndMaxValues(ranges: Array<PoGaugeRanges>) {\n    const minRange = this.getDomain(ranges, 'min');\n    const maxRange = this.getDomain(ranges, 'max');\n\n    return {\n      minRange: this.verifyIfFloatOrInteger(minRange) ? minRange : 0,\n      maxRange: this.verifyIfFloatOrInteger(maxRange) ? maxRange : 100\n    };\n  }\n\n  private verifyIfFloatOrInteger(number: number) {\n    const notABoolean = typeof number !== 'boolean';\n    const notInfinity = number !== Infinity;\n\n    const isInteger = Number(number) === number && number % 1 === 0 && notInfinity;\n    const isFloat = Number(number) === number && number % 1 !== 0 && notInfinity;\n\n    return (notABoolean && isInteger) || (notABoolean && isFloat);\n  }\n\n  private getDomain(ranges: Array<PoGaugeRanges>, type: string): number {\n    const rangeType = { min: 'from', max: 'to' };\n\n    return Math[type](...ranges.map(range => range[rangeType[type]]));\n  }\n}\n","<svg:svg\n  *ngIf=\"addSvgElement\"\n  class=\"po-gauge-svg\"\n  preserveAspectRatio=\"xMidYMax meet\"\n  width=\"100%\"\n  [attr.viewBox]=\"viewBox\"\n  [attr.height]=\"container?.height\"\n>\n  <!-- GAUGE PATHS -->\n  <svg:g po-gauge-path [p-base-coordinates]=\"baseCoordinates\" [p-ranges-coordinates]=\"coordinates\"></svg:g>\n\n  <!-- GAUGE POINTER -->\n  <svg:g *ngIf=\"hasRanges\" po-gauge-pointer [p-coordinates]=\"pointerCoordinates\"></svg:g>\n</svg:svg>\n"]}

package/esm2020/lib/components/po-gauge/po-gauge-title/po-gauge-title.component.mjs

@@ -0,0 +1,28 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+function PoGaugeTitleComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 1);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ctx_r0.title);
+} }
+export class PoGaugeTitleComponent {
+}
+PoGaugeTitleComponent.ɵfac = function PoGaugeTitleComponent_Factory(t) { return new (t || PoGaugeTitleComponent)(); };
+PoGaugeTitleComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoGaugeTitleComponent, selectors: [["po-gauge-title"]], inputs: { title: ["p-title", "title"] }, decls: 1, vars: 1, consts: [["class", "po-gauge-title", 4, "ngIf"], [1, "po-gauge-title"]], template: function PoGaugeTitleComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, PoGaugeTitleComponent_div_0_Template, 2, 1, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.title);
+    } }, directives: [i1.NgIf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugeTitleComponent, [{
+        type: Component,
+        args: [{ selector: 'po-gauge-title', template: "<div *ngIf=\"title\" class=\"po-gauge-title\">{{ title }}</div>\n" }]
+    }], null, { title: [{
+            type: Input,
+            args: ['p-title']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tZ2F1Z2UtdGl0bGUuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWdhdWdlL3BvLWdhdWdlLXRpdGxlL3BvLWdhdWdlLXRpdGxlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvY29tcG9uZW50cy9wby1nYXVnZS9wby1nYXVnZS10aXRsZS9wby1nYXVnZS10aXRsZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBVSxNQUFNLGVBQWUsQ0FBQzs7OztJQ0F6RCw4QkFBMEM7SUFBQSxZQUFXO0lBQUEsaUJBQU07OztJQUFqQixlQUFXO0lBQVgsa0NBQVc7O0FETXJELE1BQU0sT0FBTyxxQkFBcUI7OzBGQUFyQixxQkFBcUI7d0VBQXJCLHFCQUFxQjtRQ05sQyxzRUFBMkQ7O1FBQXJELGdDQUFXOzt1RkRNSixxQkFBcUI7Y0FKakMsU0FBUzsyQkFDRSxnQkFBZ0I7Z0JBSVIsS0FBSztrQkFBdEIsS0FBSzttQkFBQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3BvLWdhdWdlLXRpdGxlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3BvLWdhdWdlLXRpdGxlLmNvbXBvbmVudC5odG1sJ1xufSlcbmV4cG9ydCBjbGFzcyBQb0dhdWdlVGl0bGVDb21wb25lbnQge1xuICBASW5wdXQoJ3AtdGl0bGUnKSB0aXRsZT86IHN0cmluZztcbn1cbiIsIjxkaXYgKm5nSWY9XCJ0aXRsZVwiIGNsYXNzPVwicG8tZ2F1Z2UtdGl0bGVcIj57eyB0aXRsZSB9fTwvZGl2PlxuIl19

package/esm2020/lib/components/po-gauge/po-gauge.component.mjs

@@ -0,0 +1,109 @@
+import { Component, ElementRef, ViewChild } from '@angular/core';
+import { PoGaugePadding } from './po-gauge-default-values.constant';
+import { PoGaugeBaseComponent } from './po-gauge-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/po-color/po-color.service";
+import * as i2 from "./po-gauge-title/po-gauge-title.component";
+import * as i3 from "./po-gauge-description/po-gauge-description.component";
+import * as i4 from "./po-gauge-svg/po-gauge-svg.component";
+import * as i5 from "./po-gauge-legend/po-gauge-legend.component";
+const _c0 = ["descriptionEl"];
+const _c1 = ["legendEl"];
+const _c2 = ["titleEl"];
+const _c3 = ["svgEl"];
+/**
+ * @docsExtends PoGaugeBaseComponent
+ *
+ * @example
+ *
+ * <example name="po-gauge-basic" title="PO Gauge Basic">
+ *  <file name="sample-po-gauge-basic/sample-po-gauge-basic.component.html"> </file>
+ *  <file name="sample-po-gauge-basic/sample-po-gauge-basic.component.ts"> </file>
+ * </example>
+ * <example name="po-gauge-labs" title="PO Gauge Labs">
+ *  <file name="sample-po-gauge-labs/sample-po-gauge-labs.component.html"> </file>
+ *  <file name="sample-po-gauge-labs/sample-po-gauge-labs.component.ts"> </file>
+ * </example>
+ * <example name="po-gauge-summary" title="PO Gauge Summary">
+ *  <file name="sample-po-gauge-summary/sample-po-gauge-summary.component.html"> </file>
+ *  <file name="sample-po-gauge-summary/sample-po-gauge-summary.component.ts"> </file>
+ * </example>
+ */
+export class PoGaugeComponent extends PoGaugeBaseComponent {
+    constructor(colorService, changeDetector) {
+        super(colorService);
+        this.colorService = colorService;
+        this.changeDetector = changeDetector;
+        this.isLoaded = false;
+    }
+    get hasElementRef() {
+        return !!this.svgEl?.nativeElement.offsetWidth;
+    }
+    get hasRanges() {
+        return this.ranges.length > 0;
+    }
+    ngDoCheck() {
+        if (!this.isLoaded && this.hasElementRef) {
+            this.isLoaded = true;
+            this.svgContainerSize();
+        }
+    }
+    svgContainerSize() {
+        if (this.svgEl?.nativeElement.offsetWidth) {
+            this.changeDetector.detectChanges();
+            const titleHeight = this.titleEl.nativeElement?.offsetHeight ?? 0;
+            const legendHeight = this.legendEl.nativeElement?.offsetHeight ?? 0;
+            const descriptionHeight = this.descriptionEl.nativeElement?.offsetHeight ?? 0;
+            const height = this.height - titleHeight - legendHeight - descriptionHeight - PoGaugePadding * 2;
+            const width = this.svgEl.nativeElement.offsetWidth;
+            this.svgContainer = { width, height };
+        }
+    }
+}
+PoGaugeComponent.ɵfac = function PoGaugeComponent_Factory(t) { return new (t || PoGaugeComponent)(i0.ɵɵdirectiveInject(i1.PoColorService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoGaugeComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoGaugeComponent, selectors: [["po-gauge"]], viewQuery: function PoGaugeComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ElementRef);
+        i0.ɵɵviewQuery(_c1, 5, ElementRef);
+        i0.ɵɵviewQuery(_c2, 5, ElementRef);
+        i0.ɵɵviewQuery(_c3, 5, ElementRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.descriptionEl = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.legendEl = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.titleEl = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.svgEl = _t.first);
+    } }, features: [i0.ɵɵInheritDefinitionFeature], decls: 9, vars: 11, consts: [[1, "po-gauge-wrapper"], [3, "p-title"], ["titleEl", ""], [3, "p-description", "p-description-width", "p-has-ranges", "p-value"], ["descriptionEl", ""], [3, "p-container", "p-ranges", "p-value"], ["svgEl", ""], [3, "p-ranges"], ["legendEl", ""]], template: function PoGaugeComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelement(1, "po-gauge-title", 1, 2);
+        i0.ɵɵelement(3, "po-gauge-description", 3, 4);
+        i0.ɵɵelement(5, "po-gauge-svg", 5, 6);
+        i0.ɵɵelement(7, "po-gauge-legend", 7, 8);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵstyleProp("height", ctx.height, "px");
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("p-title", ctx.title);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("p-description", ctx.description)("p-description-width", ctx.height)("p-has-ranges", ctx.hasRanges)("p-value", ctx.value);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("p-container", ctx.svgContainer)("p-ranges", ctx.ranges)("p-value", ctx.value);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("p-ranges", ctx.ranges);
+    } }, directives: [i2.PoGaugeTitleComponent, i3.PoGaugeDescriptionComponent, i4.PoGaugeSvgComponent, i5.PoGaugeLegendComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugeComponent, [{
+        type: Component,
+        args: [{ selector: 'po-gauge', template: "<div class=\"po-gauge-wrapper\" [style.height.px]=\"height\">\n  <po-gauge-title #titleEl [p-title]=\"title\"></po-gauge-title>\n\n  <po-gauge-description\n    #descriptionEl\n    [p-description]=\"description\"\n    [p-description-width]=\"height\"\n    [p-has-ranges]=\"hasRanges\"\n    [p-value]=\"value\"\n  ></po-gauge-description>\n\n  <po-gauge-svg #svgEl [p-container]=\"svgContainer\" [p-ranges]=\"ranges\" [p-value]=\"value\"></po-gauge-svg>\n\n  <po-gauge-legend #legendEl [p-ranges]=\"ranges\"> </po-gauge-legend>\n</div>\n" }]
+    }], function () { return [{ type: i1.PoColorService }, { type: i0.ChangeDetectorRef }]; }, { descriptionEl: [{
+            type: ViewChild,
+            args: ['descriptionEl', { read: ElementRef }]
+        }], legendEl: [{
+            type: ViewChild,
+            args: ['legendEl', { read: ElementRef }]
+        }], titleEl: [{
+            type: ViewChild,
+            args: ['titleEl', { read: ElementRef }]
+        }], svgEl: [{
+            type: ViewChild,
+            args: ['svgEl', { read: ElementRef }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tZ2F1Z2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWdhdWdlL3BvLWdhdWdlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvY29tcG9uZW50cy9wby1nYXVnZS9wby1nYXVnZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXFCLFNBQVMsRUFBVyxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdGLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUlwRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQzs7Ozs7Ozs7Ozs7QUFHakU7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBS0gsTUFBTSxPQUFPLGdCQUFpQixTQUFRLG9CQUFvQjtJQVV4RCxZQUFzQixZQUE0QixFQUFVLGNBQWlDO1FBQzNGLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztRQURBLGlCQUFZLEdBQVosWUFBWSxDQUFnQjtRQUFVLG1CQUFjLEdBQWQsY0FBYyxDQUFtQjtRQUZyRixhQUFRLEdBQVksS0FBSyxDQUFDO0lBSWxDLENBQUM7SUFFRCxJQUFZLGFBQWE7UUFDdkIsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxhQUFhLENBQUMsV0FBVyxDQUFDO0lBQ2pELENBQUM7SUFFRCxJQUFJLFNBQVM7UUFDWCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQsU0FBUztRQUNQLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUU7WUFDeEMsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUM7WUFDckIsSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7U0FDekI7SUFDSCxDQUFDO0lBRVMsZ0JBQWdCO1FBQ3hCLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxhQUFhLENBQUMsV0FBVyxFQUFFO1lBQ3pDLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxFQUFFLENBQUM7WUFFcEMsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLEVBQUUsWUFBWSxJQUFJLENBQUMsQ0FBQztZQUNsRSxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsRUFBRSxZQUFZLElBQUksQ0FBQyxDQUFDO1lBQ3BFLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxhQUFhLEVBQUUsWUFBWSxJQUFJLENBQUMsQ0FBQztZQUU5RSxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsR0FBRyxZQUFZLEdBQUcsaUJBQWlCLEdBQUcsY0FBYyxHQUFHLENBQUMsQ0FBQztZQUNqRyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUM7WUFFbkQsSUFBSSxDQUFDLFlBQVksR0FBRyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQztTQUN2QztJQUNILENBQUM7O2dGQTFDVSxnQkFBZ0I7bUVBQWhCLGdCQUFnQjsrQkFDUyxVQUFVOytCQUNmLFVBQVU7K0JBQ1gsVUFBVTsrQkFDWixVQUFVOzs7Ozs7OztRQ25DeEMsOEJBQXlEO1FBQ3ZELHVDQUE0RDtRQUU1RCw2Q0FNd0I7UUFFeEIscUNBQXVHO1FBRXZHLHdDQUFrRTtRQUNwRSxpQkFBTTs7UUFkd0IsMENBQTBCO1FBQzdCLGVBQWlCO1FBQWpCLG1DQUFpQjtRQUl4QyxlQUE2QjtRQUE3QiwrQ0FBNkIsbUNBQUEsK0JBQUEsc0JBQUE7UUFNVixlQUE0QjtRQUE1Qiw4Q0FBNEIsd0JBQUEsc0JBQUE7UUFFdEIsZUFBbUI7UUFBbkIscUNBQW1COzt1RkRrQm5DLGdCQUFnQjtjQUo1QixTQUFTOzJCQUNFLFVBQVU7aUdBSThCLGFBQWE7a0JBQTlELFNBQVM7bUJBQUMsZUFBZSxFQUFFLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRTtZQUNILFFBQVE7a0JBQXBELFNBQVM7bUJBQUMsVUFBVSxFQUFFLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRTtZQUNDLE9BQU87a0JBQWxELFNBQVM7bUJBQUMsU0FBUyxFQUFFLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRTtZQUNBLEtBQUs7a0JBQTlDLFNBQVM7bUJBQUMsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdG9yUmVmLCBDb21wb25lbnQsIERvQ2hlY2ssIEVsZW1lbnRSZWYsIFZpZXdDaGlsZCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQb0dhdWdlUGFkZGluZyB9IGZyb20gJy4vcG8tZ2F1Z2UtZGVmYXVsdC12YWx1ZXMuY29uc3RhbnQnO1xuXG5pbXBvcnQgeyBQb0NvbG9yU2VydmljZSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzL3BvLWNvbG9yL3BvLWNvbG9yLnNlcnZpY2UnO1xuXG5pbXBvcnQgeyBQb0dhdWdlQmFzZUNvbXBvbmVudCB9IGZyb20gJy4vcG8tZ2F1Z2UtYmFzZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgUG9HYXVnZVN2Z0NvbnRhaW5lciB9IGZyb20gJy4vaW50ZXJmYWNlcy9wby1nYXVnZS1zdmctY29udGFpbmVyLmludGVyZmFjZSc7XG5cbi8qKlxuICogQGRvY3NFeHRlbmRzIFBvR2F1Z2VCYXNlQ29tcG9uZW50XG4gKlxuICogQGV4YW1wbGVcbiAqXG4gKiA8ZXhhbXBsZSBuYW1lPVwicG8tZ2F1Z2UtYmFzaWNcIiB0aXRsZT1cIlBPIEdhdWdlIEJhc2ljXCI+XG4gKiAgPGZpbGUgbmFtZT1cInNhbXBsZS1wby1nYXVnZS1iYXNpYy9zYW1wbGUtcG8tZ2F1Z2UtYmFzaWMuY29tcG9uZW50Lmh0bWxcIj4gPC9maWxlPlxuICogIDxmaWxlIG5hbWU9XCJzYW1wbGUtcG8tZ2F1Z2UtYmFzaWMvc2FtcGxlLXBvLWdhdWdlLWJhc2ljLmNvbXBvbmVudC50c1wiPiA8L2ZpbGU+XG4gKiA8L2V4YW1wbGU+XG4gKiA8ZXhhbXBsZSBuYW1lPVwicG8tZ2F1Z2UtbGFic1wiIHRpdGxlPVwiUE8gR2F1Z2UgTGFic1wiPlxuICogIDxmaWxlIG5hbWU9XCJzYW1wbGUtcG8tZ2F1Z2UtbGFicy9zYW1wbGUtcG8tZ2F1Z2UtbGFicy5jb21wb25lbnQuaHRtbFwiPiA8L2ZpbGU+XG4gKiAgPGZpbGUgbmFtZT1cInNhbXBsZS1wby1nYXVnZS1sYWJzL3NhbXBsZS1wby1nYXVnZS1sYWJzLmNvbXBvbmVudC50c1wiPiA8L2ZpbGU+XG4gKiA8L2V4YW1wbGU+XG4gKiA8ZXhhbXBsZSBuYW1lPVwicG8tZ2F1Z2Utc3VtbWFyeVwiIHRpdGxlPVwiUE8gR2F1Z2UgU3VtbWFyeVwiPlxuICogIDxmaWxlIG5hbWU9XCJzYW1wbGUtcG8tZ2F1Z2Utc3VtbWFyeS9zYW1wbGUtcG8tZ2F1Z2Utc3VtbWFyeS5jb21wb25lbnQuaHRtbFwiPiA8L2ZpbGU+XG4gKiAgPGZpbGUgbmFtZT1cInNhbXBsZS1wby1nYXVnZS1zdW1tYXJ5L3NhbXBsZS1wby1nYXVnZS1zdW1tYXJ5LmNvbXBvbmVudC50c1wiPiA8L2ZpbGU+XG4gKiA8L2V4YW1wbGU+XG4gKi9cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3BvLWdhdWdlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3BvLWdhdWdlLmNvbXBvbmVudC5odG1sJ1xufSlcbmV4cG9ydCBjbGFzcyBQb0dhdWdlQ29tcG9uZW50IGV4dGVuZHMgUG9HYXVnZUJhc2VDb21wb25lbnQgaW1wbGVtZW50cyBEb0NoZWNrIHtcbiAgQFZpZXdDaGlsZCgnZGVzY3JpcHRpb25FbCcsIHsgcmVhZDogRWxlbWVudFJlZiB9KSBkZXNjcmlwdGlvbkVsOiBFbGVtZW50UmVmO1xuICBAVmlld0NoaWxkKCdsZWdlbmRFbCcsIHsgcmVhZDogRWxlbWVudFJlZiB9KSBsZWdlbmRFbDogRWxlbWVudFJlZjtcbiAgQFZpZXdDaGlsZCgndGl0bGVFbCcsIHsgcmVhZDogRWxlbWVudFJlZiB9KSB0aXRsZUVsOiBFbGVtZW50UmVmO1xuICBAVmlld0NoaWxkKCdzdmdFbCcsIHsgcmVhZDogRWxlbWVudFJlZiB9KSBzdmdFbDogRWxlbWVudFJlZjtcblxuICBzdmdDb250YWluZXI6IFBvR2F1Z2VTdmdDb250YWluZXI7XG5cbiAgcHJpdmF0ZSBpc0xvYWRlZDogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBjb2xvclNlcnZpY2U6IFBvQ29sb3JTZXJ2aWNlLCBwcml2YXRlIGNoYW5nZURldGVjdG9yOiBDaGFuZ2VEZXRlY3RvclJlZikge1xuICAgIHN1cGVyKGNvbG9yU2VydmljZSk7XG4gIH1cblxuICBwcml2YXRlIGdldCBoYXNFbGVtZW50UmVmKCkge1xuICAgIHJldHVybiAhIXRoaXMuc3ZnRWw/Lm5hdGl2ZUVsZW1lbnQub2Zmc2V0V2lkdGg7XG4gIH1cblxuICBnZXQgaGFzUmFuZ2VzKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLnJhbmdlcy5sZW5ndGggPiAwO1xuICB9XG5cbiAgbmdEb0NoZWNrKCkge1xuICAgIGlmICghdGhpcy5pc0xvYWRlZCAmJiB0aGlzLmhhc0VsZW1lbnRSZWYpIHtcbiAgICAgIHRoaXMuaXNMb2FkZWQgPSB0cnVlO1xuICAgICAgdGhpcy5zdmdDb250YWluZXJTaXplKCk7XG4gICAgfVxuICB9XG5cbiAgcHJvdGVjdGVkIHN2Z0NvbnRhaW5lclNpemUoKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuc3ZnRWw/Lm5hdGl2ZUVsZW1lbnQub2Zmc2V0V2lkdGgpIHtcbiAgICAgIHRoaXMuY2hhbmdlRGV0ZWN0b3IuZGV0ZWN0Q2hhbmdlcygpO1xuXG4gICAgICBjb25zdCB0aXRsZUhlaWdodCA9IHRoaXMudGl0bGVFbC5uYXRpdmVFbGVtZW50Py5vZmZzZXRIZWlnaHQgPz8gMDtcbiAgICAgIGNvbnN0IGxlZ2VuZEhlaWdodCA9IHRoaXMubGVnZW5kRWwubmF0aXZlRWxlbWVudD8ub2Zmc2V0SGVpZ2h0ID8/IDA7XG4gICAgICBjb25zdCBkZXNjcmlwdGlvbkhlaWdodCA9IHRoaXMuZGVzY3JpcHRpb25FbC5uYXRpdmVFbGVtZW50Py5vZmZzZXRIZWlnaHQgPz8gMDtcblxuICAgICAgY29uc3QgaGVpZ2h0ID0gdGhpcy5oZWlnaHQgLSB0aXRsZUhlaWdodCAtIGxlZ2VuZEhlaWdodCAtIGRlc2NyaXB0aW9uSGVpZ2h0IC0gUG9HYXVnZVBhZGRpbmcgKiAyO1xuICAgICAgY29uc3Qgd2lkdGggPSB0aGlzLnN2Z0VsLm5hdGl2ZUVsZW1lbnQub2Zmc2V0V2lkdGg7XG5cbiAgICAgIHRoaXMuc3ZnQ29udGFpbmVyID0geyB3aWR0aCwgaGVpZ2h0IH07XG4gICAgfVxuICB9XG59XG4iLCI8ZGl2IGNsYXNzPVwicG8tZ2F1Z2Utd3JhcHBlclwiIFtzdHlsZS5oZWlnaHQucHhdPVwiaGVpZ2h0XCI+XG4gIDxwby1nYXVnZS10aXRsZSAjdGl0bGVFbCBbcC10aXRsZV09XCJ0aXRsZVwiPjwvcG8tZ2F1Z2UtdGl0bGU+XG5cbiAgPHBvLWdhdWdlLWRlc2NyaXB0aW9uXG4gICAgI2Rlc2NyaXB0aW9uRWxcbiAgICBbcC1kZXNjcmlwdGlvbl09XCJkZXNjcmlwdGlvblwiXG4gICAgW3AtZGVzY3JpcHRpb24td2lkdGhdPVwiaGVpZ2h0XCJcbiAgICBbcC1oYXMtcmFuZ2VzXT1cImhhc1Jhbmdlc1wiXG4gICAgW3AtdmFsdWVdPVwidmFsdWVcIlxuICA+PC9wby1nYXVnZS1kZXNjcmlwdGlvbj5cblxuICA8cG8tZ2F1Z2Utc3ZnICNzdmdFbCBbcC1jb250YWluZXJdPVwic3ZnQ29udGFpbmVyXCIgW3AtcmFuZ2VzXT1cInJhbmdlc1wiIFtwLXZhbHVlXT1cInZhbHVlXCI+PC9wby1nYXVnZS1zdmc+XG5cbiAgPHBvLWdhdWdlLWxlZ2VuZCAjbGVnZW5kRWwgW3AtcmFuZ2VzXT1cInJhbmdlc1wiPiA8L3BvLWdhdWdlLWxlZ2VuZD5cbjwvZGl2PlxuIl19

package/esm2020/lib/components/po-gauge/po-gauge.module.mjs

@@ -0,0 +1,44 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PoTooltipModule } from '../../directives/po-tooltip/po-tooltip.module';
+import { PoGaugeComponent } from './po-gauge.component';
+import { PoGaugeDescriptionComponent } from './po-gauge-description/po-gauge-description.component';
+import { PoGaugeLegendComponent } from './po-gauge-legend/po-gauge-legend.component';
+import { PoGaugePathComponent } from './po-gauge-svg/po-gauge-path/po-gauge-path.component';
+import { PoGaugeSvgComponent } from './po-gauge-svg/po-gauge-svg.component';
+import { PoGaugeTitleComponent } from './po-gauge-title/po-gauge-title.component';
+import { PoGaugePointerComponent } from './po-gauge-svg/po-gauge-pointer/po-gauge-pointer.component';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Módulo do componente po-gauge.
+ */
+export class PoGaugeModule {
+}
+PoGaugeModule.ɵfac = function PoGaugeModule_Factory(t) { return new (t || PoGaugeModule)(); };
+PoGaugeModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoGaugeModule });
+PoGaugeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[CommonModule, PoTooltipModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGaugeModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule, PoTooltipModule],
+                declarations: [
+                    PoGaugeComponent,
+                    PoGaugeTitleComponent,
+                    PoGaugeLegendComponent,
+                    PoGaugeSvgComponent,
+                    PoGaugePathComponent,
+                    PoGaugeDescriptionComponent,
+                    PoGaugePointerComponent
+                ],
+                exports: [PoGaugeComponent]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PoGaugeModule, { declarations: [PoGaugeComponent,
+        PoGaugeTitleComponent,
+        PoGaugeLegendComponent,
+        PoGaugeSvgComponent,
+        PoGaugePathComponent,
+        PoGaugeDescriptionComponent,
+        PoGaugePointerComponent], imports: [CommonModule, PoTooltipModule], exports: [PoGaugeComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-grid/index.mjs

@@ -0,0 +1,4 @@
+export * from './po-grid-row-actions.interface';
+export * from './po-grid.component';
+export * from './po-grid.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tZ3JpZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMscUJBQXFCLENBQUM7QUFFcEMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcG8tZ3JpZC1yb3ctYWN0aW9ucy5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wby1ncmlkLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcG8tZ3JpZC5tb2R1bGUnO1xuIl19