@po-ui/ng-components 5.21.0 → 5.22.3

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

@@ -1,244 +1,244 @@
-import { EventEmitter, Input, Output, Directive } from '@angular/core';
-import { convertToInt, isTypeof } from '../../utils/util';
-import { PoChartType } from './enums/po-chart-type.enum';
-import { PoColorService } 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 = Object.assign(Object.assign({}, this.svgContainerSize), { axisXLabelWidth: this.calculateAxisXLabelArea() });
-        }
-    }
-    onSeriesClick(event) {
-        this.seriesClick.emit(event);
-    }
-    onSeriesHover(event) {
-        this.seriesHover.emit(event);
-    }
-    setDefaultHeight() {
-        return this.type === PoChartType.Gauge ? poChartMinHeight : poChartDefaultHeight;
-    }
-    transformObjectToArrayObject(serie) {
-        this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [Object.assign({}, serie)] : [];
-    }
-    setTypeDefault(serie) {
-        var _a;
-        const data = (_a = serie.data) !== null && _a !== void 0 ? _a : serie.value;
-        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' || typeof serie.value === '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 Object.assign(Object.assign({}, serie), { type: serie.type || this.chartType });
-        });
-    }
-}
-PoChartBaseComponent.decorators = [
-    { type: Directive }
-];
-PoChartBaseComponent.ctorParameters = () => [
-    { type: PoColorService }
-];
-PoChartBaseComponent.propDecorators = {
-    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 { PoChartGaugeSerie } from './po-chart-types/po-chart-gauge/po-chart-gauge-series.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 | PoChartGaugeSerie>();\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 | PoChartGaugeSerie>();\n\n  // manipulação das séries tratadas internamente para preservar 'p-series';\n  chartSeries: Array<PoChartSerie | PoChartGaugeSerie> = [];\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> | PoChartGaugeSerie;\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> | PoChartGaugeSerie) {\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 as PoChartGaugeSerie);\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 as Array<PoChartSerie>);\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 this.type === PoChartType.Gauge ? poChartMinHeight : poChartDefaultHeight;\n  }\n\n  private transformObjectToArrayObject(serie: PoChartGaugeSerie) {\n    this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [{ ...serie }] : [];\n  }\n\n  private setTypeDefault(serie: PoChartSerie) {\n    const data = serie.data ?? serie.value;\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\n        ? typeof serie.data === 'number' || typeof serie.value === 'number'\n        : 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"]}
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { convertToInt, isTypeof } from '../../utils/util';
+import { PoChartType } from './enums/po-chart-type.enum';
+import { PoColorService } 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 = Object.assign(Object.assign({}, this.svgContainerSize), { axisXLabelWidth: this.calculateAxisXLabelArea() });
+        }
+    }
+    onSeriesClick(event) {
+        this.seriesClick.emit(event);
+    }
+    onSeriesHover(event) {
+        this.seriesHover.emit(event);
+    }
+    setDefaultHeight() {
+        return this.type === PoChartType.Gauge ? poChartMinHeight : poChartDefaultHeight;
+    }
+    transformObjectToArrayObject(serie) {
+        this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [Object.assign({}, serie)] : [];
+    }
+    setTypeDefault(serie) {
+        var _a;
+        const data = (_a = serie.data) !== null && _a !== void 0 ? _a : serie.value;
+        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' || typeof serie.value === '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 Object.assign(Object.assign({}, serie), { type: serie.type || this.chartType });
+        });
+    }
+}
+PoChartBaseComponent.decorators = [
+    { type: Directive }
+];
+PoChartBaseComponent.ctorParameters = () => [
+    { type: PoColorService }
+];
+PoChartBaseComponent.propDecorators = {
+    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":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAA4B,MAAM,eAAe,CAAC;AAEjG,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI1D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAE1E,MAAM,oBAAoB,GAAG,GAAG,CAAC;AACjC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,OAAgB,oBAAoB;IAoLxC,YAAsB,YAA4B;QAA5B,iBAAY,GAAZ,YAAY,CAAgB;QAhLlD;;;;;;;;;;WAUG;QAEH,gBAAW,GAAG,IAAI,YAAY,EAAoC,CAAC;QAEnE;;;;;;;;;;WAUG;QAEH,gBAAW,GAAG,IAAI,YAAY,EAAoC,CAAC;QAEnE,0EAA0E;QAC1E,gBAAW,GAA4C,EAAE,CAAC;IAmJL,CAAC;IAvItD;;;;;;;;;;OAUG;IACH,IAAuB,MAAM,CAAC,KAAa;QACzC,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,MAAc,CAAC;QAEnB,IAAI,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE;YAC7B,MAAM,GAAG,QAAQ,IAAI,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC;SACrE;aAAM;YACL,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;SAClC;QAED,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QAEtB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,IAAqB,IAAI,CAAC,KAAkB;QAC1C,iFAAiF;QACjF,IAAI,CAAC,KAAK,GAAS,MAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;QAEnF,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,IAAuB,MAAM,CAAC,KAA8C;QAC1E,IAAI,CAAC,OAAO,GAAG,KAAK,IAAI,EAAE,CAAC;QAE3B,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YACtD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;SACtC;aAAM;YACL,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,MAA2B,CAAC,CAAC;YACpE,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAC5B;IACH,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;;;;;;OAUG;IACH,IAA2B,UAAU,CAAC,KAAoB;QACxD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;SAC1B;IACH,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAwB,OAAO,CAAC,KAAqB;QACnD,IAAI,KAAK,YAAY,MAAM,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,EAAE;YACxD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YAEtB,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE;gBACvF,IAAI,CAAC,mBAAmB,EAAE,CAAC;aAC5B;SACF;IACH,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAID,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,GAAG,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,KAAK,CAAC;IACxF,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QAE7E,IACE,CAAC,OAAO,CAAC,MAAM,IAAI,eAAe,CAAC;YACnC,CAAC,OAAO,CAAC,IAAI,IAAI,eAAe,CAAC;YACjC,CAAC,OAAO,CAAC,UAAU,IAAI,eAAe,CAAC,EACvC;YACA,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,MAA6B,CAAC,CAAC;SAClE;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE;YAC1F,IAAI,CAAC,gBAAgB,mCAChB,IAAI,CAAC,gBAAgB,KACxB,eAAe,EAAE,IAAI,CAAC,uBAAuB,EAAE,GAChD,CAAC;SACH;IACH,CAAC;IAED,aAAa,CAAC,KAAU;QACtB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,aAAa,CAAC,KAAU;QACtB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEO,gBAAgB;QACtB,OAAO,IAAI,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,oBAAoB,CAAC;IACnF,CAAC;IAEO,4BAA4B,CAAC,KAAwB;QAC3D,IAAI,CAAC,WAAW,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,mBAAM,KAAK,EAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAClG,CAAC;IAEO,cAAc,CAAC,KAAmB;;QACxC,MAAM,IAAI,GAAG,MAAA,KAAK,CAAC,IAAI,mCAAI,KAAK,CAAC,KAAK,CAAC;QACvC,MAAM,SAAS,GAAS,MAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QAElG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC;IACxG,CAAC;IAEO,uBAAuB,CAAC,MAA2B;QACzD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC3C,IAAI,CAAC,cAAc;YACjB,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;YACnE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAC9B,CAAC;QAEF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC;IACxE,CAAC;IAEO,YAAY,CAAC,MAA2B;QAC9C,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS,CAAe,MAAM,CAAC,CAAC;IAC3D,CAAC;IAEO,UAAU,CAAC,MAA2B;QAC5C,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,KAAK,KAAK,CAAC,EAAE;gBACf,IAAI,CAAC,SAAS,GAAS,MAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC;oBACrE,CAAC,CAAC,KAAK,CAAC,IAAI;oBACZ,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC;aACnC;YAED,uCAAY,KAAK,KAAE,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,IAAG;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC;;;YA7PF,SAAS;;;YAvBD,cAAc;;;oBA0BpB,KAAK,SAAC,SAAS;0BAaf,MAAM,SAAC,gBAAgB;0BAcvB,MAAM,SAAC,gBAAgB;qBA2BvB,KAAK,SAAC,UAAU;mBAqChB,KAAK,SAAC,QAAQ;qBAgBd,KAAK,SAAC,UAAU;yBA0BhB,KAAK,SAAC,cAAc;sBA+BpB,KAAK,SAAC,WAAW","sourcesContent":["import { EventEmitter, Input, Output, Directive, OnChanges, SimpleChanges } from '@angular/core';\r\n\r\nimport { convertToInt, isTypeof } from '../../utils/util';\r\n\r\nimport { PoChartContainerSize } from './interfaces/po-chart-container-size.interface';\r\nimport { PoChartGaugeSerie } from './po-chart-types/po-chart-gauge/po-chart-gauge-series.interface';\r\nimport { PoChartType } from './enums/po-chart-type.enum';\r\nimport { PoChartOptions } from './interfaces/po-chart-options.interface';\r\nimport { PoChartSerie } from './interfaces/po-chart-serie.interface';\r\nimport { PoColorService } from '../../services/po-color/po-color.service';\r\n\r\nconst poChartDefaultHeight = 400;\r\nconst poChartMinHeight = 200;\r\n\r\n/**\r\n * @description\r\n *\r\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\r\n * visualização destes dados mais agradável.\r\n *\r\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.\r\n *\r\n * O componente permite utilizar em conjunto séries do tipo linha e coluna.\r\n *\r\n * Além disso, também é possível definir uma ação que será executada ao clicar em determinado elemento do gráfico\r\n * e outra que será executada ao passar o *mouse* sobre o elemento.\r\n *\r\n * #### Guia de uso para Gráficos\r\n *\r\n * > Veja nosso [guia de uso para gráficos](/guides/guide-charts) para auxiliar na construção do seu gráfico,\r\n * informando em qual caso utilizar, o que devemos evitar e boas práticas relacionada a cores.\r\n */\r\n@Directive()\r\nexport abstract class PoChartBaseComponent implements OnChanges {\r\n  /** Define o título do gráfico. */\r\n  @Input('p-title') title?: string;\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\n   * Evento executado quando o usuário clicar sobre um elemento do gráfico.\r\n   *\r\n   * O evento emitirá o seguinte parâmetro:\r\n   * - *donut* e *pie*: um objeto contendo a categoria e valor da série.\r\n   * - *area*, *line*, *column* e *bar*: um objeto contendo o nome da série, valor e categoria do eixo do gráfico.\r\n   */\r\n  @Output('p-series-click')\r\n  seriesClick = new EventEmitter<PoChartSerie | PoChartGaugeSerie>();\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\n   * Evento executado quando o usuário passar o *mouse* sobre um elemento do gráfico.\r\n   *\r\n   * O evento emitirá o seguinte parâmetro de acordo com o tipo de gráfico:\r\n   * - *donut* e *pie*: um objeto contendo a categoria e valor da série.\r\n   * - *area*, *line*, *column* e *bar*: um objeto contendo a categoria, valor da série e categoria do eixo do gráfico.\r\n   */\r\n  @Output('p-series-hover')\r\n  seriesHover = new EventEmitter<PoChartSerie | PoChartGaugeSerie>();\r\n\r\n  // manipulação das séries tratadas internamente para preservar 'p-series';\r\n  chartSeries: Array<PoChartSerie | PoChartGaugeSerie> = [];\r\n  chartType: PoChartType;\r\n  svgContainerSize: PoChartContainerSize;\r\n\r\n  private _options: PoChartOptions;\r\n  private _categories: Array<string>;\r\n  private _height: number;\r\n  private _series: Array<PoChartSerie> | PoChartGaugeSerie;\r\n  private _type: PoChartType;\r\n\r\n  private defaultType: PoChartType;\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\n   * Define a altura do gráfico.\r\n   *\r\n   * > O valor mínimo aceito nesta propriedade é 200.\r\n   *\r\n   * @default `400px`\r\n   */\r\n  @Input('p-height') set height(value: number) {\r\n    const intValue = convertToInt(value);\r\n    let height: number;\r\n\r\n    if (isTypeof(value, 'number')) {\r\n      height = intValue <= poChartMinHeight ? poChartMinHeight : intValue;\r\n    } else {\r\n      height = this.setDefaultHeight();\r\n    }\r\n\r\n    this._height = height;\r\n\r\n    this.getSvgContainerSize();\r\n    this.rebuildComponentRef();\r\n  }\r\n\r\n  get height(): number {\r\n    return this._height || this.setDefaultHeight();\r\n  }\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\n   * Define o tipo de gráfico.\r\n   *\r\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`.\r\n   *\r\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`.\r\n   *\r\n   * Se não passado valor, o padrão será relativo à primeira série passada em `p-series`:\r\n   * - Se `p-series = [{ data: [1,2,3] }]`: será `PoChartType.Column`.\r\n   * - Se `p-series = [{ data: 1 }]`: será `PoChartType.Pie`.\r\n   *\r\n   * > Veja os valores válidos no *enum* `PoChartType`.\r\n   */\r\n  @Input('p-type') set type(value: PoChartType) {\r\n    // O Valor default definido em `p-series` de acordo com a primeira série passada.\r\n    this._type = (<any>Object).values(PoChartType).includes(value) ? value : undefined;\r\n\r\n    this.rebuildComponentRef();\r\n  }\r\n\r\n  get type(): PoChartType {\r\n    return this._type;\r\n  }\r\n\r\n  /**\r\n   * @description\r\n   *\r\n   * Define os elementos do gráfico que serão criados dinamicamente.\r\n   */\r\n  @Input('p-series') set series(value: Array<PoChartSerie> | PoChartGaugeSerie) {\r\n    this._series = value || [];\r\n\r\n    if (Array.isArray(this._series) && this._series.length) {\r\n      this.setTypeDefault(this._series[0]);\r\n    } else {\r\n      this.transformObjectToArrayObject(this.series as PoChartGaugeSerie);\r\n      this.rebuildComponentRef();\r\n    }\r\n  }\r\n\r\n  get series() {\r\n    return this._series;\r\n  }\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\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`.\r\n   *\r\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.\r\n   *\r\n   * > Caso não seja especificado um valor para a categoria, será plotado um hífen na categoria referente a cada série.\r\n   */\r\n  @Input('p-categories') set categories(value: Array<string>) {\r\n    if (Array.isArray(value)) {\r\n      this._categories = value;\r\n    }\r\n  }\r\n\r\n  get categories() {\r\n    return this._categories;\r\n  }\r\n\r\n  /**\r\n   * @optional\r\n   *\r\n   * @description\r\n   *\r\n   * Objeto com as configurações usadas no `po-chart`.\r\n   *\r\n   * É possível, por exemplo, definir as configurações de exibição das legendas,\r\n   * configurar os eixos(*axis*) para os gráficos dos tipos `area`, `line`, `column` e `bar` da seguinte forma:\r\n   *\r\n   * ```\r\n   *  chartOptions: PoChartOptions = {\r\n   *    legend: true,\r\n   *    axis: {\r\n   *      minRange: 0,\r\n   *      maxRange: 100,\r\n   *      gridLines: 5,\r\n   *    },\r\n   *  };\r\n   * ```\r\n   */\r\n  @Input('p-options') set options(value: PoChartOptions) {\r\n    if (value instanceof Object && !(value instanceof Array)) {\r\n      this._options = value;\r\n\r\n      if (this._options.hasOwnProperty('legend') && typeof this._options.legend === 'boolean') {\r\n        this.getSvgContainerSize();\r\n      }\r\n    }\r\n  }\r\n\r\n  get options() {\r\n    return this._options;\r\n  }\r\n\r\n  constructor(protected colorService: PoColorService) {}\r\n\r\n  get isTypeCircular() {\r\n    return this.defaultType === PoChartType.Pie || this.defaultType === PoChartType.Donut;\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    const isArrayOfseries = Array.isArray(this.series) && this.series.length > 0;\r\n\r\n    if (\r\n      (changes.series && isArrayOfseries) ||\r\n      (changes.type && isArrayOfseries) ||\r\n      (changes.categories && isArrayOfseries)\r\n    ) {\r\n      this.validateSerieAndAddType(this.series as Array<PoChartSerie>);\r\n    }\r\n\r\n    if ((changes.type && !this.isTypeCircular) || (changes.categories && !this.isTypeCircular)) {\r\n      this.svgContainerSize = {\r\n        ...this.svgContainerSize,\r\n        axisXLabelWidth: this.calculateAxisXLabelArea()\r\n      };\r\n    }\r\n  }\r\n\r\n  onSeriesClick(event: any): void {\r\n    this.seriesClick.emit(event);\r\n  }\r\n\r\n  onSeriesHover(event: any): void {\r\n    this.seriesHover.emit(event);\r\n  }\r\n\r\n  private setDefaultHeight() {\r\n    return this.type === PoChartType.Gauge ? poChartMinHeight : poChartDefaultHeight;\r\n  }\r\n\r\n  private transformObjectToArrayObject(serie: PoChartGaugeSerie) {\r\n    this.chartSeries = typeof serie === 'object' && Object.keys(serie).length ? [{ ...serie }] : [];\r\n  }\r\n\r\n  private setTypeDefault(serie: PoChartSerie) {\r\n    const data = serie.data ?? serie.value;\r\n    const serieType = (<any>Object).values(PoChartType).includes(serie.type) ? serie.type : undefined;\r\n\r\n    this.defaultType = serieType ? serieType : Array.isArray(data) ? PoChartType.Column : PoChartType.Pie;\r\n  }\r\n\r\n  private validateSerieAndAddType(series: Array<PoChartSerie>): void {\r\n    const filteredSeries = series.filter(serie =>\r\n      this.isTypeCircular\r\n        ? typeof serie.data === 'number' || typeof serie.value === 'number'\r\n        : Array.isArray(serie.data)\r\n    );\r\n\r\n    this.chartSeries = this.appendType(this.appendColors(filteredSeries));\r\n  }\r\n\r\n  private appendColors(series: Array<PoChartSerie>) {\r\n    return this.colorService.getColors<PoChartSerie>(series);\r\n  }\r\n\r\n  private appendType(series: Array<PoChartSerie>) {\r\n    return series.map((serie, index) => {\r\n      if (index === 0) {\r\n        this.chartType = (<any>Object).values(PoChartType).includes(serie.type)\r\n          ? serie.type\r\n          : this.type || this.defaultType;\r\n      }\r\n\r\n      return { ...serie, type: serie.type || this.chartType };\r\n    });\r\n  }\r\n\r\n  abstract rebuildComponentRef(): void;\r\n\r\n  // válido para gráficos do tipo circular e que será refatorado.\r\n  protected abstract getSvgContainerSize(): void;\r\n  protected abstract calculateAxisXLabelArea(): number;\r\n}\r\n"]}

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

@@ -1,23 +1,23 @@
-import { Component, Input } from '@angular/core';
-export class PoChartAxisLabelComponent {
-    constructor() {
-        this.alignByTheCorners = false;
-    }
-    trackBy(index) {
-        return index;
-    }
-}
-PoChartAxisLabelComponent.decorators = [
-    { 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>"
-            },] }
-];
-PoChartAxisLabelComponent.ctorParameters = () => [];
-PoChartAxisLabelComponent.propDecorators = {
-    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtYXhpcy1sYWJlbC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvcG8tY2hhcnQtY29udGFpbmVyL3BvLWNoYXJ0LWF4aXMvcG8tY2hhcnQtYXhpcy1sYWJlbC9wby1jaGFydC1heGlzLWxhYmVsLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVNqRCxNQUFNLE9BQU8seUJBQXlCO0lBU3BDO1FBUmlDLHNCQUFpQixHQUFZLEtBQUssQ0FBQztJQVFyRCxDQUFDO0lBRWhCLE9BQU8sQ0FBQyxLQUFLO1FBQ1gsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDOzs7WUFqQkYsU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSx1QkFBdUI7Z0JBQ2pDLGtuQkFBa0Q7YUFDbkQ7Ozs7Z0NBRUUsS0FBSyxTQUFDLHdCQUF3QjtvQ0FFOUIsS0FBSyxTQUFDLDRCQUE0QjtvQ0FFbEMsS0FBSyxTQUFDLDRCQUE0QjttQkFFbEMsS0FBSyxTQUFDLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBvQ2hhcnRUeXBlIH0gZnJvbSAnLi4vLi4vLi4vZW51bXMvcG8tY2hhcnQtdHlwZS5lbnVtJztcbmltcG9ydCB7IFBvQ2hhcnRMYWJlbENvb3JkaW5hdGVzIH0gZnJvbSAnLi4vLi4vLi4vaW50ZXJmYWNlcy9wby1jaGFydC1sYWJlbC1jb29yZGluYXRlcy5pbnRlcmZhY2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdbcG8tY2hhcnQtYXhpcy1sYWJlbF0nLFxuICB0ZW1wbGF0ZVVybDogJy4vcG8tY2hhcnQtYXhpcy1sYWJlbC5jb21wb25lbnQuc3ZnJ1xufSlcbmV4cG9ydCBjbGFzcyBQb0NoYXJ0QXhpc0xhYmVsQ29tcG9uZW50IHtcbiAgQElucHV0KCdwLWFsaWduLWJ5LXRoZS1jb3JuZXJzJykgYWxpZ25CeVRoZUNvcm5lcnM6IGJvb2xlYW4gPSBmYWxzZTtcblxuICBASW5wdXQoJ3AtYXhpcy14LWxhYmVsLWNvb3JkaW5hdGVzJykgYXhpc1hMYWJlbENvb3JkaW5hdGVzOiBBcnJheTxQb0NoYXJ0TGFiZWxDb29yZGluYXRlcz47XG5cbiAgQElucHV0KCdwLWF4aXMteS1sYWJlbC1jb29yZGluYXRlcycpIGF4aXNZTGFiZWxDb29yZGluYXRlczogQXJyYXk8UG9DaGFydExhYmVsQ29vcmRpbmF0ZXM+O1xuXG4gIEBJbnB1dCgncC10eXBlJykgdHlwZTogUG9DaGFydFR5cGU7XG5cbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIHRyYWNrQnkoaW5kZXgpIHtcbiAgICByZXR1cm4gaW5kZXg7XG4gIH1cbn1cbiJdfQ==
+import { Component, Input } from '@angular/core';
+export class PoChartAxisLabelComponent {
+    constructor() {
+        this.alignByTheCorners = false;
+    }
+    trackBy(index) {
+        return index;
+    }
+}
+PoChartAxisLabelComponent.decorators = [
+    { type: Component, args: [{
+                selector: '[po-chart-axis-label]',
+                template: "<svg:g>\r\n  <svg:text *ngFor=\"let item of axisXLabelCoordinates; trackBy: trackBy\"\r\n    class=\"po-chart-axis-x-label\" \r\n    dominant-baseline=\"middle\"\r\n    [attr.x]=\"item.xCoordinate\"\r\n    [attr.y]=\"item.yCoordinate\">\r\n    {{ item.label }}\r\n  </svg:text> \r\n</svg:g>\r\n\r\n<svg:g>\r\n  <svg:text *ngFor=\"let item of axisYLabelCoordinates; let first = first; let last = last; trackBy: trackBy\"\r\n    class=\"po-chart-axis-y-label\" \r\n    [class.po-chart-centered-label]=\"!alignByTheCorners\"\r\n    [attr.x]=\"item.xCoordinate\"\r\n    [attr.y]=\"item.yCoordinate\">\r\n    {{ item.label }}\r\n  </svg:text> \r\n</svg:g>"
+            },] }
+];
+PoChartAxisLabelComponent.ctorParameters = () => [];
+PoChartAxisLabelComponent.propDecorators = {
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tY2hhcnQtYXhpcy1sYWJlbC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2NvbXBvbmVudHMvcG8tY2hhcnQvcG8tY2hhcnQtY29udGFpbmVyL3BvLWNoYXJ0LWF4aXMvcG8tY2hhcnQtYXhpcy1sYWJlbC9wby1jaGFydC1heGlzLWxhYmVsLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVNqRCxNQUFNLE9BQU8seUJBQXlCO0lBU3BDO1FBUmlDLHNCQUFpQixHQUFZLEtBQUssQ0FBQztJQVFyRCxDQUFDO0lBRWhCLE9BQU8sQ0FBQyxLQUFLO1FBQ1gsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDOzs7WUFqQkYsU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSx1QkFBdUI7Z0JBQ2pDLHNwQkFBa0Q7YUFDbkQ7Ozs7Z0NBRUUsS0FBSyxTQUFDLHdCQUF3QjtvQ0FFOUIsS0FBSyxTQUFDLDRCQUE0QjtvQ0FFbEMsS0FBSyxTQUFDLDRCQUE0QjttQkFFbEMsS0FBSyxTQUFDLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5pbXBvcnQgeyBQb0NoYXJ0VHlwZSB9IGZyb20gJy4uLy4uLy4uL2VudW1zL3BvLWNoYXJ0LXR5cGUuZW51bSc7XHJcbmltcG9ydCB7IFBvQ2hhcnRMYWJlbENvb3JkaW5hdGVzIH0gZnJvbSAnLi4vLi4vLi4vaW50ZXJmYWNlcy9wby1jaGFydC1sYWJlbC1jb29yZGluYXRlcy5pbnRlcmZhY2UnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6ICdbcG8tY2hhcnQtYXhpcy1sYWJlbF0nLFxyXG4gIHRlbXBsYXRlVXJsOiAnLi9wby1jaGFydC1heGlzLWxhYmVsLmNvbXBvbmVudC5zdmcnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBQb0NoYXJ0QXhpc0xhYmVsQ29tcG9uZW50IHtcclxuICBASW5wdXQoJ3AtYWxpZ24tYnktdGhlLWNvcm5lcnMnKSBhbGlnbkJ5VGhlQ29ybmVyczogYm9vbGVhbiA9IGZhbHNlO1xyXG5cclxuICBASW5wdXQoJ3AtYXhpcy14LWxhYmVsLWNvb3JkaW5hdGVzJykgYXhpc1hMYWJlbENvb3JkaW5hdGVzOiBBcnJheTxQb0NoYXJ0TGFiZWxDb29yZGluYXRlcz47XHJcblxyXG4gIEBJbnB1dCgncC1heGlzLXktbGFiZWwtY29vcmRpbmF0ZXMnKSBheGlzWUxhYmVsQ29vcmRpbmF0ZXM6IEFycmF5PFBvQ2hhcnRMYWJlbENvb3JkaW5hdGVzPjtcclxuXHJcbiAgQElucHV0KCdwLXR5cGUnKSB0eXBlOiBQb0NoYXJ0VHlwZTtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7fVxyXG5cclxuICB0cmFja0J5KGluZGV4KSB7XHJcbiAgICByZXR1cm4gaW5kZXg7XHJcbiAgfVxyXG59XHJcbiJdfQ==