@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-chart/enums/po-chart-type.enum.mjs

@@ -0,0 +1,38 @@
+/**
+ * @usedBy PoChartComponent
+ *
+ * @description
+ *
+ * *Enum* `PoChartType` para especificação dos tipos de gráficos.
+ */
+export var PoChartType;
+(function (PoChartType) {
+    /**
+     * Tipo de gráfico que exibe os dados de modo quantitativo, utilizando linhas contínuas demarcadas por pontos para cada valor de série definido.
+     * Similar ao gráfico de linha, diferencia-se pela área localizada abaixo da linha das séries, que é preenchida com cores para um destaque explícita da evolução e mudança dos dados.
+     */
+    PoChartType["Area"] = "area";
+    /**
+     * Exibe os dados em formato de rosca, dividindo em partes proporcionais.
+     */
+    PoChartType["Donut"] = "donut";
+    /**
+     * Exibe os dados em formato circular, dividindo proporcionalmente em fatias.
+     */
+    PoChartType["Pie"] = "pie";
+    /**
+     * Gráfico que mostra os dados de modo linear e contínuo. É útil, por exemplo, para fazer comparações de tendência durante determinado período.
+     * Pode ser utilizado em conjunto com gráficos dos tipos `column` e `area`, definindo-se o tipo através da propriedade `PoChartSerie.type`.
+     */
+    PoChartType["Line"] = "line";
+    /**
+     * Gráfico que exibe os dados em forma de barras verticais e sua extensão varia de acordo com seus valores. É comumente usado como comparativo entre diversas séries.
+     * As séries são exibidas lado-a-lado, com um pequeno espaço entre elas.
+     */
+    PoChartType["Column"] = "column";
+    /**
+     * Gráfico que exibe os dados em forma de barras horizontais e sua extensão varia de acordo com seus valores. É comumente usado como comparativo de séries e categorias.
+     */
+    PoChartType["Bar"] = "bar";
+})(PoChartType || (PoChartType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-chart/helpers/po-chart-default-values.constant.mjs

@@ -0,0 +1,18 @@
+// Padding padrão
+export const PoChartPadding = 24;
+// Área lateral designada para os rótulos do eixo X
+export const PoChartAxisXLabelArea = 56;
+// Quantidade de linhas do eixo X
+export const PoChartGridLines = 5;
+// Padding top para área interna de plotagem do grid para evitar overflow no hover dos pontos do gráfico do tipo linha;
+export const PoChartPlotAreaPaddingTop = 8;
+// Angulação inicial de raio para gráficos do tipo circular
+export const PoChartStartAngle = -Math.PI / 2;
+// Valor referente à espessura padrão do gráfico do tipo Donut.
+export const PoChartDonutDefaultThickness = 40;
+// Valor para subtração do valor de angulo radiano final de série em tipos Donut e Pie. Necessário para o caso de uma série única: se uma circunferência tiver valores de ângulo de raio inicial e final iguais não plota.
+export const PoChartCompleteCircle = 0.0001;
+// Duração da animação para gráficos dos tipos Donut e Pie.
+const durationTime = 1500;
+export const PoChartAngleStepInterval = (Math.PI * 2) / Math.floor(durationTime / 60);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+export * from './interfaces/po-chart-serie.interface';
+export * from './enums/po-chart-type.enum';
+export * from './interfaces/po-chart-axis-options.interface';
+export * from './interfaces/po-chart-options.interface';
+export * from './po-chart.component';
+export * from './po-chart.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1Q0FBdUMsQ0FBQztBQUV0RCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyx5Q0FBeUMsQ0FBQztBQUV4RCxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMvcG8tY2hhcnQtc2VyaWUuaW50ZXJmYWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9lbnVtcy9wby1jaGFydC10eXBlLmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzL3BvLWNoYXJ0LWF4aXMtb3B0aW9ucy5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzL3BvLWNoYXJ0LW9wdGlvbnMuaW50ZXJmYWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9wby1jaGFydC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BvLWNoYXJ0Lm1vZHVsZSc7XG4iXX0=

package/esm2020/lib/components/po-chart/interfaces/po-chart-axis-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/po-chart/interfaces/po-chart-bar-coordinates.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtYmFyLWNvb3JkaW5hdGVzLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvY29tcG9uZW50cy9wby1jaGFydC9pbnRlcmZhY2VzL3BvLWNoYXJ0LWJhci1jb29yZGluYXRlcy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRvY3NQcml2YXRlXG4gKlxuICogQHVzZWRCeSBQb0NoYXJ0Q29tcG9uZW50XG4gKlxuICogQGRlc2NyaXB0aW9uXG4gKlxuICogSW50ZXJmYWNlIHF1ZSBkZWZpbmUgbyBvYmpldG8gY29tIGFzIGNvb3JkZW5hZGFzIGRhcyBjb2x1bmFzIHBhcmEgb3MgZ3LDoWZpY28gZG9zIHRpcG9zIGJhcnJhIGUgY29sdW5hLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBvQ2hhcnRCYXJDb29yZGluYXRlcyB7XG4gIC8qKiBDYXRlZ29yaWEgZG8gZWl4byBZIG5hIHF1YWwgbyBpdGVtIGRhIHPDqXJpZSBlc3TDoSBwcmVzZW50ZS4gKi9cbiAgY2F0ZWdvcnk6IHN0cmluZztcblxuICAvKiogQSBjb3IgZGEgc8OpcmllLiAqL1xuICBjb2xvcj86IHN0cmluZztcblxuICAvKiogQSBzw6lyaWUgcGFyYSBhIHF1YWwgY29ycmVzcG9uZGVtIGFzIGNvb3JkZW5hZGFzLiAqL1xuICBsYWJlbDogc3RyaW5nO1xuXG4gIC8qKiBPIHRleHRvIGRlIGV4aWJpw6fDo28gbm8gdG9vbHRpcC4gKi9cbiAgdG9vbHRpcExhYmVsOiBzdHJpbmc7XG5cbiAgLyoqIFZhbG9yIGRhIHPDqXJpZS4gKi9cbiAgZGF0YTogbnVtYmVyO1xuXG4gIC8qKiBDb29yZGVuYWRhcyBkYSBjb2x1bmEuICovXG4gIGNvb3JkaW5hdGVzOiBzdHJpbmc7XG59XG4iXX0=

package/esm2020/lib/components/po-chart/interfaces/po-chart-container-size.interface.mjs

@@ -0,0 +1,11 @@
+/**
+ * @docsPrivate
+ *
+ * @usedBy PoChartComponent
+ *
+ * @description
+ *
+ * Agrupamento das medidas utilizadas para dimensionamento do container SVG e para cálculos de plotagem.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtY29udGFpbmVyLXNpemUuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWNoYXJ0L2ludGVyZmFjZXMvcG8tY2hhcnQtY29udGFpbmVyLXNpemUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZG9jc1ByaXZhdGVcbiAqXG4gKiBAdXNlZEJ5IFBvQ2hhcnRDb21wb25lbnRcbiAqXG4gKiBAZGVzY3JpcHRpb25cbiAqXG4gKiBBZ3J1cGFtZW50byBkYXMgbWVkaWRhcyB1dGlsaXphZGFzIHBhcmEgZGltZW5zaW9uYW1lbnRvIGRvIGNvbnRhaW5lciBTVkcgZSBwYXJhIGPDoWxjdWxvcyBkZSBwbG90YWdlbS5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFBvQ2hhcnRDb250YWluZXJTaXplIHtcbiAgLyoqIExhcmd1cmEgcmVmZXJlbnRlIGFvIHRleHRvIG1haXMgbG9uZ28gZGEgc8OpcmllIG91IGNhdGVnb3JpYSBwYXJhIGRlc2lnbmHDp8OjbyBkZSDDoXJlYSBkb3MgdGV4dG9zIGRvIGVpeG8gWCBkbyBncmlkLiAqL1xuICBheGlzWExhYmVsV2lkdGg/OiBudW1iZXI7XG5cbiAgLyoqIExhcmd1cmEgZG8gY29udGFpbmVyLiAqL1xuICBzdmdXaWR0aD86IG51bWJlcjtcblxuICAvKiogTWV0YWRlIGRhIGxhcmd1cmEgZG8gY29udGFpbmVyICovXG4gIGNlbnRlclg/OiBudW1iZXI7XG5cbiAgLyoqIEFsdHVyYSBkbyBjb250YWluZXIuICovXG4gIHN2Z0hlaWdodD86IG51bWJlcjtcblxuICAvKiogTWV0YWRlIGRhIGFsdHVyYSBkbyBjb250YWluZXIuICovXG4gIGNlbnRlclk/OiBudW1iZXI7XG5cbiAgLyoqIE1lZGlkYSBkYSBhbHR1cmEgZG8gY29udGFpbmVyIC0gcGFkZGluZyBzdXBlcmlvci4gKi9cbiAgc3ZnUGxvdHRpbmdBcmVhSGVpZ2h0PzogbnVtYmVyO1xufVxuIl19

package/esm2020/lib/components/po-chart/interfaces/po-chart-label-coordinates.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtbGFiZWwtY29vcmRpbmF0ZXMuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWNoYXJ0L2ludGVyZmFjZXMvcG8tY2hhcnQtbGFiZWwtY29vcmRpbmF0ZXMuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkb2NzUHJpdmF0ZVxuICpcbiAqIEB1c2VkQnkgUG9DaGFydENvbXBvbmVudFxuICpcbiAqIEBkZXNjcmlwdGlvblxuICpcbiAqIEludGVyZmFjZSBxdWUgZGVmaW5lIG8gb2JqZXRvIGNvbSBhcyBjb29yZGVuYWRhcyBkb3MgdGV4dG9zIGRvcyBlaXhvcyhheGlzKS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQb0NoYXJ0TGFiZWxDb29yZGluYXRlcyB7XG4gIC8qKiBEZWZpbmUgYSBjb3IgZG8gdGV4dG8uICovXG4gIGNvbG9yPzogc3RyaW5nO1xuXG4gIC8qKiBEZWZpbmUgbyB0ZXh0byBkbyBlaXhvIGNvcnJlc3BvbmRlbnRlLiAqL1xuICBsYWJlbD86IHN0cmluZztcblxuICAvKiogQ29vcmRlbmFkYSBob3Jpem9udGFsLiAqL1xuICB4Q29vcmRpbmF0ZT86IG51bWJlcjtcblxuICAvKiogQ29vcmRlbmFkYSB2ZXJ0aWNhbC4gKi9cbiAgeUNvb3JkaW5hdGU/OiBudW1iZXI7XG59XG4iXX0=

package/esm2020/lib/components/po-chart/interfaces/po-chart-min-max-values.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtbWluLW1heC12YWx1ZXMuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWNoYXJ0L2ludGVyZmFjZXMvcG8tY2hhcnQtbWluLW1heC12YWx1ZXMuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkb2NzUHJpdmF0ZVxuICpcbiAqIEB1c2VkQnkgUG9DaGFydENvbXBvbmVudFxuICpcbiAqIEBkZXNjcmlwdGlvblxuICpcbiAqICpJbnRlcmZhY2UqIGBQb0NoYXJ0TWluTWF4YCBwYXJhIGVzcGVjaWZpY2HDp8OjbyBkZSB2YWxvcmVzIGVzcGVjw61maWNvcyBkYXMgc8Opcmllcy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQb0NoYXJ0TWluTWF4VmFsdWVzIHtcbiAgLyoqXG4gICAqIE8gdmFsb3IgbcOtbmltbyBkYXMgc8Opcmllcy5cbiAgICovXG4gIG1pblZhbHVlPzogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBPIHZhbG9yIG3DoXhpbW8gZGFzIHPDqXJpZXNcbiAgICovXG4gIG1heFZhbHVlPzogbnVtYmVyO1xufVxuIl19

package/esm2020/lib/components/po-chart/interfaces/po-chart-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtb3B0aW9ucy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvaW50ZXJmYWNlcy9wby1jaGFydC1vcHRpb25zLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9DaGFydEF4aXNPcHRpb25zIH0gZnJvbSAnLi9wby1jaGFydC1heGlzLW9wdGlvbnMuaW50ZXJmYWNlJztcblxuLyoqXG4gKiBAdXNlZEJ5IFBvQ2hhcnRDb21wb25lbnRcbiAqXG4gKiBAZGVzY3JpcHRpb25cbiAqXG4gKiAqSW50ZXJmYWNlKiBwYXJhIGNvbmZpZ3VyYcOnw7VlcyBkb3MgZWxlbWVudG9zIGRvIGdyw6FmaWNvLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBvQ2hhcnRPcHRpb25zIHtcbiAgLyoqIERlZmluZSB1bSBvYmpldG8gZG8gdGlwbyBgUG9DaGFydEF4aXNPcHRpb25zYCBwYXJhIGNvbmZpZ3VyYcOnw6NvIGRvcyBlaXhvcy4gKi9cbiAgYXhpcz86IFBvQ2hhcnRBeGlzT3B0aW9ucztcblxuICAvKipcbiAgICogRGVmaW5lIG8gZGnDom1ldHJvLCBlbSB2YWxvciBwZXJjZW50dWFsIGVudHJlIGAwYCBlIGAxMDBgLCBkYSDDoXJlYSBjZW50cmFsIHBhcmEgZ3LDoWZpY29zIGRvIHRpcG8gYGRvbnV0YC5cbiAgICogU2UgcGFzc2FkbyB1bSBwZXJjZW50dWFsIHF1ZSB0b3JuZSBhIGVzcGVzc3VyYSBkbyBncsOhZmljbyBtZW5vciBkbyBxdWUgYDQwcHhgLFxuICAgKiBvcyB0ZXh0b3MgaW50ZXJub3MgZG8gZ3LDoWZpY29zIHNlcsOjbyBvY3VsdGFkb3MgcGFyYSBxdWUgbsOjbyBoYWphIHF1ZWJyYSBkZSBsYXlvdXQuXG4gICAqL1xuICBpbm5lclJhZGl1cz86IG51bWJlcjtcblxuICAvKiogRGVmaW5lIGEgZXhpYmnDp8OjbyBkYSBsZWdlbmRhIGRvIGdyw6FmaWNvLiBWYWxvciBwYWRyw6NvIMOpIGB0cnVlYCAqL1xuICBsZWdlbmQ/OiBib29sZWFuO1xufVxuIl19

package/esm2020/lib/components/po-chart/interfaces/po-chart-path-coordinates.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtcGF0aC1jb29yZGluYXRlcy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvaW50ZXJmYWNlcy9wby1jaGFydC1wYXRoLWNvb3JkaW5hdGVzLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZG9jc1ByaXZhdGVcbiAqXG4gKiBAdXNlZEJ5IFBvQ2hhcnRDb21wb25lbnRcbiAqXG4gKiBAZGVzY3JpcHRpb25cbiAqXG4gKiBJbnRlcmZhY2UgcXVlIGRlZmluZSBvIG9iamV0byBjb20gYXMgY29vcmRlbmFkYXMgZGFzIGxpbmhhcyBkbyBncsOhZmljbyAoY2hhcnQtcGF0aCkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUG9DaGFydFBhdGhDb29yZGluYXRlcyB7XG4gIC8qKiBBIGNvciBkYSBzw6lyaWUuICovXG4gIGNvbG9yPzogc3RyaW5nO1xuXG4gIC8qKiBBcyBjb29yZGVuYWRhcyBkYSBzw6lyaWUuICovXG4gIGNvb3JkaW5hdGVzPzogc3RyaW5nO1xuXG4gIC8qKiBWYWxvciBkYSBzw6lyaWUuICovXG4gIGRhdGE/OiBudW1iZXI7XG5cbiAgLyoqIEluZGljYSBzZSDDqSBlbGVtZW50byBhbyBxdWFsIG8gY3Vyc29yIGVzdMOhIHNlbGVjaW9uYWRvLiAqL1xuICBpc0FjdGl2ZT86IGJvb2xlYW47XG5cbiAgLyoqIEEgc8OpcmllIHBhcmEgYSBxdWFsIGNvcnJlc3BvbmRlbSBhcyBjb29yZGVuYWRhcy4gKi9cbiAgbGFiZWw/OiBzdHJpbmc7XG5cbiAgLyoqIE8gdGV4dG8gZGUgZXhpYmnDp8OjbyBubyB0b29sdGlwLiAqL1xuICB0b29sdGlwTGFiZWw/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2020/lib/components/po-chart/interfaces/po-chart-points-coordinates.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtcG9pbnRzLWNvb3JkaW5hdGVzLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvY29tcG9uZW50cy9wby1jaGFydC9pbnRlcmZhY2VzL3BvLWNoYXJ0LXBvaW50cy1jb29yZGluYXRlcy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRvY3NQcml2YXRlXG4gKlxuICogQHVzZWRCeSBQb0NoYXJ0Q29tcG9uZW50XG4gKlxuICogQGRlc2NyaXB0aW9uXG4gKlxuICogSW50ZXJmYWNlIHF1ZSBkZWZpbmUgbyBvYmpldG8gY29tIGFzIGNvb3JkZW5hZGFzIGRvcyBwb250b3MgZGFzIGxpbmhhcyBkbyBncsOhZmljbyBkbyB0aXBvIGxpbmhhLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBvQ2hhcnRQb2ludHNDb29yZGluYXRlcyB7XG4gIC8qKiBDYXRlZ29yaWEgZG8gZWl4byBZIG5hIHF1YWwgbyBpdGVtIGRhIHPDqXJpZSBlc3TDoSBwcmVzZW50ZS4gKi9cbiAgY2F0ZWdvcnk6IHN0cmluZztcblxuICAvLyBDb3IgZGEgc8OpcmllXG4gIGNvbG9yPzogc3RyaW5nO1xuXG4gIC8qKiBJbmRpY2EgbyBwb250byBhdGl2byBlbSByZWxhw6fDo28gYW8gcG9zaWNpb25hbWVudG8gZG8gY3Vyc29yIG5hIMOhcmVhIGRvIGdyw6FmaWNvLiAqL1xuICBpc0FjdGl2ZT86IGJvb2xlYW47XG5cbiAgLyoqIEEgc8OpcmllIHBhcmEgYSBxdWFsIGNvcnJlc3BvbmRlbSBhcyBjb29yZGVuYWRhcy4gKi9cbiAgbGFiZWw6IHN0cmluZztcblxuICAvKiogTyB0ZXh0byBkZSBleGliacOnw6NvIG5vIHRvb2x0aXAuICovXG4gIHRvb2x0aXBMYWJlbDogc3RyaW5nO1xuXG4gIC8qKiBWYWxvciBkYSBzw6lyaWUuICovXG4gIGRhdGE6IG51bWJlcjtcblxuICAvKiogQ29vcmRlbmFkYSBob3Jpem9udGFsLiAqL1xuICB4Q29vcmRpbmF0ZTogbnVtYmVyO1xuXG4gIC8qKiBDb29yZGVuYWRhIHZlcnRpY2FsLiAqL1xuICB5Q29vcmRpbmF0ZTogbnVtYmVyO1xufVxuIl19

package/esm2020/lib/components/po-chart/interfaces/po-chart-serie.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,258 @@
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { convertToInt, isTypeof } from '../../utils/util';
+import { PoChartType } from './enums/po-chart-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/po-color/po-color.service";
+const poChartDefaultHeight = 400;
+const poChartMinHeight = 200;
+/**
+ * @description
+ *
+ * O `po-chart` é um componente para renderização de dados através de gráficos, com isso facilitando a compreensão e tornando a
+ * visualização destes dados mais agradável.
+ *
+ * Através de suas principais propriedades é possível definir atributos, tais como tipo de gráfico, altura, título, cores customizadas, opções para os eixos, entre outros.
+ *
+ * O componente permite utilizar em conjunto séries do tipo linha e coluna.
+ *
+ * Além disso, também é possível definir uma ação que será executada ao clicar em determinado elemento do gráfico
+ * e outra que será executada ao passar o *mouse* sobre o elemento.
+ *
+ * #### Guia de uso para Gráficos
+ *
+ * > Veja nosso [guia de uso para gráficos](/guides/guide-charts) para auxiliar na construção do seu gráfico,
+ * informando em qual caso utilizar, o que devemos evitar e boas práticas relacionada a cores.
+ */
+export class PoChartBaseComponent {
+    constructor(colorService) {
+        this.colorService = colorService;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado quando o usuário clicar sobre um elemento do gráfico.
+         *
+         * O evento emitirá o seguinte parâmetro:
+         * - *donut* e *pie*: um objeto contendo a categoria e valor da série.
+         * - *area*, *line*, *column* e *bar*: um objeto contendo o nome da série, valor e categoria do eixo do gráfico.
+         */
+        this.seriesClick = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado quando o usuário passar o *mouse* sobre um elemento do gráfico.
+         *
+         * O evento emitirá o seguinte parâmetro de acordo com o tipo de gráfico:
+         * - *donut* e *pie*: um objeto contendo a categoria e valor da série.
+         * - *area*, *line*, *column* e *bar*: um objeto contendo a categoria, valor da série e categoria do eixo do gráfico.
+         */
+        this.seriesHover = new EventEmitter();
+        // manipulação das séries tratadas internamente para preservar 'p-series';
+        this.chartSeries = [];
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define a altura do gráfico.
+     *
+     * > O valor mínimo aceito nesta propriedade é 200.
+     *
+     * @default `400px`
+     */
+    set height(value) {
+        const intValue = convertToInt(value);
+        let height;
+        if (isTypeof(value, 'number')) {
+            height = intValue <= poChartMinHeight ? poChartMinHeight : intValue;
+        }
+        else {
+            height = this.setDefaultHeight();
+        }
+        this._height = height;
+        this.getSvgContainerSize();
+        this.rebuildComponentRef();
+    }
+    get height() {
+        return this._height || this.setDefaultHeight();
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define o tipo de gráfico.
+     *
+     * É possível também combinar gráficos dos tipos linha e coluna. Para isso, opte pela declaração de `type` conforme a interface `PoChartSerie`.
+     *
+     * > Note que, se houver declaração de tipo de gráfico tanto em `p-type` quanto em `PochartSerie.type`, o valor `{ type }` da primeira série anulará o valor definido em `p-type`.
+     *
+     * Se não passado valor, o padrão será relativo à primeira série passada em `p-series`:
+     * - Se `p-series = [{ data: [1,2,3] }]`: será `PoChartType.Column`.
+     * - Se `p-series = [{ data: 1 }]`: será `PoChartType.Pie`.
+     *
+     * > Veja os valores válidos no *enum* `PoChartType`.
+     */
+    set type(value) {
+        // O Valor default definido em `p-series` de acordo com a primeira série passada.
+        this._type = Object.values(PoChartType).includes(value) ? value : undefined;
+        this.rebuildComponentRef();
+    }
+    get type() {
+        return this._type;
+    }
+    /**
+     * @description
+     *
+     * Define os elementos do gráfico que serão criados dinamicamente.
+     */
+    set series(value) {
+        this._series = value || [];
+        if (Array.isArray(this._series) && this._series.length) {
+            this.setTypeDefault(this._series[0]);
+        }
+        else {
+            this.transformObjectToArrayObject(this.series);
+            this.rebuildComponentRef();
+        }
+    }
+    get series() {
+        return this._series;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define os nomes das categorias que serão plotadas no eixo X do gráfico caso seja do tipo `bar`, ou então nos eixos Y do grid de gráficos dos tipos `area`, `columnn` e `line`.
+     *
+     * > Gráficos do tipo `bar` dimensionam a área do gráfico de acordo com a largura do maior texto de categorias. No entanto, é uma boa prática optar por palavras curtas para que a leitura do gráfico não seja prejudicada.
+     *
+     * > Caso não seja especificado um valor para a categoria, será plotado um hífen na categoria referente a cada série.
+     */
+    set categories(value) {
+        if (Array.isArray(value)) {
+            this._categories = value;
+        }
+    }
+    get categories() {
+        return this._categories;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Objeto com as configurações usadas no `po-chart`.
+     *
+     * É possível, por exemplo, definir as configurações de exibição das legendas,
+     * configurar os eixos(*axis*) para os gráficos dos tipos `area`, `line`, `column` e `bar` da seguinte forma:
+     *
+     * ```
+     *  chartOptions: PoChartOptions = {
+     *    legend: true,
+     *    axis: {
+     *      minRange: 0,
+     *      maxRange: 100,
+     *      gridLines: 5,
+     *    },
+     *  };
+     * ```
+     */
+    set options(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._options = value;
+            if (this._options.hasOwnProperty('legend') && typeof this._options.legend === 'boolean') {
+                this.getSvgContainerSize();
+            }
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    get isTypeCircular() {
+        return this.defaultType === PoChartType.Pie || this.defaultType === PoChartType.Donut;
+    }
+    ngOnChanges(changes) {
+        const isArrayOfseries = Array.isArray(this.series) && this.series.length > 0;
+        if ((changes.series && isArrayOfseries) ||
+            (changes.type && isArrayOfseries) ||
+            (changes.categories && isArrayOfseries)) {
+            this.validateSerieAndAddType(this.series);
+        }
+        if ((changes.type && !this.isTypeCircular) || (changes.categories && !this.isTypeCircular)) {
+            this.svgContainerSize = {
+                ...this.svgContainerSize,
+                axisXLabelWidth: this.calculateAxisXLabelArea()
+            };
+        }
+    }
+    onSeriesClick(event) {
+        this.seriesClick.emit(event);
+    }
+    onSeriesHover(event) {
+        this.seriesHover.emit(event);
+    }
+    setDefaultHeight() {
+        return poChartDefaultHeight;
+    }
+    transformObjectToArrayObject(serie) {
+        this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [{ ...serie }] : [];
+    }
+    setTypeDefault(serie) {
+        const data = serie.data;
+        const serieType = Object.values(PoChartType).includes(serie.type) ? serie.type : undefined;
+        this.defaultType = serieType ? serieType : Array.isArray(data) ? PoChartType.Column : PoChartType.Pie;
+    }
+    validateSerieAndAddType(series) {
+        const filteredSeries = series.filter(serie => this.isTypeCircular ? typeof serie.data === 'number' : Array.isArray(serie.data));
+        this.chartSeries = this.appendType(this.appendColors(filteredSeries));
+    }
+    appendColors(series) {
+        return this.colorService.getColors(series);
+    }
+    appendType(series) {
+        return series.map((serie, index) => {
+            if (index === 0) {
+                this.chartType = Object.values(PoChartType).includes(serie.type)
+                    ? serie.type
+                    : this.type || this.defaultType;
+            }
+            return { ...serie, type: serie.type || this.chartType };
+        });
+    }
+}
+PoChartBaseComponent.ɵfac = function PoChartBaseComponent_Factory(t) { return new (t || PoChartBaseComponent)(i0.ɵɵdirectiveInject(i1.PoColorService)); };
+PoChartBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoChartBaseComponent, inputs: { title: ["p-title", "title"], height: ["p-height", "height"], type: ["p-type", "type"], series: ["p-series", "series"], categories: ["p-categories", "categories"], options: ["p-options", "options"] }, outputs: { seriesClick: "p-series-click", seriesHover: "p-series-hover" }, features: [i0.ɵɵNgOnChangesFeature] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.PoColorService }]; }, { title: [{
+            type: Input,
+            args: ['p-title']
+        }], seriesClick: [{
+            type: Output,
+            args: ['p-series-click']
+        }], seriesHover: [{
+            type: Output,
+            args: ['p-series-hover']
+        }], height: [{
+            type: Input,
+            args: ['p-height']
+        }], type: [{
+            type: Input,
+            args: ['p-type']
+        }], series: [{
+            type: Input,
+            args: ['p-series']
+        }], categories: [{
+            type: Input,
+            args: ['p-categories']
+        }], options: [{
+            type: Input,
+            args: ['p-options']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-chart-base.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/components/po-chart/po-chart-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Input, Output, Directive, OnChanges, SimpleChanges } from '@angular/core';\n\nimport { convertToInt, isTypeof } from '../../utils/util';\n\nimport { PoChartContainerSize } from './interfaces/po-chart-container-size.interface';\nimport { PoChartType } from './enums/po-chart-type.enum';\nimport { PoChartOptions } from './interfaces/po-chart-options.interface';\nimport { PoChartSerie } from './interfaces/po-chart-serie.interface';\nimport { PoColorService } from '../../services/po-color/po-color.service';\n\nconst poChartDefaultHeight = 400;\nconst poChartMinHeight = 200;\n\n/**\n * @description\n *\n * O `po-chart` é um componente para renderização de dados através de gráficos, com isso facilitando a compreensão e tornando a\n * visualização destes dados mais agradável.\n *\n * Através de suas principais propriedades é possível definir atributos, tais como tipo de gráfico, altura, título, cores customizadas, opções para os eixos, entre outros.\n *\n * O componente permite utilizar em conjunto séries do tipo linha e coluna.\n *\n * Além disso, também é possível definir uma ação que será executada ao clicar em determinado elemento do gráfico\n * e outra que será executada ao passar o *mouse* sobre o elemento.\n *\n * #### Guia de uso para Gráficos\n *\n * > Veja nosso [guia de uso para gráficos](/guides/guide-charts) para auxiliar na construção do seu gráfico,\n * informando em qual caso utilizar, o que devemos evitar e boas práticas relacionada a cores.\n */\n@Directive()\nexport abstract class PoChartBaseComponent implements OnChanges {\n  /** Define o título do gráfico. */\n  @Input('p-title') title?: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado quando o usuário clicar sobre um elemento do gráfico.\n   *\n   * O evento emitirá o seguinte parâmetro:\n   * - *donut* e *pie*: um objeto contendo a categoria e valor da série.\n   * - *area*, *line*, *column* e *bar*: um objeto contendo o nome da série, valor e categoria do eixo do gráfico.\n   */\n  @Output('p-series-click')\n  seriesClick = new EventEmitter<PoChartSerie>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado quando o usuário passar o *mouse* sobre um elemento do gráfico.\n   *\n   * O evento emitirá o seguinte parâmetro de acordo com o tipo de gráfico:\n   * - *donut* e *pie*: um objeto contendo a categoria e valor da série.\n   * - *area*, *line*, *column* e *bar*: um objeto contendo a categoria, valor da série e categoria do eixo do gráfico.\n   */\n  @Output('p-series-hover')\n  seriesHover = new EventEmitter<PoChartSerie>();\n\n  // manipulação das séries tratadas internamente para preservar 'p-series';\n  chartSeries: Array<PoChartSerie> = [];\n  chartType: PoChartType;\n  svgContainerSize: PoChartContainerSize;\n\n  private _options: PoChartOptions;\n  private _categories: Array<string>;\n  private _height: number;\n  private _series: Array<PoChartSerie>;\n  private _type: PoChartType;\n\n  private defaultType: PoChartType;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define a altura do gráfico.\n   *\n   * > O valor mínimo aceito nesta propriedade é 200.\n   *\n   * @default `400px`\n   */\n  @Input('p-height') set height(value: number) {\n    const intValue = convertToInt(value);\n    let height: number;\n\n    if (isTypeof(value, 'number')) {\n      height = intValue <= poChartMinHeight ? poChartMinHeight : intValue;\n    } else {\n      height = this.setDefaultHeight();\n    }\n\n    this._height = height;\n\n    this.getSvgContainerSize();\n    this.rebuildComponentRef();\n  }\n\n  get height(): number {\n    return this._height || this.setDefaultHeight();\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define o tipo de gráfico.\n   *\n   * É possível também combinar gráficos dos tipos linha e coluna. Para isso, opte pela declaração de `type` conforme a interface `PoChartSerie`.\n   *\n   * > Note que, se houver declaração de tipo de gráfico tanto em `p-type` quanto em `PochartSerie.type`, o valor `{ type }` da primeira série anulará o valor definido em `p-type`.\n   *\n   * Se não passado valor, o padrão será relativo à primeira série passada em `p-series`:\n   * - Se `p-series = [{ data: [1,2,3] }]`: será `PoChartType.Column`.\n   * - Se `p-series = [{ data: 1 }]`: será `PoChartType.Pie`.\n   *\n   * > Veja os valores válidos no *enum* `PoChartType`.\n   */\n  @Input('p-type') set type(value: PoChartType) {\n    // O Valor default definido em `p-series` de acordo com a primeira série passada.\n    this._type = (<any>Object).values(PoChartType).includes(value) ? value : undefined;\n\n    this.rebuildComponentRef();\n  }\n\n  get type(): PoChartType {\n    return this._type;\n  }\n\n  /**\n   * @description\n   *\n   * Define os elementos do gráfico que serão criados dinamicamente.\n   */\n  @Input('p-series') set series(value: Array<PoChartSerie>) {\n    this._series = value || [];\n\n    if (Array.isArray(this._series) && this._series.length) {\n      this.setTypeDefault(this._series[0]);\n    } else {\n      this.transformObjectToArrayObject(this.series);\n      this.rebuildComponentRef();\n    }\n  }\n\n  get series() {\n    return this._series;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define os nomes das categorias que serão plotadas no eixo X do gráfico caso seja do tipo `bar`, ou então nos eixos Y do grid de gráficos dos tipos `area`, `columnn` e `line`.\n   *\n   * > Gráficos do tipo `bar` dimensionam a área do gráfico de acordo com a largura do maior texto de categorias. No entanto, é uma boa prática optar por palavras curtas para que a leitura do gráfico não seja prejudicada.\n   *\n   * > Caso não seja especificado um valor para a categoria, será plotado um hífen na categoria referente a cada série.\n   */\n  @Input('p-categories') set categories(value: Array<string>) {\n    if (Array.isArray(value)) {\n      this._categories = value;\n    }\n  }\n\n  get categories() {\n    return this._categories;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Objeto com as configurações usadas no `po-chart`.\n   *\n   * É possível, por exemplo, definir as configurações de exibição das legendas,\n   * configurar os eixos(*axis*) para os gráficos dos tipos `area`, `line`, `column` e `bar` da seguinte forma:\n   *\n   * ```\n   *  chartOptions: PoChartOptions = {\n   *    legend: true,\n   *    axis: {\n   *      minRange: 0,\n   *      maxRange: 100,\n   *      gridLines: 5,\n   *    },\n   *  };\n   * ```\n   */\n  @Input('p-options') set options(value: PoChartOptions) {\n    if (value instanceof Object && !(value instanceof Array)) {\n      this._options = value;\n\n      if (this._options.hasOwnProperty('legend') && typeof this._options.legend === 'boolean') {\n        this.getSvgContainerSize();\n      }\n    }\n  }\n\n  get options() {\n    return this._options;\n  }\n\n  constructor(protected colorService: PoColorService) {}\n\n  get isTypeCircular() {\n    return this.defaultType === PoChartType.Pie || this.defaultType === PoChartType.Donut;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const isArrayOfseries = Array.isArray(this.series) && this.series.length > 0;\n\n    if (\n      (changes.series && isArrayOfseries) ||\n      (changes.type && isArrayOfseries) ||\n      (changes.categories && isArrayOfseries)\n    ) {\n      this.validateSerieAndAddType(this.series);\n    }\n\n    if ((changes.type && !this.isTypeCircular) || (changes.categories && !this.isTypeCircular)) {\n      this.svgContainerSize = {\n        ...this.svgContainerSize,\n        axisXLabelWidth: this.calculateAxisXLabelArea()\n      };\n    }\n  }\n\n  onSeriesClick(event: any): void {\n    this.seriesClick.emit(event);\n  }\n\n  onSeriesHover(event: any): void {\n    this.seriesHover.emit(event);\n  }\n\n  private setDefaultHeight() {\n    return poChartDefaultHeight;\n  }\n\n  private transformObjectToArrayObject(serie) {\n    this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [{ ...serie }] : [];\n  }\n\n  private setTypeDefault(serie: PoChartSerie) {\n    const data = serie.data;\n    const serieType = (<any>Object).values(PoChartType).includes(serie.type) ? serie.type : undefined;\n\n    this.defaultType = serieType ? serieType : Array.isArray(data) ? PoChartType.Column : PoChartType.Pie;\n  }\n\n  private validateSerieAndAddType(series: Array<PoChartSerie>): void {\n    const filteredSeries = series.filter(serie =>\n      this.isTypeCircular ? typeof serie.data === 'number' : Array.isArray(serie.data)\n    );\n\n    this.chartSeries = this.appendType(this.appendColors(filteredSeries));\n  }\n\n  private appendColors(series: Array<PoChartSerie>) {\n    return this.colorService.getColors<PoChartSerie>(series);\n  }\n\n  private appendType(series: Array<PoChartSerie>) {\n    return series.map((serie, index) => {\n      if (index === 0) {\n        this.chartType = (<any>Object).values(PoChartType).includes(serie.type)\n          ? serie.type\n          : this.type || this.defaultType;\n      }\n\n      return { ...serie, type: serie.type || this.chartType };\n    });\n  }\n\n  abstract rebuildComponentRef(): void;\n\n  // válido para gráficos do tipo circular e que será refatorado.\n  protected abstract getSvgContainerSize(): void;\n  protected abstract calculateAxisXLabelArea(): number;\n}\n"]}

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

@@ -0,0 +1,68 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const _c0 = ["po-chart-axis-label", ""];
+function PoChartAxisLabelComponent__svg_text_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "text", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r2 = ctx.$implicit;
+    i0.ɵɵattribute("x", item_r2.xCoordinate)("y", item_r2.yCoordinate);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", item_r2.label, " ");
+} }
+function PoChartAxisLabelComponent__svg_text_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "text", 3);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r3 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵclassProp("po-chart-centered-label", !ctx_r1.alignByTheCorners);
+    i0.ɵɵattribute("x", item_r3.xCoordinate)("y", item_r3.yCoordinate);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", item_r3.label, " ");
+} }
+export class PoChartAxisLabelComponent {
+    constructor() {
+        this.alignByTheCorners = false;
+    }
+    trackBy(index) {
+        return index;
+    }
+}
+PoChartAxisLabelComponent.ɵfac = function PoChartAxisLabelComponent_Factory(t) { return new (t || PoChartAxisLabelComponent)(); };
+PoChartAxisLabelComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartAxisLabelComponent, selectors: [["", "po-chart-axis-label", ""]], inputs: { alignByTheCorners: ["p-align-by-the-corners", "alignByTheCorners"], axisXLabelCoordinates: ["p-axis-x-label-coordinates", "axisXLabelCoordinates"], axisYLabelCoordinates: ["p-axis-y-label-coordinates", "axisYLabelCoordinates"], type: ["p-type", "type"] }, attrs: _c0, decls: 4, vars: 4, consts: [["class", "po-chart-axis-x-label", "dominant-baseline", "middle", 4, "ngFor", "ngForOf", "ngForTrackBy"], ["class", "po-chart-axis-y-label", 3, "po-chart-centered-label", 4, "ngFor", "ngForOf", "ngForTrackBy"], ["dominant-baseline", "middle", 1, "po-chart-axis-x-label"], [1, "po-chart-axis-y-label"]], template: function PoChartAxisLabelComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartAxisLabelComponent__svg_text_1_Template, 2, 3, "text", 0);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(2, "g");
+        i0.ɵɵtemplate(3, PoChartAxisLabelComponent__svg_text_3_Template, 2, 5, "text", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.axisXLabelCoordinates)("ngForTrackBy", ctx.trackBy);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngForOf", ctx.axisYLabelCoordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i1.NgForOf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartAxisLabelComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-axis-label]', template: "<svg:g>\n  <svg:text *ngFor=\"let item of axisXLabelCoordinates; trackBy: trackBy\"\n    class=\"po-chart-axis-x-label\" \n    dominant-baseline=\"middle\"\n    [attr.x]=\"item.xCoordinate\"\n    [attr.y]=\"item.yCoordinate\">\n    {{ item.label }}\n  </svg:text> \n</svg:g>\n\n<svg:g>\n  <svg:text *ngFor=\"let item of axisYLabelCoordinates; let first = first; let last = last; trackBy: trackBy\"\n    class=\"po-chart-axis-y-label\" \n    [class.po-chart-centered-label]=\"!alignByTheCorners\"\n    [attr.x]=\"item.xCoordinate\"\n    [attr.y]=\"item.yCoordinate\">\n    {{ item.label }}\n  </svg:text> \n</svg:g>" }]
+    }], function () { return []; }, { alignByTheCorners: [{
+            type: Input,
+            args: ['p-align-by-the-corners']
+        }], axisXLabelCoordinates: [{
+            type: Input,
+            args: ['p-axis-x-label-coordinates']
+        }], axisYLabelCoordinates: [{
+            type: Input,
+            args: ['p-axis-y-label-coordinates']
+        }], type: [{
+            type: Input,
+            args: ['p-type']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const _c0 = ["po-chart-axis-path", ""];
+function PoChartAxisPathComponent__svg_path_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "path", 1);
+} if (rf & 2) {
+    const item_r2 = ctx.$implicit;
+    i0.ɵɵattribute("d", item_r2.coordinates);
+} }
+function PoChartAxisPathComponent__svg_path_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "path", 1);
+} if (rf & 2) {
+    const item_r3 = ctx.$implicit;
+    i0.ɵɵattribute("d", item_r3.coordinates);
+} }
+export class PoChartAxisPathComponent {
+    constructor() { }
+    trackBy(index) {
+        return index;
+    }
+}
+PoChartAxisPathComponent.ɵfac = function PoChartAxisPathComponent_Factory(t) { return new (t || PoChartAxisPathComponent)(); };
+PoChartAxisPathComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoChartAxisPathComponent, selectors: [["", "po-chart-axis-path", ""]], inputs: { axisXCoordinates: ["p-axis-x-coordinates", "axisXCoordinates"], axisYCoordinates: ["p-axis-y-coordinates", "axisYCoordinates"] }, attrs: _c0, decls: 4, vars: 4, consts: [["class", "po-chart-axis-path", 4, "ngFor", "ngForOf", "ngForTrackBy"], [1, "po-chart-axis-path"]], template: function PoChartAxisPathComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "g");
+        i0.ɵɵtemplate(1, PoChartAxisPathComponent__svg_path_1_Template, 1, 1, "path", 0);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(2, "g");
+        i0.ɵɵtemplate(3, PoChartAxisPathComponent__svg_path_3_Template, 1, 1, "path", 0);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngForOf", ctx.axisXCoordinates)("ngForTrackBy", ctx.trackBy);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngForOf", ctx.axisYCoordinates)("ngForTrackBy", ctx.trackBy);
+    } }, directives: [i1.NgForOf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoChartAxisPathComponent, [{
+        type: Component,
+        args: [{ selector: '[po-chart-axis-path]', template: "<svg:g>\n  <svg:path *ngFor=\"let item of axisXCoordinates; trackBy: trackBy\"\n    class=\"po-chart-axis-path\" \n    [attr.d]=\"item.coordinates\">\n  </svg:path> \n</svg:g>\n\n<svg:g>\n  <svg:path *ngFor=\"let item of axisYCoordinates; trackBy: trackBy\"\n    class=\"po-chart-axis-path\" \n    [attr.d]=\"item.coordinates\">\n  </svg:path> \n</svg:g>" }]
+    }], function () { return []; }, { axisXCoordinates: [{
+            type: Input,
+            args: ['p-axis-x-coordinates']
+        }], axisYCoordinates: [{
+            type: Input,
+            args: ['p-axis-y-coordinates']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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