@biit-solutions/wizardry-theme 1.21.34

package/esm2020/charts/heatmap-chart/heatmap-chart.component.mjs

@@ -0,0 +1,242 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { HeatmapChartRange } from "./heatmap-chart-range";
+import { completeIconSet } from '@biit-solutions/biit-icons-collection';
+import * as i0 from "@angular/core";
+import * as i1 from "@biit-solutions/wizardry-theme/icon";
+import * as i2 from "@angular/common";
+import * as i3 from "ng-apexcharts";
+import * as i4 from "@biit-solutions/wizardry-theme/button";
+export class HeatmapChartComponent {
+    constructor(biitIconService) {
+        this.biitIconService = biitIconService;
+        this.pageNumber = 1;
+        this.title = '';
+        this.itemsPerPage = 20;
+        biitIconService.registerIcons(completeIconSet);
+    }
+    ngOnInit() {
+        if (!this.data?.elements?.length) {
+            return;
+        }
+        this.fillDefaultValues();
+        this.createHeatmapOptions();
+    }
+    ngOnChanges() {
+        if (!this.data?.elements?.length) {
+            return;
+        }
+        this.fillDefaultValues();
+        this.createHeatmapOptions();
+    }
+    fillDefaultValues() {
+        if (!this.ranges.some(r => r.from == -10000 && r.to == -9998 && r.color == "#FFFFFF")) {
+            this.ranges.push(new HeatmapChartRange(-10000, -9998, "#FFFFFF"));
+        }
+        const data = this.data.elements.map(element => element.data);
+        const keys = new Set();
+        data.flatMap(flatValues => flatValues).forEach(value => keys.add(value.x));
+        this.data.elements.map(element => element.data)
+            .forEach(data => {
+            keys.forEach(key => {
+                if (!data.some(element => element.x === key)) {
+                    data.push({ x: key, y: -9999 });
+                }
+            });
+            data.sort((a, b) => +a.x - +b.x);
+        });
+    }
+    createHeatmapOptions() {
+        // @ts-ignore
+        this.heatmapOptions = {
+            series: this.generateSeries(),
+            chart: {
+                height: 'auto',
+                width: '892',
+                type: "heatmap",
+                events: {
+                    mounted(chart, options) {
+                        const totalWidth = chart.dimensions.w.globals.dom.elWrap.clientWidth;
+                        const oldGridWidth = chart.dimensions.w.globals.gridWidth;
+                        const newGridWidth = options.config.series[0]?.data?.length * 37;
+                        const newTotalWidth = Math.trunc((totalWidth - oldGridWidth) + newGridWidth);
+                        const totalHeight = chart.dimensions.w.globals.dom.elWrap.clientHeight;
+                        const oldGridHeight = chart.dimensions.w.globals.dom.elWrap
+                            .getElementsByClassName("apexcharts-xcrosshairs")[0].getBoundingClientRect().height;
+                        const newGridHeight = options.config.series?.length * 35;
+                        const newTotalHeight = Math.trunc((totalHeight - oldGridHeight) + newGridHeight);
+                        if (totalHeight !== newTotalHeight || totalWidth !== newTotalWidth) {
+                            options.config.chart.width = newTotalWidth;
+                            options.config.chart.height = newTotalHeight;
+                            chart.updateOptions({
+                                chart: {
+                                    width: newTotalWidth,
+                                    height: newTotalHeight
+                                },
+                                legend: {
+                                    width: newTotalWidth
+                                }
+                            });
+                        }
+                    },
+                    updated(chart, options) {
+                        const totalWidth = chart.dimensions.w.globals.dom.elWrap.clientWidth;
+                        const oldGridWidth = chart.dimensions.w.globals.gridWidth;
+                        const newGridWidth = options.config.series[0]?.data?.length * 37;
+                        const newTotalWidth = Math.trunc((totalWidth - oldGridWidth) + newGridWidth);
+                        const totalHeight = chart.dimensions.w.globals.dom.elWrap.clientHeight;
+                        const oldGridHeight = chart.dimensions.w.globals.dom.elWrap
+                            .getElementsByClassName("apexcharts-xcrosshairs")[0].getBoundingClientRect().height;
+                        const newGridHeight = options.config.series?.length * 35;
+                        const newTotalHeight = Math.trunc((totalHeight - oldGridHeight) + newGridHeight);
+                        if (totalHeight !== newTotalHeight || totalWidth !== newTotalWidth) {
+                            options.config.chart.width = newTotalWidth;
+                            options.config.chart.height = newTotalHeight;
+                            chart.updateOptions({
+                                chart: {
+                                    width: newTotalWidth,
+                                    height: newTotalHeight
+                                },
+                                legend: {
+                                    width: newTotalWidth
+                                }
+                            });
+                        }
+                    }
+                }
+            },
+            plotOptions: {
+                heatmap: {
+                    radius: 20,
+                    enableShades: false,
+                    colorScale: {
+                        ranges: this.ranges
+                    }
+                }
+            },
+            dataLabels: {
+                enabled: true,
+                style: {
+                    colors: ["#fff"],
+                    fontSize: '16px',
+                    fontFamily: 'Montserrat',
+                },
+                formatter: function (value) {
+                    if (value === -9999) {
+                        return "";
+                    }
+                    else {
+                        return value + "";
+                    }
+                }
+            },
+            xaxis: {
+                type: "category",
+                labels: {
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat',
+                    },
+                    trim: true,
+                    minHeight: 120
+                },
+            },
+            yaxis: {
+                labels: {
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat',
+                    },
+                },
+            },
+            legend: {
+                width: 892,
+                fontSize: '16px',
+                fontFamily: 'Montserrat',
+                itemMargin: {
+                    vertical: 20,
+                    horizontal: 20
+                },
+                formatter: function (value) {
+                    // Remove decimals on legend
+                    return Number.parseInt(value.substring(0, value.indexOf(" - "))) + ' / ' + Number.parseInt(value.substring(value.indexOf(" - ") + 3, value.length));
+                },
+                markers: {
+                    offsetY: -1
+                },
+            },
+            title: {
+                text: this.title.toUpperCase(),
+                style: {
+                    fontSize: '20px',
+                    fontFamily: 'Montserrat',
+                    fontWeight: 700,
+                }
+            },
+            tooltip: {
+                enabled: false
+            },
+            grid: {
+                borderColor: '#262626',
+                position: 'front',
+                xaxis: {
+                    lines: {
+                        show: false
+                    }
+                },
+                yaxis: {
+                    lines: {
+                        show: true
+                    }
+                },
+            },
+            states: {
+                active: {
+                    filter: {
+                        type: 'lighten',
+                        value: 0.15
+                    }
+                }
+            }
+        };
+    }
+    updateGraph() {
+        this.chart.updateSeries(this.generateSeries());
+    }
+    generateSeries() {
+        let series = [];
+        this.data.elements.forEach(item => {
+            series.push({ name: item.name, data: item.data });
+        });
+        series.forEach(category => {
+            category.data = category.data.slice((this.pageNumber - 1) * this.itemsPerPage, this.pageNumber * this.itemsPerPage);
+            while (category.data.length < this.itemsPerPage) {
+                // @ts-ignore
+                category.data.push({ x: '', y: -9999 });
+            }
+        });
+        return series;
+    }
+    async getPngBlob() {
+        const base64 = await this.chart.dataURI();
+        const decode = await fetch(base64.imgURI);
+        return decode.blob();
+    }
+}
+HeatmapChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartComponent, deps: [{ token: i1.BiitIconService }], target: i0.ɵɵFactoryTarget.Component });
+HeatmapChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: HeatmapChartComponent, selector: "biit-heatmap", inputs: { data: "data", ranges: "ranges", title: "title", itemsPerPage: "itemsPerPage" }, viewQueries: [{ propertyName: "chart", first: true, predicate: ["heatmap"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div id=\"chart\"\n     [style.opacity]=\"heatmapOptions ? '1' : '0'\">\n  <apx-chart #heatmap\n             *ngIf=\"heatmapOptions\"\n             [series]=\"heatmapOptions.series\"\n             [chart]=\"heatmapOptions.chart\"\n             [dataLabels]=\"heatmapOptions.dataLabels\"\n             [colors]=\"heatmapOptions.colors\"\n             [stroke]=\"heatmapOptions.stroke\"\n             [plotOptions]=\"heatmapOptions.plotOptions\"\n             [xaxis]=\"heatmapOptions.xaxis\"\n             [yaxis]=\"heatmapOptions.yaxis\"\n             [legend]=\"heatmapOptions.legend\"\n             [title]=\"heatmapOptions.title\"\n             [tooltip]=\"heatmapOptions.tooltip\"\n             [grid]=\"heatmapOptions.grid\"\n             [states]=\"heatmapOptions.states\"\n  ></apx-chart>\n  <div class=\"buttons\"\n       *ngIf=\"this.data?.elements[0]?.data.length > itemsPerPage\">\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"pageNumber == 1\"\n            (click)=\"pageNumber = pageNumber-1; updateGraph()\"\n            style=\"rotate: 180deg\"\n    ></button>\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"this.data?.elements[0].data.length <= pageNumber*itemsPerPage\"\n            (click)=\"pageNumber = pageNumber+1; updateGraph()\"\n    ></button>\n  </div>\n</div>\n", styles: ["#chart{display:block;position:relative;height:-moz-fit-content;height:fit-content;width:-moz-fit-content;width:fit-content;transition:.5s ease-in-out}#chart apx-chart ::ng-deep .apexcharts-legend>.apexcharts-legend-series:last-child{display:none}.buttons{display:flex;position:absolute;bottom:0;left:50%;transform:translate(-50%)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.ChartComponent, selector: "apx-chart", inputs: ["chart", "annotations", "colors", "dataLabels", "series", "stroke", "labels", "legend", "markers", "noData", "fill", "tooltip", "plotOptions", "responsive", "xaxis", "yaxis", "forecastDataPoints", "grid", "states", "title", "subtitle", "theme", "autoUpdateSeries"] }, { kind: "component", type: i4.BiitIconButtonComponent, selector: "button[biit-icon]", inputs: ["icon", "checked"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'biit-heatmap', template: "<div id=\"chart\"\n     [style.opacity]=\"heatmapOptions ? '1' : '0'\">\n  <apx-chart #heatmap\n             *ngIf=\"heatmapOptions\"\n             [series]=\"heatmapOptions.series\"\n             [chart]=\"heatmapOptions.chart\"\n             [dataLabels]=\"heatmapOptions.dataLabels\"\n             [colors]=\"heatmapOptions.colors\"\n             [stroke]=\"heatmapOptions.stroke\"\n             [plotOptions]=\"heatmapOptions.plotOptions\"\n             [xaxis]=\"heatmapOptions.xaxis\"\n             [yaxis]=\"heatmapOptions.yaxis\"\n             [legend]=\"heatmapOptions.legend\"\n             [title]=\"heatmapOptions.title\"\n             [tooltip]=\"heatmapOptions.tooltip\"\n             [grid]=\"heatmapOptions.grid\"\n             [states]=\"heatmapOptions.states\"\n  ></apx-chart>\n  <div class=\"buttons\"\n       *ngIf=\"this.data?.elements[0]?.data.length > itemsPerPage\">\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"pageNumber == 1\"\n            (click)=\"pageNumber = pageNumber-1; updateGraph()\"\n            style=\"rotate: 180deg\"\n    ></button>\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"this.data?.elements[0].data.length <= pageNumber*itemsPerPage\"\n            (click)=\"pageNumber = pageNumber+1; updateGraph()\"\n    ></button>\n  </div>\n</div>\n", styles: ["#chart{display:block;position:relative;height:-moz-fit-content;height:fit-content;width:-moz-fit-content;width:fit-content;transition:.5s ease-in-out}#chart apx-chart ::ng-deep .apexcharts-legend>.apexcharts-legend-series:last-child{display:none}.buttons{display:flex;position:absolute;bottom:0;left:50%;transform:translate(-50%)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.BiitIconService }]; }, propDecorators: { chart: [{
+                type: ViewChild,
+                args: ["heatmap"]
+            }], data: [{
+                type: Input
+            }], ranges: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], itemsPerPage: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"heatmap-chart.component.js","sourceRoot":"","sources":["../../../../../projects/wizardry-theme/charts/src/heatmap-chart/heatmap-chart.component.ts","../../../../../projects/wizardry-theme/charts/src/heatmap-chart/heatmap-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, OnChanges, OnInit, ViewChild} from '@angular/core';\nimport {\n  ApexAxisChartSeries,\n  ApexChart,\n  ApexDataLabels, ApexGrid, ApexLegend,\n  ApexPlotOptions, ApexStates, ApexStroke,\n  ApexTitleSubtitle, ApexTooltip,\n  ApexXAxis, ApexYAxis,\n  ChartComponent\n} from \"ng-apexcharts\";\nimport {HeatmapChartData} from \"./heatmap-chart-data\";\nimport {HeatmapChartRange} from \"./heatmap-chart-range\";\nimport {completeIconSet} from '@biit-solutions/biit-icons-collection';\nimport {BiitIconService} from '@biit-solutions/wizardry-theme/icon';\n\n\nexport type HeatmapOptions = {\n  series: ApexAxisChartSeries;\n  chart: ApexChart;\n  dataLabels: ApexDataLabels;\n  fill: any;\n  colors: any;\n  stroke: ApexStroke;\n  title: ApexTitleSubtitle;\n  xaxis: ApexXAxis;\n  yaxis: ApexYAxis;\n  legend: ApexLegend;\n  plotOptions: ApexPlotOptions;\n  tooltip: ApexTooltip;\n  grid: ApexGrid;\n  states: ApexStates;\n};\n\n\n@Component({\n  selector: 'biit-heatmap',\n  templateUrl: './heatmap-chart.component.html',\n  styleUrls: ['./heatmap-chart.component.scss']\n})\nexport class HeatmapChartComponent implements OnInit, OnChanges {\n\n  @ViewChild(\"heatmap\") chart: ChartComponent;\n\n  heatmapOptions: Partial<HeatmapOptions>;\n  pageNumber = 1;\n\n  @Input() public data: HeatmapChartData;\n  @Input() public ranges: HeatmapChartRange[] | undefined;\n  @Input() public title = '';\n  @Input() public itemsPerPage = 20;\n\n  constructor(private biitIconService: BiitIconService) {\n    biitIconService.registerIcons(completeIconSet);\n  }\n\n  ngOnInit() {\n    if (!this.data?.elements?.length) {\n      return;\n    }\n    this.fillDefaultValues();\n    this.createHeatmapOptions();\n  }\n\n  ngOnChanges() {\n    if (!this.data?.elements?.length) {\n      return;\n    }\n    this.fillDefaultValues();\n    this.createHeatmapOptions();\n  }\n\n  private fillDefaultValues(): void {\n    if (!this.ranges.some(r => r.from == -10000 && r.to == -9998 && r.color == \"#FFFFFF\")) {\n      this.ranges.push(new HeatmapChartRange(-10000, -9998, \"#FFFFFF\"))\n    }\n\n    const data : { x: string, y: number | string}[][] = this.data.elements.map(element => element.data);\n    const keys: Set<string> = new Set();\n    data.flatMap(flatValues => flatValues).forEach(value => keys.add(value.x));\n    this.data.elements.map(element => element.data)\n      .forEach(data => {\n        keys.forEach(key => {\n          if(!data.some(element => element.x === key)) {\n            data.push({x: key, y: -9999});\n          }\n        });\n        data.sort((a,b) => +a.x-+b.x);\n      });\n\n  }\n\n  private createHeatmapOptions() {\n    // @ts-ignore\n    this.heatmapOptions = {\n      series: this.generateSeries(),\n      chart: {\n        height: 'auto',\n        width: '892',\n        type: \"heatmap\",\n        events: {\n          mounted(chart: any, options?: any) {\n            const totalWidth = chart.dimensions.w.globals.dom.elWrap.clientWidth;\n            const oldGridWidth = chart.dimensions.w.globals.gridWidth;\n            const newGridWidth = options.config.series[0]?.data?.length * 37;\n            const newTotalWidth = Math.trunc((totalWidth - oldGridWidth) + newGridWidth);\n\n            const totalHeight = chart.dimensions.w.globals.dom.elWrap.clientHeight;\n            const oldGridHeight = chart.dimensions.w.globals.dom.elWrap\n              .getElementsByClassName(\"apexcharts-xcrosshairs\")[0].getBoundingClientRect().height;\n            const newGridHeight = options.config.series?.length * 35;\n            const newTotalHeight = Math.trunc((totalHeight - oldGridHeight) + newGridHeight);\n\n            if (totalHeight !== newTotalHeight || totalWidth !== newTotalWidth) {\n              options.config.chart.width = newTotalWidth;\n              options.config.chart.height = newTotalHeight;\n\n              chart.updateOptions({\n                chart: {\n                  width: newTotalWidth,\n                  height: newTotalHeight\n                },\n                legend: {\n                  width: newTotalWidth\n                }\n              })\n            }\n          },\n          updated(chart: any, options?: any) {\n            const totalWidth = chart.dimensions.w.globals.dom.elWrap.clientWidth;\n            const oldGridWidth = chart.dimensions.w.globals.gridWidth;\n            const newGridWidth = options.config.series[0]?.data?.length * 37;\n            const newTotalWidth = Math.trunc((totalWidth - oldGridWidth) + newGridWidth);\n\n            const totalHeight = chart.dimensions.w.globals.dom.elWrap.clientHeight;\n            const oldGridHeight = chart.dimensions.w.globals.dom.elWrap\n              .getElementsByClassName(\"apexcharts-xcrosshairs\")[0].getBoundingClientRect().height;\n            const newGridHeight = options.config.series?.length * 35;\n            const newTotalHeight = Math.trunc((totalHeight - oldGridHeight) + newGridHeight);\n\n            if (totalHeight !== newTotalHeight || totalWidth !== newTotalWidth) {\n              options.config.chart.width = newTotalWidth;\n              options.config.chart.height = newTotalHeight;\n\n              chart.updateOptions({\n                chart: {\n                  width: newTotalWidth,\n                  height: newTotalHeight\n                },\n                legend: {\n                  width: newTotalWidth\n                }\n              })\n            }\n          }\n        }\n      },\n      plotOptions: {\n        heatmap: {\n          radius: 20,\n          enableShades: false,\n          colorScale: {\n            ranges: this.ranges\n          }\n        }\n      },\n      dataLabels: {\n        enabled: true,\n        style: {\n          colors: [\"#fff\"],\n          fontSize: '16px',\n          fontFamily: 'Montserrat',\n        },\n        formatter: function(value) {\n          if(value === -9999) {\n            return \"\";\n          } else {\n            return value + \"\";\n          }\n        }\n      },\n      xaxis: {\n        type: \"category\",\n        labels: {\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat',\n          },\n          trim: true,\n          minHeight: 120\n        },\n      },\n      yaxis: {\n        labels: {\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat',\n          },\n        },\n      },\n      legend: {\n        width: 892,\n        fontSize: '16px',\n        fontFamily: 'Montserrat',\n        itemMargin: {\n          vertical: 20,\n          horizontal: 20\n        },\n        formatter: function(value) {\n          // Remove decimals on legend\n          return Number.parseInt(value.substring(0, value.indexOf(\" - \"))) + ' / ' + Number.parseInt(value.substring(value.indexOf(\" - \")+3, value.length));\n        },\n        markers: {\n          offsetY: -1\n        },\n\n      },\n      title: {\n        text: this.title.toUpperCase(),\n        style: {\n          fontSize: '20px',\n          fontFamily: 'Montserrat',\n          fontWeight: 700,\n        }\n      },\n      tooltip: {\n        enabled: false\n      },\n      grid: {\n        borderColor: '#262626',\n        position: 'front',\n        xaxis: {\n          lines: {\n            show: false\n          }\n        },\n        yaxis: {\n          lines: {\n            show: true\n          }\n        },\n      },\n      states: {\n        active: {\n          filter: {\n            type: 'lighten',\n            value: 0.15\n          }\n        }\n      }\n    };\n  }\n\n  updateGraph() {\n    this.chart.updateSeries(this.generateSeries());\n  }\n\n  generateSeries(): ApexAxisChartSeries {\n    let series: ApexAxisChartSeries = [];\n    this.data.elements.forEach(item => {\n      series.push({name: item.name, data: item.data})\n    });\n\n    series.forEach(category => {\n      category.data = category.data.slice((this.pageNumber-1)*this.itemsPerPage, this.pageNumber*this.itemsPerPage);\n      while (category.data.length < this.itemsPerPage) {\n        // @ts-ignore\n        category.data.push({x:'', y:-9999});\n      }\n    });\n\n    return series;\n  }\n\n  public async getPngBlob(): Promise<Blob> {\n    const base64 = await this.chart.dataURI();\n    const decode = await fetch(base64.imgURI);\n    return decode.blob();\n  }\n}\n","<div id=\"chart\"\n     [style.opacity]=\"heatmapOptions ? '1' : '0'\">\n  <apx-chart #heatmap\n             *ngIf=\"heatmapOptions\"\n             [series]=\"heatmapOptions.series\"\n             [chart]=\"heatmapOptions.chart\"\n             [dataLabels]=\"heatmapOptions.dataLabels\"\n             [colors]=\"heatmapOptions.colors\"\n             [stroke]=\"heatmapOptions.stroke\"\n             [plotOptions]=\"heatmapOptions.plotOptions\"\n             [xaxis]=\"heatmapOptions.xaxis\"\n             [yaxis]=\"heatmapOptions.yaxis\"\n             [legend]=\"heatmapOptions.legend\"\n             [title]=\"heatmapOptions.title\"\n             [tooltip]=\"heatmapOptions.tooltip\"\n             [grid]=\"heatmapOptions.grid\"\n             [states]=\"heatmapOptions.states\"\n  ></apx-chart>\n  <div class=\"buttons\"\n       *ngIf=\"this.data?.elements[0]?.data.length > itemsPerPage\">\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"pageNumber == 1\"\n            (click)=\"pageNumber = pageNumber-1; updateGraph()\"\n            style=\"rotate: 180deg\"\n    ></button>\n    <button biit-icon\n            [icon]=\"'right_arrow'\"\n            [disabled]=\"this.data?.elements[0].data.length <= pageNumber*itemsPerPage\"\n            (click)=\"pageNumber = pageNumber+1; updateGraph()\"\n    ></button>\n  </div>\n</div>\n"]}

package/esm2020/charts/heatmap-chart/heatmap-chart.module.mjs

@@ -0,0 +1,28 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HeatmapChartComponent } from "./heatmap-chart.component";
+import { NgApexchartsModule } from "ng-apexcharts";
+import { BiitIconButtonModule } from '@biit-solutions/wizardry-theme/button';
+import * as i0 from "@angular/core";
+export class HeatmapChartModule {
+}
+HeatmapChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+HeatmapChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartModule, declarations: [HeatmapChartComponent], imports: [CommonModule,
+        NgApexchartsModule,
+        BiitIconButtonModule], exports: [HeatmapChartComponent] });
+HeatmapChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartModule, imports: [CommonModule,
+        NgApexchartsModule,
+        BiitIconButtonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeatmapChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [HeatmapChartComponent],
+                    exports: [HeatmapChartComponent],
+                    imports: [
+                        CommonModule,
+                        NgApexchartsModule,
+                        BiitIconButtonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhdG1hcC1jaGFydC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93aXphcmRyeS10aGVtZS9jaGFydHMvc3JjL2hlYXRtYXAtY2hhcnQvaGVhdG1hcC1jaGFydC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFDaEUsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHVDQUF1QyxDQUFDOztBQVkzRSxNQUFNLE9BQU8sa0JBQWtCOztnSEFBbEIsa0JBQWtCO2lIQUFsQixrQkFBa0IsaUJBUmQscUJBQXFCLGFBR2xDLFlBQVk7UUFDWixrQkFBa0I7UUFDbEIsb0JBQW9CLGFBSloscUJBQXFCO2lIQU9wQixrQkFBa0IsWUFMM0IsWUFBWTtRQUNaLGtCQUFrQjtRQUNsQixvQkFBb0I7NEZBR1gsa0JBQWtCO2tCQVQ5QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDaEMsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osa0JBQWtCO3dCQUNsQixvQkFBb0I7cUJBQ3JCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SGVhdG1hcENoYXJ0Q29tcG9uZW50fSBmcm9tIFwiLi9oZWF0bWFwLWNoYXJ0LmNvbXBvbmVudFwiO1xuaW1wb3J0IHtOZ0FwZXhjaGFydHNNb2R1bGV9IGZyb20gXCJuZy1hcGV4Y2hhcnRzXCI7XG5pbXBvcnQge0JpaXRJY29uQnV0dG9uTW9kdWxlfSBmcm9tICdAYmlpdC1zb2x1dGlvbnMvd2l6YXJkcnktdGhlbWUvYnV0dG9uJztcblxuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtIZWF0bWFwQ2hhcnRDb21wb25lbnRdLFxuICBleHBvcnRzOiBbSGVhdG1hcENoYXJ0Q29tcG9uZW50XSxcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBOZ0FwZXhjaGFydHNNb2R1bGUsXG4gICAgQmlpdEljb25CdXR0b25Nb2R1bGVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBIZWF0bWFwQ2hhcnRNb2R1bGUge1xufVxuIl19

package/esm2020/charts/line-chart/line-chart.component.mjs

@@ -0,0 +1,191 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "ng-apexcharts";
+export class LineChartComponent {
+    constructor() {
+        this.pageNumber = 1;
+        this.title = '';
+        this.xTitle = '';
+        this.yTitle = '';
+    }
+    ngOnInit() {
+        if (!this.data?.series?.length) {
+            return;
+        }
+        this.createChartOptions();
+    }
+    ngOnChanges() {
+        if (!this.data?.series?.length) {
+            return;
+        }
+        this.createChartOptions();
+    }
+    createChartOptions() {
+        this.chartOptions = {
+            series: this.data.series,
+            chart: {
+                height: '100%',
+                width: '100%',
+                type: "line",
+                toolbar: {
+                    show: true
+                }
+            },
+            colors: this.data.series.map(c => c.color),
+            fill: {
+                opacity: 1
+            },
+            dataLabels: {
+                enabled: this.data.series.length > 1,
+                enabledOnSeries: this.enabledLabelsOnSeries,
+                style: {
+                    fontSize: "16px",
+                    fontFamily: "Montserrat",
+                    fontWeight: "500"
+                },
+                background: {
+                    opacity: 1,
+                    borderWidth: 0,
+                    borderRadius: 0
+                }
+            },
+            stroke: {
+                curve: "straight"
+            },
+            title: {
+                text: this.title.toUpperCase(),
+                align: "left",
+                style: {
+                    fontSize: '20px',
+                    fontFamily: 'Montserrat',
+                    fontWeight: 700,
+                }
+            },
+            grid: {
+                borderColor: "#262626",
+                position: 'back',
+                strokeDashArray: 0,
+                padding: {
+                    top: 20
+                }
+            },
+            markers: {
+                strokeWidth: 0,
+                fillOpacity: 1,
+                hover: {
+                    size: this.data.series.length == 1 ? 7 : 0
+                }
+            },
+            xaxis: {
+                categories: this.data.legend,
+                title: {
+                    text: this.xTitle,
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat',
+                        fontWeight: 900,
+                        color: "#262626"
+                    }
+                },
+                crosshairs: {
+                    width: 'tickWidth',
+                    position: 'back',
+                    stroke: {
+                        color: '#EDEDED',
+                        dashArray: 0,
+                    },
+                    opacity: 0.2
+                },
+                tooltip: {
+                    enabled: false
+                },
+                labels: {
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat'
+                    },
+                    trim: true
+                }
+            },
+            yaxis: {
+                title: {
+                    text: this.yTitle,
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat',
+                        fontWeight: 900,
+                        color: "#262626"
+                    }
+                },
+                labels: {
+                    style: {
+                        fontSize: '14px',
+                        fontFamily: 'Montserrat'
+                    }
+                },
+                min: this.min,
+                max: this.max
+            },
+            legend: {
+                position: "top",
+                horizontalAlign: "left",
+                floating: false,
+                offsetY: -5,
+                fontSize: '16px',
+                fontFamily: 'Montserrat'
+            },
+            tooltip: {
+                custom: function ({ series, seriesIndex, dataPointIndex, w }) {
+                    // debugger;
+                    let tooltip = '<div class="tooltip-base">' +
+                        '  <div class="tooltip-header">' +
+                        w.globals.categoryLabels[dataPointIndex] +
+                        '  </div>' +
+                        '  <div class="tooltip-content">';
+                    series.forEach((seriesItem, i) => {
+                        tooltip +=
+                            '<div class="tooltip-metadata">' +
+                                '  <div class="tooltip-square" style="background:' + w.globals.colors[i] + '"></div>' +
+                                '  <a>' + w.globals.seriesNames[i] + ': </a>' +
+                                '  <a style="margin-left: 0.35rem; font-weight: 500">' + series[i][dataPointIndex] + '</a>' +
+                                '</div>';
+                    });
+                    tooltip +=
+                        '  </div>' +
+                            '</div>';
+                    return tooltip;
+                }
+            },
+        };
+    }
+    async getPngBlob() {
+        const base64 = await this.apexChart.dataURI();
+        const decode = await fetch(base64.imgURI);
+        return decode.blob();
+    }
+}
+LineChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LineChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LineChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: LineChartComponent, selector: "biit-line-chart", inputs: { data: "data", title: "title", xTitle: "xTitle", yTitle: "yTitle", min: "min", max: "max", enabledLabelsOnSeries: "enabledLabelsOnSeries" }, viewQueries: [{ propertyName: "apexChart", first: true, predicate: ["apexChart"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div id=\"line-chart\"\n     [style.opacity]=\"chartOptions ? '1' : '0'\">\n  <apx-chart *ngIf=\"chartOptions\"\n             [chart]=\"chartOptions.chart\"\n             [series]=\"chartOptions.series\"\n             [dataLabels]=\"chartOptions.dataLabels\"\n             [colors]=\"chartOptions.colors\"\n             [stroke]=\"chartOptions.stroke\"\n             [title]=\"chartOptions.title\"\n             [grid]=\"chartOptions.grid\"\n             [xaxis]=\"chartOptions.xaxis\"\n             [yaxis]=\"chartOptions.yaxis\"\n             [markers]=\"chartOptions.markers\"\n             [legend]=\"chartOptions.legend\"\n             [fill]=\"chartOptions.fill\"\n             [tooltip]=\"chartOptions.tooltip\"\n             style=\"display: block; height: 100%;\"\n             #apexChart\n  ></apx-chart>\n</div>\n", styles: ["#line-chart{display:block;height:inherit;width:inherit;transition:1s ease-in-out}#line-chart ::ng-deep apx-chart .apexcharts-tooltip{border:1px solid #262626;border-radius:0;box-shadow:none;font-family:Montserrat;font-size:.7rem;background:white}#line-chart ::ng-deep apx-chart .apexcharts-tooltip *{box-sizing:border-box}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-header{background:#262626;color:#fff;padding:.45rem .7rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content{display:flex;flex-direction:column;row-gap:.2rem;padding:.45rem .7rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data{display:flex;align-items:center}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data .tooltip-square{height:.5rem;width:.5rem;margin-right:.45rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data .tooltip-line{height:.1rem;width:.5rem;margin-right:.45rem}#line-chart ::ng-deep apx-chart .apexcharts-legend-series{display:flex}#line-chart ::ng-deep apx-chart .apexcharts-legend-series .apexcharts-legend-marker{border-radius:0!important;margin-right:7px}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.ChartComponent, selector: "apx-chart", inputs: ["chart", "annotations", "colors", "dataLabels", "series", "stroke", "labels", "legend", "markers", "noData", "fill", "tooltip", "plotOptions", "responsive", "xaxis", "yaxis", "forecastDataPoints", "grid", "states", "title", "subtitle", "theme", "autoUpdateSeries"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LineChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'biit-line-chart', template: "<div id=\"line-chart\"\n     [style.opacity]=\"chartOptions ? '1' : '0'\">\n  <apx-chart *ngIf=\"chartOptions\"\n             [chart]=\"chartOptions.chart\"\n             [series]=\"chartOptions.series\"\n             [dataLabels]=\"chartOptions.dataLabels\"\n             [colors]=\"chartOptions.colors\"\n             [stroke]=\"chartOptions.stroke\"\n             [title]=\"chartOptions.title\"\n             [grid]=\"chartOptions.grid\"\n             [xaxis]=\"chartOptions.xaxis\"\n             [yaxis]=\"chartOptions.yaxis\"\n             [markers]=\"chartOptions.markers\"\n             [legend]=\"chartOptions.legend\"\n             [fill]=\"chartOptions.fill\"\n             [tooltip]=\"chartOptions.tooltip\"\n             style=\"display: block; height: 100%;\"\n             #apexChart\n  ></apx-chart>\n</div>\n", styles: ["#line-chart{display:block;height:inherit;width:inherit;transition:1s ease-in-out}#line-chart ::ng-deep apx-chart .apexcharts-tooltip{border:1px solid #262626;border-radius:0;box-shadow:none;font-family:Montserrat;font-size:.7rem;background:white}#line-chart ::ng-deep apx-chart .apexcharts-tooltip *{box-sizing:border-box}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-header{background:#262626;color:#fff;padding:.45rem .7rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content{display:flex;flex-direction:column;row-gap:.2rem;padding:.45rem .7rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data{display:flex;align-items:center}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data .tooltip-square{height:.5rem;width:.5rem;margin-right:.45rem}#line-chart ::ng-deep apx-chart .apexcharts-tooltip .tooltip-content .tooltip-data .tooltip-line{height:.1rem;width:.5rem;margin-right:.45rem}#line-chart ::ng-deep apx-chart .apexcharts-legend-series{display:flex}#line-chart ::ng-deep apx-chart .apexcharts-legend-series .apexcharts-legend-marker{border-radius:0!important;margin-right:7px}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { apexChart: [{
+                type: ViewChild,
+                args: ['apexChart']
+            }], data: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], xTitle: [{
+                type: Input
+            }], yTitle: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], enabledLabelsOnSeries: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-chart.component.js","sourceRoot":"","sources":["../../../../../projects/wizardry-theme/charts/src/line-chart/line-chart.component.ts","../../../../../projects/wizardry-theme/charts/src/line-chart/line-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, OnChanges, OnInit, ViewChild} from '@angular/core';\nimport {\n  ApexAxisChartSeries, ApexChart,\n  ApexDataLabels, ApexGrid, ApexLegend, ApexMarkers,\n  ApexStroke, ApexTitleSubtitle,\n  ApexTooltip, ApexXAxis, ApexYAxis, ChartComponent\n} from \"ng-apexcharts\";\nimport {LineChartData} from './models/line-chart-data';\n\n\nexport type LineChartOptions = {\n  series: ApexAxisChartSeries;\n  chart: ApexChart;\n  dataLabels: ApexDataLabels;\n  fill: any;\n  colors: any;\n  title: ApexTitleSubtitle;\n  xaxis: ApexXAxis;\n  yaxis: ApexYAxis;\n  legend: ApexLegend;\n  tooltip: ApexTooltip;\n  grid: ApexGrid;\n  stroke: ApexStroke;\n  markers: ApexMarkers;\n};\n\n\n@Component({\n  selector: 'biit-line-chart',\n  templateUrl: './line-chart.component.html',\n  styleUrls: ['./line-chart.component.scss']\n})\nexport class LineChartComponent implements OnInit, OnChanges {\n  @ViewChild('apexChart') apexChart: ChartComponent;\n\n  chartOptions: Partial<LineChartOptions>;\n  pageNumber = 1;\n\n  @Input() public data: LineChartData;\n  @Input() public title = '';\n  @Input() public xTitle = '';\n  @Input() public yTitle = '';\n  @Input() public min: number;\n  @Input() public max: number;\n  @Input() public enabledLabelsOnSeries: number[];\n\n  constructor() { }\n\n  ngOnInit() {\n    if (!this.data?.series?.length) {\n      return;\n    }\n    this.createChartOptions();\n  }\n\n  ngOnChanges() {\n    if (!this.data?.series?.length) {\n      return;\n    }\n    this.createChartOptions();\n  }\n\n  private createChartOptions() {\n    this.chartOptions = {\n      series: this.data.series,\n      chart: {\n        height: '100%',\n        width: '100%',\n        type: \"line\",\n        toolbar: {\n          show: true\n        }\n      },\n      colors: this.data.series.map(c => c.color),\n      fill: {\n        opacity: 1\n      },\n      dataLabels: {\n        enabled: this.data.series.length > 1,\n        enabledOnSeries: this.enabledLabelsOnSeries,\n        style: {\n          fontSize: \"16px\",\n          fontFamily: \"Montserrat\",\n          fontWeight: \"500\"\n        },\n        background: {\n          opacity: 1,\n          borderWidth: 0,\n          borderRadius: 0\n        }\n      },\n      stroke: {\n        curve: \"straight\"\n      },\n      title: {\n        text: this.title.toUpperCase(),\n        align: \"left\",\n        style: {\n          fontSize: '20px',\n          fontFamily: 'Montserrat',\n          fontWeight: 700,\n        }\n      },\n      grid: {\n        borderColor: \"#262626\",\n        position: 'back',\n        strokeDashArray: 0,\n        padding: {\n          top: 20\n        }\n      },\n      markers: {\n        strokeWidth: 0,\n        fillOpacity: 1,\n        hover: {\n          size: this.data.series.length == 1 ? 7 : 0\n        }\n      },\n      xaxis: {\n        categories: this.data.legend,\n        title: {\n          text: this.xTitle,\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat',\n            fontWeight: 900,\n            color: \"#262626\"\n          }\n        },\n        crosshairs : {\n          width: 'tickWidth',\n          position: 'back',\n          stroke: {\n            color: '#EDEDED',\n            dashArray: 0,\n          },\n          opacity: 0.2\n        },\n        tooltip: {\n          enabled: false\n        },\n        labels: {\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat'\n          },\n          trim: true\n        }\n      },\n      yaxis: {\n        title: {\n          text: this.yTitle,\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat',\n            fontWeight: 900,\n            color: \"#262626\"\n          }\n        },\n        labels: {\n          style: {\n            fontSize: '14px',\n            fontFamily: 'Montserrat'\n          }\n        },\n        min: this.min,\n        max: this.max\n      },\n      legend: {\n        position: \"top\",\n        horizontalAlign: \"left\",\n        floating: false,\n        offsetY: -5,\n        fontSize: '16px',\n        fontFamily: 'Montserrat'\n      },\n      tooltip: {\n        custom: function({ series, seriesIndex, dataPointIndex, w }) {\n          // debugger;\n          let tooltip =\n            '<div class=\"tooltip-base\">' +\n            '  <div class=\"tooltip-header\">' +\n            w.globals.categoryLabels[dataPointIndex] +\n            '  </div>' +\n            '  <div class=\"tooltip-content\">';\n          series.forEach((seriesItem, i) => {\n            tooltip +=\n              '<div class=\"tooltip-metadata\">' +\n              '  <div class=\"tooltip-square\" style=\"background:'+ w.globals.colors[i] +'\"></div>' +\n              '  <a>' + w.globals.seriesNames[i] + ': </a>' +\n              '  <a style=\"margin-left: 0.35rem; font-weight: 500\">' + series[i][dataPointIndex] + '</a>' +\n              '</div>';\n          });\n\n          tooltip +=\n            '  </div>' +\n            '</div>';\n          return tooltip;\n        }\n      },\n    };\n  }\n\n  public async getPngBlob(): Promise<Blob> {\n    const base64 = await this.apexChart.dataURI();\n    const decode = await fetch(base64.imgURI);\n    return decode.blob();\n  }\n}\n","<div id=\"line-chart\"\n     [style.opacity]=\"chartOptions ? '1' : '0'\">\n  <apx-chart *ngIf=\"chartOptions\"\n             [chart]=\"chartOptions.chart\"\n             [series]=\"chartOptions.series\"\n             [dataLabels]=\"chartOptions.dataLabels\"\n             [colors]=\"chartOptions.colors\"\n             [stroke]=\"chartOptions.stroke\"\n             [title]=\"chartOptions.title\"\n             [grid]=\"chartOptions.grid\"\n             [xaxis]=\"chartOptions.xaxis\"\n             [yaxis]=\"chartOptions.yaxis\"\n             [markers]=\"chartOptions.markers\"\n             [legend]=\"chartOptions.legend\"\n             [fill]=\"chartOptions.fill\"\n             [tooltip]=\"chartOptions.tooltip\"\n             style=\"display: block; height: 100%;\"\n             #apexChart\n  ></apx-chart>\n</div>\n"]}

package/esm2020/charts/line-chart/line-chart.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LineChartComponent } from "./line-chart.component";
+import { NgApexchartsModule } from "ng-apexcharts";
+import * as i0 from "@angular/core";
+export class LineChartModule {
+}
+LineChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LineChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LineChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: LineChartModule, declarations: [LineChartComponent], imports: [CommonModule,
+        NgApexchartsModule], exports: [LineChartComponent] });
+LineChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LineChartModule, imports: [CommonModule,
+        NgApexchartsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LineChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LineChartComponent],
+                    exports: [LineChartComponent],
+                    imports: [
+                        CommonModule,
+                        NgApexchartsModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluZS1jaGFydC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93aXphcmRyeS10aGVtZS9jaGFydHMvc3JjL2xpbmUtY2hhcnQvbGluZS1jaGFydC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFDMUQsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sZUFBZSxDQUFDOztBQVdqRCxNQUFNLE9BQU8sZUFBZTs7NkdBQWYsZUFBZTs4R0FBZixlQUFlLGlCQVBYLGtCQUFrQixhQUcvQixZQUFZO1FBQ1osa0JBQWtCLGFBSFYsa0JBQWtCOzhHQU1qQixlQUFlLFlBSnhCLFlBQVk7UUFDWixrQkFBa0I7NEZBR1QsZUFBZTtrQkFSM0IsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztvQkFDbEMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7b0JBQzdCLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLGtCQUFrQjtxQkFDbkI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtMaW5lQ2hhcnRDb21wb25lbnR9IGZyb20gXCIuL2xpbmUtY2hhcnQuY29tcG9uZW50XCI7XG5pbXBvcnQge05nQXBleGNoYXJ0c01vZHVsZX0gZnJvbSBcIm5nLWFwZXhjaGFydHNcIjtcblxuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtMaW5lQ2hhcnRDb21wb25lbnRdLFxuICBleHBvcnRzOiBbTGluZUNoYXJ0Q29tcG9uZW50XSxcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBOZ0FwZXhjaGFydHNNb2R1bGVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMaW5lQ2hhcnRNb2R1bGUge1xufVxuIl19

package/esm2020/charts/line-chart/models/line-chart-data.mjs

@@ -0,0 +1,15 @@
+export class LineChartData {
+    constructor(series, legend) {
+        this.series = series;
+        this.legend = legend;
+    }
+}
+export class LineChartSeries {
+    constructor(name, type, data, color) {
+        this.name = name;
+        this.type = type;
+        this.data = data;
+        this.color = color;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluZS1jaGFydC1kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvd2l6YXJkcnktdGhlbWUvY2hhcnRzL3NyYy9saW5lLWNoYXJ0L21vZGVscy9saW5lLWNoYXJ0LWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGFBQWE7SUFJeEIsWUFBWSxNQUF5QixFQUFFLE1BQWdCO1FBQ3JELElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO0lBQ3ZCLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxlQUFlO0lBTTFCLFlBQVksSUFBWSxFQUFFLElBQWdDLEVBQUUsSUFBYyxFQUFFLEtBQWE7UUFDdkYsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDckIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIExpbmVDaGFydERhdGEge1xuICBzZXJpZXM6IExpbmVDaGFydFNlcmllc1tdO1xuICBsZWdlbmQ6IHN0cmluZ1tdO1xuXG4gIGNvbnN0cnVjdG9yKHNlcmllczogTGluZUNoYXJ0U2VyaWVzW10sIGxlZ2VuZDogc3RyaW5nW10pIHtcbiAgICB0aGlzLnNlcmllcyA9IHNlcmllcztcbiAgICB0aGlzLmxlZ2VuZCA9IGxlZ2VuZDtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgTGluZUNoYXJ0U2VyaWVzIHtcbiAgbmFtZTogc3RyaW5nO1xuICB0eXBlOiAnbGluZScgfCAnY29sdW1uJyB8ICdhcmVhJztcbiAgZGF0YTogbnVtYmVyW107XG4gIGNvbG9yOiBzdHJpbmc7IC8vIENvbG9yIHNldCBhcyAnI1hYWFhYWCdcblxuICBjb25zdHJ1Y3RvcihuYW1lOiBzdHJpbmcsIHR5cGU6ICdsaW5lJyB8ICdjb2x1bW4nIHwgJ2FyZWEnLCBkYXRhOiBudW1iZXJbXSwgY29sb3I6IHN0cmluZykge1xuICAgIHRoaXMubmFtZSA9IG5hbWU7XG4gICAgdGhpcy50eXBlID0gdHlwZTtcbiAgICB0aGlzLmRhdGEgPSBkYXRhO1xuICAgIHRoaXMuY29sb3IgPSBjb2xvcjtcbiAgfVxufVxuIl19