@esfaenza/es-charts 13.1.4 → 13.1.7

package/esm2020/lib/services/Vertical2DChartService.mjs

@@ -0,0 +1,160 @@
+import * as am4core from "@amcharts/amcharts4/core";
+import * as am4charts from "@amcharts/amcharts4/charts";
+/**
+ * Classe il cui unico scopo è gestire il setup e rendering di un Vertical2DChart
+ */
+export class Vertical2DChartService {
+    /** @ignore */
+    constructor(Adapter) {
+        this.Adapter = Adapter;
+        /** @ignore */
+        this.DefaultGroupPaddingPercentage = 5;
+        /** @ignore */
+        this.dangerZone = 50;
+        /** @ignore */
+        this.LabelWidth = 150;
+        /** @ignore */
+        this.LabelRightWhenCompressed = 20;
+        /** @ignore */
+        this.LabelTopWhenCompressed = -5;
+        /** @ignore */
+        this.DefaultColumnWidthPercentage = 85;
+    }
+    /**
+     * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un Vertical2DChart
+     */
+    graphicate(data, settings) {
+        if (settings.Timeline) {
+            console.error("Timeline not supported for vertical chart");
+            return null;
+        }
+        //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...
+        am4core.options.autoDispose = true;
+        this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);
+        let ChartInstanceCasted = this.ChartInstance;
+        if (settings.Legend) {
+            ChartInstanceCasted.legend = new am4charts.Legend();
+            ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';
+            ChartInstanceCasted.legend.itemContainers.template.tooltipText = "{category}";
+            if (settings.LegendPadding) {
+                let template = this.ChartInstance.legend.itemContainers.template;
+                template.paddingTop = settings.LegendPadding.top ?? 0;
+                template.paddingBottom = settings.LegendPadding.bottom ?? 0;
+                template.paddingLeft = settings.LegendPadding.left ?? 0;
+                template.paddingRight = settings.LegendPadding.right ?? 0;
+            }
+        }
+        let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());
+        if (settings.YAxisTitle) {
+            yAxis.title.text = settings.YAxisTitle;
+            yAxis.title.fontWeight = "bold";
+        }
+        let categoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis());
+        if (settings.XAxisTitle) {
+            categoryAxis.title.text = settings.XAxisTitle;
+            categoryAxis.title.fontWeight = "bold";
+        }
+        yAxis.min = 0;
+        categoryAxis.dataFields.category = 'key';
+        categoryAxis.renderer.cellStartLocation = am4core.percent(settings.GroupPaddingPercentage ?? this.DefaultGroupPaddingPercentage).value;
+        categoryAxis.renderer.cellEndLocation = am4core.percent(100 - (settings.GroupPaddingPercentage ?? this.DefaultGroupPaddingPercentage)).value;
+        categoryAxis.renderer.grid.template.location = 0;
+        categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;
+        let label = categoryAxis.renderer.labels.template;
+        label.truncate = true;
+        label.maxWidth = settings.LabelWidth ?? this.LabelWidth;
+        label.tooltipText = "{category}";
+        if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {
+            categoryAxis.events.on("sizechanged", (ev) => {
+                let axis = ev.target;
+                var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);
+                if (cellWidth < axis.renderer.labels.template.maxWidth) {
+                    let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);
+                    axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;
+                    axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;
+                    axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;
+                    axis.renderer.labels.template.horizontalCenter = "right";
+                    axis.renderer.labels.template.verticalCenter = "middle";
+                }
+                else {
+                    axis.renderer.labels.template.rotation = 0;
+                    axis.renderer.labels.template.dx = 0;
+                    axis.renderer.labels.template.dy = 0;
+                    axis.renderer.labels.template.horizontalCenter = "middle";
+                    axis.renderer.labels.template.verticalCenter = "top";
+                }
+            });
+        }
+        let dataPreConverted = this.Adapter ? this.Adapter.adaptDataForVertical2DChart(data) : data;
+        let dataConverted = [];
+        for (let i = 0; i < dataPreConverted.groups.length; i++) {
+            let item = dataPreConverted.groups[i];
+            let obj = { key: item.name };
+            for (let p = 0; p < item.values.length; p++) {
+                let value = item.values[p];
+                obj[value.k] = value.v;
+            }
+            dataConverted.push(obj);
+        }
+        ChartInstanceCasted.data = dataConverted;
+        if (dataPreConverted.colorInfos)
+            ChartInstanceCasted.colors.list = dataPreConverted.colorInfos.map(c => am4core.color(c.color));
+        //Prendo la prima categoria e mi baso sulle proprietà per dfeinire le serie
+        for (let prop in dataConverted[0])
+            if (prop !== "key")
+                this.createSeries(ChartInstanceCasted, settings, prop, prop);
+        return this;
+    }
+    /** @ignore */
+    refreshData(data) {
+        //TODO:IMPL
+    }
+    /** @ignore */
+    createSeries(chart, settings, value, name) {
+        let series = chart.series.push(new am4charts.ColumnSeries());
+        series.dataFields.valueY = value;
+        series.dataFields.categoryX = 'key';
+        series.name = name;
+        series.columns.template.tooltipText = "{name} {categoryX}: [bold]{valueY}[/]";
+        series.columns.template.fillOpacity = .8;
+        series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);
+        series.events.on("hidden", () => this.arrangeColumns);
+        series.events.on("shown", () => this.arrangeColumns);
+        return series;
+    }
+    /** @ignore */
+    arrangeColumns() {
+        let ChartInstanceCasted = this.ChartInstance;
+        let series = ChartInstanceCasted.series.getIndex(0);
+        let xAxis = ChartInstanceCasted.xAxes.getIndex(0);
+        let w = 1 - xAxis.renderer.cellStartLocation - (1 - xAxis.renderer.cellEndLocation);
+        if (series.dataItems.length > 1) {
+            let x0 = xAxis.getX(series.dataItems.getIndex(0), "categoryX");
+            let x1 = xAxis.getX(series.dataItems.getIndex(1), "categoryX");
+            let delta = ((x1 - x0) / ChartInstanceCasted.series.length) * w;
+            if (am4core.isNumber(delta)) {
+                let middle = ChartInstanceCasted.series.length / 2;
+                let newIndex = 0;
+                ChartInstanceCasted.series.each((series) => {
+                    if (!series.isHidden && !series.isHiding) {
+                        series.dummyData = newIndex;
+                        newIndex++;
+                    }
+                    else {
+                        series.dummyData = ChartInstanceCasted.series.indexOf(series);
+                    }
+                });
+                let visibleCount = newIndex;
+                let newMiddle = visibleCount / 2;
+                ChartInstanceCasted.series.each((series) => {
+                    let trueIndex = ChartInstanceCasted.series.indexOf(series);
+                    let newIndex = series.dummyData;
+                    let dx = (newIndex - trueIndex + middle - newMiddle) * delta;
+                    series.animate({ property: "dx", to: dx }, series.interpolationDuration, series.interpolationEasing);
+                    series.bulletsContainer.animate({ property: "dx", to: dx }, series.interpolationDuration, series.interpolationEasing);
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Vertical2DChartService.js","sourceRoot":"","sources":["../../../../../projects/es-charts/src/lib/services/Vertical2DChartService.ts"],"names":[],"mappings":"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","sourcesContent":["import { IBaseService } from './base/IBaseService';\r\nimport { BaseAdapter } from '../adapters/BaseAdapter';\r\nimport { Vertical2DChartData } from '../models/data/Vertical2DChartData';\r\nimport { Vertical2DChartSettings } from '../models/settings/Vertical2DChartSettings';\r\n\r\nimport * as am4core from \"@amcharts/amcharts4/core\";\r\nimport * as am4charts from \"@amcharts/amcharts4/charts\";\r\n\r\n/**\r\n * Classe il cui unico scopo è gestire il setup e rendering di un Vertical2DChart\r\n */\r\nexport class Vertical2DChartService implements IBaseService<am4charts.XYChart>{\r\n  /** @ignore */\r\n  public ChartInstance: am4charts.XYChart;\r\n  /** @ignore */\r\n  private DefaultGroupPaddingPercentage: number = 5;\r\n  /** @ignore */\r\n  private dangerZone: number = 50;\r\n  /** @ignore */\r\n  private LabelWidth: number = 150;\r\n  /** @ignore */\r\n  private LabelRightWhenCompressed: number = 20;\r\n  /** @ignore */\r\n  private LabelTopWhenCompressed: number = -5;\r\n  /** @ignore */\r\n  private DefaultColumnWidthPercentage: number = 85;\r\n\r\n  /** @ignore */\r\n  constructor(public Adapter: BaseAdapter) { }\r\n\r\n  /**\r\n   * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un Vertical2DChart\r\n   */\r\n  public graphicate(data: Vertical2DChartData | any, settings: Vertical2DChartSettings): IBaseService<am4charts.XYChart> {\r\n\r\n    if (settings.Timeline) {\r\n      console.error(\"Timeline not supported for vertical chart\");\r\n      return null;\r\n    }\r\n\r\n    //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...\r\n    am4core.options.autoDispose = true;\r\n\r\n    this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);\r\n    let ChartInstanceCasted = <am4charts.XYChart>this.ChartInstance;\r\n\r\n    if (settings.Legend) {\r\n      ChartInstanceCasted.legend = new am4charts.Legend();\r\n      ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';\r\n      ChartInstanceCasted.legend.itemContainers.template.tooltipText = \"{category}\";\r\n      \r\n      if (settings.LegendPadding) {\r\n        let template = this.ChartInstance.legend.itemContainers.template;\r\n        template.paddingTop = settings.LegendPadding.top ?? 0;\r\n        template.paddingBottom = settings.LegendPadding.bottom ?? 0;\r\n        template.paddingLeft = settings.LegendPadding.left ?? 0;\r\n        template.paddingRight = settings.LegendPadding.right ?? 0;\r\n      }\r\n    }\r\n\r\n    let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());\r\n    if (settings.YAxisTitle) {\r\n      yAxis.title.text = settings.YAxisTitle\r\n      yAxis.title.fontWeight = \"bold\";\r\n    }\r\n    let categoryAxis: am4charts.CategoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis())\r\n    if (settings.XAxisTitle) {\r\n      categoryAxis.title.text = settings.XAxisTitle\r\n      categoryAxis.title.fontWeight = \"bold\";\r\n    }\r\n\r\n    yAxis.min = 0;\r\n    categoryAxis.dataFields.category = 'key'\r\n    categoryAxis.renderer.cellStartLocation = am4core.percent(settings.GroupPaddingPercentage ?? this.DefaultGroupPaddingPercentage).value\r\n    categoryAxis.renderer.cellEndLocation = am4core.percent(100 - (settings.GroupPaddingPercentage ?? this.DefaultGroupPaddingPercentage)).value\r\n    categoryAxis.renderer.grid.template.location = 0;\r\n    categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;\r\n\r\n    let label = categoryAxis.renderer.labels.template;\r\n    label.truncate = true;\r\n    label.maxWidth = settings.LabelWidth ?? this.LabelWidth;\r\n    label.tooltipText = \"{category}\";\r\n\r\n    if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {\r\n      categoryAxis.events.on(\"sizechanged\", (ev) => {\r\n        let axis = ev.target;\r\n        var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);\r\n        if (cellWidth < axis.renderer.labels.template.maxWidth) {\r\n          let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);\r\n          axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;\r\n          axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;\r\n          axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;\r\n          axis.renderer.labels.template.horizontalCenter = \"right\";\r\n          axis.renderer.labels.template.verticalCenter = \"middle\";\r\n        }\r\n        else {\r\n          axis.renderer.labels.template.rotation = 0;\r\n          axis.renderer.labels.template.dx = 0;\r\n          axis.renderer.labels.template.dy = 0;\r\n          axis.renderer.labels.template.horizontalCenter = \"middle\";\r\n          axis.renderer.labels.template.verticalCenter = \"top\";\r\n        }\r\n      });\r\n    }\r\n\r\n    let dataPreConverted: Vertical2DChartData = this.Adapter ? this.Adapter.adaptDataForVertical2DChart(data) : data;\r\n\r\n    let dataConverted = [];\r\n    for (let i = 0; i < dataPreConverted.groups.length; i++) {\r\n      let item = dataPreConverted.groups[i];\r\n      let obj = { key: item.name };\r\n      for (let p = 0; p < item.values.length; p++) {\r\n        let value = item.values[p];\r\n        obj[value.k] = value.v;\r\n      }\r\n      dataConverted.push(obj);\r\n    }\r\n\r\n    ChartInstanceCasted.data = dataConverted;\r\n    if (dataPreConverted.colorInfos)\r\n      ChartInstanceCasted.colors.list = dataPreConverted.colorInfos.map(c => am4core.color(c.color));\r\n\r\n    //Prendo la prima categoria e mi baso sulle proprietà per dfeinire le serie\r\n    for (let prop in dataConverted[0])\r\n      if (prop !== \"key\")\r\n        this.createSeries(ChartInstanceCasted, settings, prop, prop);\r\n\r\n    return this;\r\n  }\r\n\r\n  /** @ignore */\r\n  public refreshData(data: Vertical2DChartData | any) {\r\n    //TODO:IMPL\r\n  }\r\n\r\n  /** @ignore */\r\n  private createSeries(chart, settings: Vertical2DChartSettings, value, name) {\r\n    let series: am4charts.ColumnSeries = chart.series.push(new am4charts.ColumnSeries())\r\n    series.dataFields.valueY = value;\r\n    series.dataFields.categoryX = 'key';\r\n    series.name = name;\r\n    series.columns.template.tooltipText = \"{name} {categoryX}: [bold]{valueY}[/]\";\r\n    series.columns.template.fillOpacity = .8;\r\n    series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);\r\n\r\n    series.events.on(\"hidden\", () => this.arrangeColumns);\r\n    series.events.on(\"shown\", () => this.arrangeColumns);\r\n\r\n    return series;\r\n  }\r\n\r\n  /** @ignore */\r\n  private arrangeColumns() {\r\n    let ChartInstanceCasted = <am4charts.XYChart>this.ChartInstance;\r\n    let series = ChartInstanceCasted.series.getIndex(0);\r\n    let xAxis = ChartInstanceCasted.xAxes.getIndex(0);\r\n\r\n    let w = 1 - xAxis.renderer.cellStartLocation - (1 - xAxis.renderer.cellEndLocation);\r\n    if (series.dataItems.length > 1) {\r\n      let x0 = xAxis.getX(series.dataItems.getIndex(0), \"categoryX\");\r\n      let x1 = xAxis.getX(series.dataItems.getIndex(1), \"categoryX\");\r\n      let delta = ((x1 - x0) / ChartInstanceCasted.series.length) * w;\r\n      if (am4core.isNumber(delta)) {\r\n        let middle = ChartInstanceCasted.series.length / 2;\r\n\r\n        let newIndex = 0;\r\n        ChartInstanceCasted.series.each((series) => {\r\n          if (!series.isHidden && !series.isHiding) {\r\n            series.dummyData = newIndex;\r\n            newIndex++;\r\n          }\r\n          else {\r\n            series.dummyData = ChartInstanceCasted.series.indexOf(series);\r\n          }\r\n        })\r\n        let visibleCount = newIndex;\r\n        let newMiddle = visibleCount / 2;\r\n\r\n        ChartInstanceCasted.series.each((series) => {\r\n          let trueIndex = ChartInstanceCasted.series.indexOf(series);\r\n          let newIndex = series.dummyData;\r\n\r\n          let dx = (newIndex - trueIndex + middle - newMiddle) * delta\r\n\r\n          series.animate({ property: \"dx\", to: dx }, series.interpolationDuration, series.interpolationEasing);\r\n          series.bulletsContainer.animate({ property: \"dx\", to: dx }, series.interpolationDuration, series.interpolationEasing);\r\n        })\r\n      }\r\n    }\r\n  }\r\n}"]}

package/esm2020/lib/services/VerticalChartService.mjs

@@ -0,0 +1,103 @@
+import * as am4core from "@amcharts/amcharts4/core";
+import * as am4charts from "@amcharts/amcharts4/charts";
+/**
+ * Classe il cui unico scopo è gestire il setup e rendering di un VerticalChart
+ */
+export class VerticalChartService {
+    /** @ignore */
+    constructor(Adapter) {
+        this.Adapter = Adapter;
+        /** @ignore */
+        this.dangerZone = 50;
+        /** @ignore */
+        this.LabelWidth = 150;
+        /** @ignore */
+        this.LabelRightWhenCompressed = 20;
+        /** @ignore */
+        this.LabelTopWhenCompressed = -5;
+        /** @ignore */
+        this.DefaultColumnWidthPercentage = 85;
+    }
+    /**
+     * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un VerticalChart
+     */
+    graphicate(data, settings) {
+        if (settings.Timeline) {
+            console.error("Timeline not supported for vertical chart");
+            return null;
+        }
+        //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...
+        am4core.options.autoDispose = true;
+        this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);
+        let ChartInstanceCasted = this.ChartInstance;
+        let dataConverted = this.Adapter ? this.Adapter.adaptDataForVerticalChart(data) : data;
+        ChartInstanceCasted.data = dataConverted.values;
+        if (settings.Legend) {
+            ChartInstanceCasted.legend = new am4charts.Legend();
+            ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';
+            ChartInstanceCasted.legend.itemContainers.template.tooltipText = "{category}";
+            if (settings.LegendPadding) {
+                let template = this.ChartInstance.legend.itemContainers.template;
+                template.paddingTop = settings.LegendPadding.top ?? 0;
+                template.paddingBottom = settings.LegendPadding.bottom ?? 0;
+                template.paddingLeft = settings.LegendPadding.left ?? 0;
+                template.paddingRight = settings.LegendPadding.right ?? 0;
+            }
+        }
+        let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());
+        if (settings.YAxisTitle) {
+            yAxis.title.text = settings.YAxisTitle;
+            yAxis.title.fontWeight = "bold";
+        }
+        let categoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis());
+        if (settings.XAxisTitle) {
+            categoryAxis.title.text = settings.XAxisTitle;
+            categoryAxis.title.fontWeight = "bold";
+        }
+        categoryAxis.dataFields.category = "k";
+        categoryAxis.renderer.grid.template.location = 0;
+        categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;
+        let label = categoryAxis.renderer.labels.template;
+        label.truncate = true;
+        label.maxWidth = settings.LabelWidth ?? this.LabelWidth;
+        label.tooltipText = "{category}";
+        if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {
+            categoryAxis.events.on("sizechanged", (ev) => {
+                let axis = ev.target;
+                var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);
+                if (cellWidth < axis.renderer.labels.template.maxWidth) {
+                    let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);
+                    axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;
+                    axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;
+                    axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;
+                    axis.renderer.labels.template.horizontalCenter = "right";
+                    axis.renderer.labels.template.verticalCenter = "middle";
+                }
+                else {
+                    axis.renderer.labels.template.rotation = 0;
+                    axis.renderer.labels.template.dx = 0;
+                    axis.renderer.labels.template.dy = 0;
+                    axis.renderer.labels.template.horizontalCenter = "middle";
+                    axis.renderer.labels.template.verticalCenter = "top";
+                }
+            });
+        }
+        // Create series
+        let series = ChartInstanceCasted.series.push(new am4charts.ColumnSeries());
+        series.dataFields.valueY = "v";
+        series.dataFields.categoryX = "k";
+        series.name = "";
+        series.columns.template.tooltipText = "{categoryX}: [bold]{valueY}[/]";
+        series.columns.template.fillOpacity = .8;
+        series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);
+        let columnTemplate = series.columns.template;
+        columnTemplate.strokeWidth = 2;
+        columnTemplate.strokeOpacity = 1;
+        return this;
+    }
+    /** @ignore */
+    refreshData(data) {
+        //TODO:IMPL
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VerticalChartService.js","sourceRoot":"","sources":["../../../../../projects/es-charts/src/lib/services/VerticalChartService.ts"],"names":[],"mappings":"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","sourcesContent":["import { IBaseService } from './base/IBaseService';\r\nimport { BaseAdapter } from '../adapters/BaseAdapter';\r\nimport { VerticalChartData } from '../models/data/VerticalChartData';\r\nimport { VerticalChartSettings } from '../models/settings/VerticalChartSettings';\r\n\r\nimport * as am4core from \"@amcharts/amcharts4/core\";\r\nimport * as am4charts from \"@amcharts/amcharts4/charts\";\r\n\r\n/**\r\n * Classe il cui unico scopo è gestire il setup e rendering di un VerticalChart\r\n */\r\nexport class VerticalChartService implements IBaseService<am4charts.XYChart>{\r\n    /** @ignore */\r\n    public ChartInstance: am4charts.XYChart;\r\n    /** @ignore */\r\n    private dangerZone: number = 50;\r\n    /** @ignore */\r\n    private LabelWidth: number = 150;\r\n    /** @ignore */\r\n    private LabelRightWhenCompressed: number = 20;\r\n    /** @ignore */\r\n    private LabelTopWhenCompressed: number = -5;\r\n    /** @ignore */\r\n    private DefaultColumnWidthPercentage: number = 85;\r\n\r\n    /** @ignore */\r\n    constructor(public Adapter: BaseAdapter) { }\r\n\r\n    /**\r\n     * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un VerticalChart\r\n     */\r\n    public graphicate(data: VerticalChartData | any, settings: VerticalChartSettings): IBaseService<am4charts.XYChart> {\r\n\r\n        if (settings.Timeline) {\r\n            console.error(\"Timeline not supported for vertical chart\");\r\n            return null;\r\n        }\r\n\r\n        //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...\r\n        am4core.options.autoDispose = true;\r\n        \r\n        this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);\r\n        let ChartInstanceCasted = <am4charts.XYChart>this.ChartInstance;\r\n\r\n        let dataConverted: VerticalChartData = this.Adapter ? this.Adapter.adaptDataForVerticalChart(data) : data;\r\n        ChartInstanceCasted.data = dataConverted.values;\r\n\r\n        if (settings.Legend) {\r\n            ChartInstanceCasted.legend = new am4charts.Legend();\r\n            ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';\r\n            ChartInstanceCasted.legend.itemContainers.template.tooltipText = \"{category}\";\r\n            \r\n            if (settings.LegendPadding) {\r\n                let template = this.ChartInstance.legend.itemContainers.template;\r\n                template.paddingTop = settings.LegendPadding.top ?? 0;\r\n                template.paddingBottom = settings.LegendPadding.bottom ?? 0;\r\n                template.paddingLeft = settings.LegendPadding.left ?? 0;\r\n                template.paddingRight = settings.LegendPadding.right ?? 0;\r\n            }\r\n        }\r\n\r\n        let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());\r\n        if (settings.YAxisTitle) {\r\n            yAxis.title.text = settings.YAxisTitle\r\n            yAxis.title.fontWeight = \"bold\";\r\n        }\r\n        let categoryAxis: am4charts.CategoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis())\r\n        if (settings.XAxisTitle) {\r\n            categoryAxis.title.text = settings.XAxisTitle\r\n            categoryAxis.title.fontWeight = \"bold\";\r\n        }\r\n\r\n        categoryAxis.dataFields.category = \"k\";\r\n        categoryAxis.renderer.grid.template.location = 0;\r\n        categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;\r\n\r\n        let label = categoryAxis.renderer.labels.template;\r\n        label.truncate = true;\r\n        label.maxWidth = settings.LabelWidth ?? this.LabelWidth;\r\n        label.tooltipText = \"{category}\";\r\n\r\n        if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {\r\n            categoryAxis.events.on(\"sizechanged\", (ev) => {\r\n                let axis = ev.target;\r\n                var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);\r\n                if (cellWidth < axis.renderer.labels.template.maxWidth) {\r\n                    let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);\r\n                    axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;\r\n                    axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;\r\n                    axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;\r\n                    axis.renderer.labels.template.horizontalCenter = \"right\";\r\n                    axis.renderer.labels.template.verticalCenter = \"middle\";\r\n                }\r\n                else {\r\n                    axis.renderer.labels.template.rotation = 0;\r\n                    axis.renderer.labels.template.dx = 0;\r\n                    axis.renderer.labels.template.dy = 0;\r\n                    axis.renderer.labels.template.horizontalCenter = \"middle\";\r\n                    axis.renderer.labels.template.verticalCenter = \"top\";\r\n                }\r\n            });\r\n        }\r\n\r\n        // Create series\r\n        let series = ChartInstanceCasted.series.push(new am4charts.ColumnSeries());\r\n        series.dataFields.valueY = \"v\";\r\n        series.dataFields.categoryX = \"k\";\r\n        series.name = \"\";\r\n        series.columns.template.tooltipText = \"{categoryX}: [bold]{valueY}[/]\";\r\n        series.columns.template.fillOpacity = .8;\r\n        series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);\r\n\r\n        let columnTemplate = series.columns.template;\r\n        columnTemplate.strokeWidth = 2;\r\n        columnTemplate.strokeOpacity = 1;\r\n\r\n        return this;\r\n    }\r\n\r\n    /** @ignore */\r\n    public refreshData(data: VerticalChartData | any) {\r\n        //TODO:IMPL\r\n    }\r\n}"]}

package/esm2020/lib/services/VerticalStackedChartService.mjs

@@ -0,0 +1,124 @@
+import * as am4core from "@amcharts/amcharts4/core";
+import * as am4charts from "@amcharts/amcharts4/charts";
+/**
+ * Classe il cui unico scopo è gestire il setup e rendering di un VerticalStackedChart
+ */
+export class VerticalStackedChartService {
+    /** @ignore */
+    constructor(Adapter) {
+        this.Adapter = Adapter;
+        /** @ignore */
+        this.dangerZone = 50;
+        /** @ignore */
+        this.LabelWidth = 150;
+        /** @ignore */
+        this.LabelRightWhenCompressed = 20;
+        /** @ignore */
+        this.LabelTopWhenCompressed = -5;
+        /** @ignore */
+        this.DefaultColumnWidthPercentage = 85;
+    }
+    /**
+     * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un VerticalStackedChart
+     */
+    graphicate(data, settings) {
+        if (settings.Timeline) {
+            console.error("Timeline not supported for vertical chart");
+            return null;
+        }
+        //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...
+        am4core.options.autoDispose = true;
+        this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);
+        let ChartInstanceCasted = this.ChartInstance;
+        // Create axes 
+        let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());
+        if (settings.YAxisTitle) {
+            yAxis.title.text = settings.YAxisTitle;
+            yAxis.title.fontWeight = "bold";
+        }
+        let categoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis());
+        if (settings.XAxisTitle) {
+            categoryAxis.title.text = settings.XAxisTitle;
+            categoryAxis.title.fontWeight = "bold";
+        }
+        yAxis.min = 0;
+        categoryAxis.dataFields.category = "key";
+        categoryAxis.renderer.grid.template.location = 0;
+        categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;
+        let label = categoryAxis.renderer.labels.template;
+        label.truncate = true;
+        label.maxWidth = settings.LabelWidth ?? this.LabelWidth;
+        label.tooltipText = "{category}";
+        if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {
+            categoryAxis.events.on("sizechanged", (ev) => {
+                let axis = ev.target;
+                var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);
+                if (cellWidth < axis.renderer.labels.template.maxWidth) {
+                    let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);
+                    axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;
+                    axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;
+                    axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;
+                    axis.renderer.labels.template.horizontalCenter = "right";
+                    axis.renderer.labels.template.verticalCenter = "middle";
+                }
+                else {
+                    axis.renderer.labels.template.rotation = 0;
+                    axis.renderer.labels.template.dx = 0;
+                    axis.renderer.labels.template.dy = 0;
+                    axis.renderer.labels.template.horizontalCenter = "middle";
+                    axis.renderer.labels.template.verticalCenter = "top";
+                }
+            });
+        }
+        let dataPreConverted = this.Adapter ? this.Adapter.adaptDataForVerticalStackedChart(data) : data;
+        let dataConverted = [];
+        for (let i = 0; i < dataPreConverted.groups.length; i++) {
+            let item = dataPreConverted.groups[i];
+            let obj = { key: item.name };
+            for (let p = 0; p < item.values.length; p++) {
+                let value = item.values[p];
+                obj[value.k] = value.v;
+            }
+            dataConverted.push(obj);
+        }
+        ChartInstanceCasted.data = dataConverted;
+        //Prendo la prima categoria e mi baso sulle proprietà per dfeinire le serie
+        for (let prop in dataConverted[0]) {
+            if (prop !== "key")
+                this.createSeriesStacked(ChartInstanceCasted, settings, prop, prop);
+        }
+        if (settings.Legend) {
+            ChartInstanceCasted.legend = new am4charts.Legend();
+            ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';
+            ChartInstanceCasted.legend.itemContainers.template.tooltipText = "{category}";
+            if (settings.LegendPadding) {
+                let template = this.ChartInstance.legend.itemContainers.template;
+                template.paddingTop = settings.LegendPadding.top ?? 0;
+                template.paddingBottom = settings.LegendPadding.bottom ?? 0;
+                template.paddingLeft = settings.LegendPadding.left ?? 0;
+                template.paddingRight = settings.LegendPadding.right ?? 0;
+            }
+        }
+        return this;
+    }
+    /** @ignore */
+    refreshData(data) {
+        //TODO:IMPL
+    }
+    /** @ignore */
+    createSeriesStacked(chart, settings, field, name) {
+        // Set up series
+        let series = chart.series.push(new am4charts.ColumnSeries());
+        series.name = name;
+        series.dataFields.valueY = field;
+        series.dataFields.categoryX = "key";
+        series.sequencedInterpolation = true;
+        series.columns.template.tooltipText = "{name} {categoryX}: [bold]{valueY}[/]";
+        series.columns.template.fillOpacity = .8;
+        series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);
+        // Make it stacked
+        series.stacked = true;
+        return series;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VerticalStackedChartService.js","sourceRoot":"","sources":["../../../../../projects/es-charts/src/lib/services/VerticalStackedChartService.ts"],"names":[],"mappings":"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","sourcesContent":["import { IBaseService } from './base/IBaseService';\r\nimport { BaseAdapter } from '../adapters/BaseAdapter';\r\nimport { VerticalStackedChartData } from '../models/data/VerticalStackedChartData';\r\nimport { VerticalStackedChartSettings } from '../models/settings/VerticalStackedChartSettings';\r\n\r\nimport * as am4core from \"@amcharts/amcharts4/core\";\r\nimport * as am4charts from \"@amcharts/amcharts4/charts\";\r\n\r\n/**\r\n * Classe il cui unico scopo è gestire il setup e rendering di un VerticalStackedChart\r\n */\r\nexport class VerticalStackedChartService implements IBaseService<am4charts.XYChart>{\r\n  /** @ignore */\r\n  public ChartInstance: am4charts.XYChart;\r\n  /** @ignore */\r\n  private dangerZone: number = 50;\r\n  /** @ignore */\r\n  private LabelWidth: number = 150;\r\n  /** @ignore */\r\n  private LabelRightWhenCompressed: number = 20;\r\n  /** @ignore */\r\n  private LabelTopWhenCompressed: number = -5;\r\n  /** @ignore */\r\n  private DefaultColumnWidthPercentage: number = 85;\r\n\r\n  /** @ignore */\r\n  constructor(public Adapter: BaseAdapter) { }\r\n\r\n  /**\r\n   * Metodo che data una coppia Dati - Impostazioni li utilizza per creare e visualizzare un VerticalStackedChart\r\n   */\r\n  public graphicate(data: VerticalStackedChartData | any, settings: VerticalStackedChartSettings): IBaseService<am4charts.XYChart> {\r\n    \r\n    if (settings.Timeline) {\r\n      console.error(\"Timeline not supported for vertical chart\");\r\n      return null;\r\n    }\r\n\r\n    //Per evitare di dimenticarmeli e gestire comunque bene gli ngif ecc...\r\n    am4core.options.autoDispose = true;\r\n\r\n    this.ChartInstance = am4core.create(settings.Name, am4charts.XYChart);\r\n    let ChartInstanceCasted = <am4charts.XYChart>this.ChartInstance;\r\n\r\n    // Create axes \r\n    let yAxis = ChartInstanceCasted.yAxes.push(new am4charts.ValueAxis());\r\n    if (settings.YAxisTitle) {\r\n      yAxis.title.text = settings.YAxisTitle\r\n      yAxis.title.fontWeight = \"bold\";\r\n    }\r\n    let categoryAxis = ChartInstanceCasted.xAxes.push(new am4charts.CategoryAxis());\r\n    if (settings.XAxisTitle) {\r\n      categoryAxis.title.text = settings.XAxisTitle\r\n      categoryAxis.title.fontWeight = \"bold\";\r\n    }\r\n\r\n    yAxis.min = 0;\r\n\r\n    categoryAxis.dataFields.category = \"key\";\r\n    categoryAxis.renderer.grid.template.location = 0;\r\n    categoryAxis.renderer.minGridDistance = settings?.MinGridDistance ?? 30;\r\n\r\n    let label = categoryAxis.renderer.labels.template;\r\n    label.truncate = true;\r\n    label.maxWidth = settings.LabelWidth ?? this.LabelWidth;\r\n    label.tooltipText = \"{category}\";\r\n\r\n    if (settings?.AdaptLabelSizeAndOrientation == null ? true : settings?.AdaptLabelSizeAndOrientation) {\r\n      categoryAxis.events.on(\"sizechanged\", (ev) => {\r\n        let axis = ev.target;\r\n        var cellWidth = axis.pixelWidth / (axis.endIndex - axis.startIndex);\r\n        if (cellWidth < axis.renderer.labels.template.maxWidth) {\r\n          let areWeInDangerZone = cellWidth < (settings?.LabelVerticalOrientationCutoffWidth ?? this.dangerZone);\r\n          axis.renderer.labels.template.rotation = areWeInDangerZone ? -90 : -45;\r\n          axis.renderer.labels.template.dx = settings.LabelRightWhenCompressed ?? areWeInDangerZone ? 0 : this.LabelRightWhenCompressed;\r\n          axis.renderer.labels.template.dy = settings.LabelTopWhenCompressed ?? this.LabelTopWhenCompressed;\r\n          axis.renderer.labels.template.horizontalCenter = \"right\";\r\n          axis.renderer.labels.template.verticalCenter = \"middle\";\r\n        }\r\n        else {\r\n          axis.renderer.labels.template.rotation = 0;\r\n          axis.renderer.labels.template.dx = 0;\r\n          axis.renderer.labels.template.dy = 0;\r\n          axis.renderer.labels.template.horizontalCenter = \"middle\";\r\n          axis.renderer.labels.template.verticalCenter = \"top\";\r\n        }\r\n      });\r\n    }\r\n\r\n    let dataPreConverted: VerticalStackedChartData = this.Adapter ? this.Adapter.adaptDataForVerticalStackedChart(data) : data;\r\n\r\n    let dataConverted = [];\r\n    for (let i = 0; i < dataPreConverted.groups.length; i++) {\r\n      let item = dataPreConverted.groups[i];\r\n      let obj = { key: item.name };\r\n      for (let p = 0; p < item.values.length; p++) {\r\n        let value = item.values[p];\r\n        obj[value.k] = value.v;\r\n      }\r\n      dataConverted.push(obj);\r\n    }\r\n\r\n    ChartInstanceCasted.data = dataConverted;\r\n\r\n    //Prendo la prima categoria e mi baso sulle proprietà per dfeinire le serie\r\n    for (let prop in dataConverted[0]) {\r\n      if (prop !== \"key\")\r\n        this.createSeriesStacked(ChartInstanceCasted, settings, prop, prop);\r\n    }\r\n\r\n    if (settings.Legend) {\r\n      ChartInstanceCasted.legend = new am4charts.Legend();\r\n      ChartInstanceCasted.legend.position = settings?.LegendPosition ?? 'right';\r\n      ChartInstanceCasted.legend.itemContainers.template.tooltipText = \"{category}\";\r\n\r\n      if (settings.LegendPadding) {\r\n        let template = this.ChartInstance.legend.itemContainers.template;\r\n        template.paddingTop = settings.LegendPadding.top ?? 0;\r\n        template.paddingBottom = settings.LegendPadding.bottom ?? 0;\r\n        template.paddingLeft = settings.LegendPadding.left ?? 0;\r\n        template.paddingRight = settings.LegendPadding.right ?? 0;\r\n      }\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /** @ignore */\r\n  public refreshData(data: VerticalStackedChartData | any) {\r\n    //TODO:IMPL\r\n  }\r\n\r\n  /** @ignore */\r\n  private createSeriesStacked(chart, settings: VerticalStackedChartSettings, field, name) {\r\n    // Set up series\r\n    let series = chart.series.push(new am4charts.ColumnSeries());\r\n    series.name = name;\r\n    series.dataFields.valueY = field;\r\n    series.dataFields.categoryX = \"key\";\r\n    series.sequencedInterpolation = true;\r\n    series.columns.template.tooltipText = \"{name} {categoryX}: [bold]{valueY}[/]\";\r\n    series.columns.template.fillOpacity = .8;\r\n    series.columns.template.width = am4core.percent(settings.ColumnWidthPercentage ?? this.DefaultColumnWidthPercentage);\r\n\r\n    // Make it stacked\r\n    series.stacked = true;\r\n\r\n    return series;\r\n  }\r\n}"]}

package/esm2020/lib/services/base/IBaseService.mjs

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

package/esm2020/public-api.mjs

@@ -1,28 +1,28 @@
 /*
  * Public API Surface of es-charts
  */
-export * from './lib/adapters/classes/BaseAdapter';
-export * from './lib/adapters/classes/IBaseAdapter';
-export * from './lib/models/data/classes/LineChartData';
-export * from './lib/models/data/classes/PieChartData';
-export * from './lib/models/data/classes/AreaChartData';
-export * from './lib/models/data/classes/Vertical2DChartData';
-export * from './lib/models/data/classes/VerticalChartData';
-export * from './lib/models/data/classes/VerticalStackedChartData';
-export * from './lib/models/settings/classes/AreaChartSettings';
-export * from './lib/models/settings/classes/LineChartSettings';
-export * from './lib/models/settings/classes/PieChartSettings';
-export * from './lib/models/settings/classes/Vertical2DChartSettings';
-export * from './lib/models/settings/classes/VerticalChartSettings';
-export * from './lib/models/settings/classes/VerticalStackedChartSettings';
-export * from './lib/models/settings/classes/base/BaseSettings';
-export * from './lib/models/settings/classes/base/BaseInterval';
-export * from './lib/models/settings/classes/base/LegendPad';
-export * from './lib/models/data/classes/base/Limit';
-export * from './lib/models/data/classes/base/DateValue';
-export * from './lib/models/data/classes/base/KeyValue';
-export * from './lib/models/data/classes/base/KeyValueColor';
-export * from './lib/models/data/classes/base/LineSerie';
+export * from './lib/adapters/BaseAdapter';
+export * from './lib/adapters/IBaseAdapter';
+export * from './lib/models/data/LineChartData';
+export * from './lib/models/data/PieChartData';
+export * from './lib/models/data/AreaChartData';
+export * from './lib/models/data/Vertical2DChartData';
+export * from './lib/models/data/VerticalChartData';
+export * from './lib/models/data/VerticalStackedChartData';
+export * from './lib/models/settings/AreaChartSettings';
+export * from './lib/models/settings/LineChartSettings';
+export * from './lib/models/settings/PieChartSettings';
+export * from './lib/models/settings/Vertical2DChartSettings';
+export * from './lib/models/settings/VerticalChartSettings';
+export * from './lib/models/settings/VerticalStackedChartSettings';
+export * from './lib/models/settings/base/BaseSettings';
+export * from './lib/models/settings/base/BaseInterval';
+export * from './lib/models/settings/base/LegendPad';
+export * from './lib/models/data/base/Limit';
+export * from './lib/models/data/base/DateValue';
+export * from './lib/models/data/base/KeyValue';
+export * from './lib/models/data/base/KeyValueColor';
+export * from './lib/models/data/base/LineSerie';
 export * from './lib/components/chart-pager/chart-pager.component';
 export * from './lib/components/base/base-chart.component';
 export * from './lib/components/specializations/es-chart.component';
@@ -32,7 +32,7 @@ export * from './lib/components/specializations/es-pie-chart.component';
 export * from './lib/components/specializations/es-vertical-2d-chart.component';
 export * from './lib/components/specializations/es-vertical-chart.component';
 export * from './lib/components/specializations/es-vertical-stacked-chart.component';
-export * from './lib/models/core/classes/ChartThemes';
-export * from './lib/models/data/classes/PagedChartData';
+export * from './lib/models/core/ChartThemes';
+export * from './lib/models/data/PagedChartData';
 export * from './lib/es-charts.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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