@kiwibit/chart 1.0.0

package/README.md

@@ -0,0 +1,46 @@
+# Getting Started
+
+**kiwi-chart** is an Angular library designed to simplify the process of 2D charts generation.
+
+# Installation
+
+After creating a new Angular project simply run:
+
+```properties
+npm install @kiwibit/chart
+``` 
+
+# Usage
+
+- Firstly, import KiwiChartModule in your app module (or any other proper Angular module).
+  
+    ```typescript
+    import { KiwiChartModule } from '@kiwibit/chart';
+
+    @NgModule({
+        imports: [
+            KiwiChartModule
+        ],
+    })
+    export class AppModule {}
+    ```
+- Then use kiwi-chart in your Angular component:
+  
+  ```html
+  <kiwi-chart></kiwi-chart>
+  ```
+  The predefined height of the chart is 480px but it can be adjusted as preferred.
+
+# API
+
+| Input    | Type   | Default | Description                      |
+| -------- | ------ | ------- | -------------------------------- |
+| [chart]  | Chart  |         | The chart object                 |
+| [width]  | string | 100%    | The width of the canvas element  |
+| [height] | string | 480px   | The height of the canvas element |
+
+| Output     | Type      | Description                                                                       |
+| ---------- | --------- | --------------------------------------------------------------------------------- |
+| (addPoint) | BasePoint | Emits an object containing the coordinate of the point selected in the chart area |
+
+**documentation still in progress...**

package/esm2020/kiwibit-chart.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2l3aWJpdC1jaGFydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2tpd2liaXQvY2hhcnQvc3JjL2tpd2liaXQtY2hhcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/chart.component.mjs

@@ -0,0 +1,266 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { ADD_POINT_IMG_OFF, ADD_POINT_IMG_ON } from './constants/chart.constants';
+import { ShapeVariant, TraceType } from './models/chart.models';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-echarts";
+import * as i2 from "@angular/common";
+export class KiwiChartComponent {
+    constructor() {
+        this.chart = null;
+        this.width = '100%';
+        this.height = '480px';
+        this.addPoint = new EventEmitter();
+        this.chartOption = {
+            title: {
+                text: "Chart",
+            },
+            tooltip: {
+                axisPointer: {
+                    type: 'cross',
+                    crossStyle: {
+                        color: '#bebebe'
+                    }
+                }
+            },
+            toolbox: {
+                orient: 'horizontal',
+                feature: {
+                    dataZoom: {
+                        brushStyle: {
+                            borderColor: '#000',
+                            borderWidth: 1,
+                            borderType: 'dashed'
+                        },
+                    },
+                    saveAsImage: {},
+                },
+                left: 'center'
+            },
+            dataZoom: [
+                {
+                    type: 'inside',
+                    xAxisIndex: [0],
+                    throttle: 0,
+                    filterMode: 'none'
+                },
+                {
+                    type: 'inside',
+                    yAxisIndex: [0],
+                    throttle: 0,
+                    filterMode: 'none'
+                }
+            ],
+            xAxis: {
+                type: "value",
+                name: "X",
+                nameLocation: 'middle',
+                nameGap: 30,
+            },
+            yAxis: {
+                type: "value",
+                name: "Y",
+                nameLocation: 'middle',
+                nameGap: 50,
+            },
+            series: [],
+            animation: false
+        };
+        this.updateOption = {};
+        this.echartsInstance = null;
+        this.zr = null;
+    }
+    onChartInit(ec) {
+        this.echartsInstance = ec;
+        this.setupZrEventHandler(ec);
+    }
+    setupZrEventHandler(ec) {
+        this.zr = ec.getZr();
+        this.zr.on('click', params => {
+            let option = ec.getOption();
+            let active = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;
+            if (active && this.chart?.clickToAddPoint) {
+                const pointInPixel = [params.offsetX, params.offsetY];
+                const pointInGrid = ec.convertFromPixel('grid', pointInPixel);
+                if (ec.containPixel('grid', pointInPixel) && pointInGrid) {
+                    let newPoint = {
+                        x: +pointInGrid[0].toFixed(3),
+                        y: +pointInGrid[1].toFixed(3)
+                    };
+                    this.addPoint.emit(newPoint);
+                    ec.setOption({
+                        series: this.createSeries([...this.chart.shapes, {
+                                color: 'crimson',
+                                points: [newPoint],
+                                type: TraceType.SCATTER,
+                                variant: ShapeVariant.TRACE,
+                                smooth: false
+                            }])
+                    });
+                }
+            }
+        });
+        this.zr.on('mousemove', params => {
+            const pointInPixel = [params.offsetX, params.offsetY];
+            const option = ec.getOption();
+            const active = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;
+            if (active) {
+                this.zr?.setCursorStyle(ec.containPixel('grid', pointInPixel) ? 'copy' : 'default');
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        let chart = changes['chart']?.currentValue;
+        if (chart) {
+            this.updateOption = {
+                title: {
+                    text: chart.title,
+                },
+                toolbox: {
+                    feature: {
+                        myAddPoint: {
+                            show: chart.clickToAddPoint,
+                            title: 'Add Point',
+                            icon: ADD_POINT_IMG_OFF,
+                            iconStatus: false,
+                            onclick: () => {
+                                let option = this.echartsInstance?.getOption();
+                                let status = option.toolbox[0].feature.myAddPoint.iconStatus;
+                                this.echartsInstance?.setOption({
+                                    toolbox: {
+                                        feature: {
+                                            myAddPoint: {
+                                                iconStatus: !status,
+                                                icon: !status ? ADD_POINT_IMG_ON : ADD_POINT_IMG_OFF
+                                            }
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    },
+                },
+                legend: {
+                    data: chart.shapes.map((shape) => ({
+                        name: shape.name,
+                        icon: 'circle'
+                    })),
+                    show: chart.showLegend ?? false,
+                    orient: 'vertical',
+                    left: 'right',
+                    padding: [60, 20],
+                    type: 'scroll',
+                    textStyle: {
+                        width: 100,
+                        fontWeight: 'bold',
+                        overflow: 'break'
+                    }
+                },
+                xAxis: {
+                    type: chart.xAxisType,
+                    name: chart.xAxisName,
+                },
+                yAxis: {
+                    type: chart.yAxisType,
+                    name: chart.yAxisName,
+                },
+                series: this.createSeries(chart.shapes),
+                animation: chart.hasAnimations,
+            };
+        }
+    }
+    createSeries(shapes) {
+        let series = [];
+        shapes.forEach((shape) => {
+            switch (shape.variant) {
+                case ShapeVariant.TRACE:
+                    series.push(this.createTrace(shape));
+                    break;
+                default:
+                    break;
+            }
+        });
+        return series;
+    }
+    createTrace(trace) {
+        return {
+            type: trace.type,
+            name: trace.name,
+            data: trace.points.map((point) => ({
+                value: [point.x, point.y],
+                symbol: point.symbol,
+                name: point.name,
+                symbolSize: point.symbolSize,
+                label: {
+                    show: true,
+                    position: 'bottom',
+                    align: 'left',
+                    verticalAlign: 'bottom',
+                    formatter: () => `${point.name ?? ''}`,
+                    color: '#000',
+                    fontSize: 13,
+                    padding: [0, 0, 0, 10],
+                    width: 100,
+                    overflow: 'truncate',
+                    ellipsis: '...',
+                    fontWeight: 'bold'
+                },
+                tooltip: {
+                    formatter: ({ value }) => `
+              ${point.name ? `<strong>${point.name}</strong><br>` : ''}
+              <strong>${this.chart?.xAxisName}:</strong> ${value[0]}
+              <br>
+              <strong>${this.chart?.yAxisName}:</strong> ${value[1]}
+            `
+                }
+            })),
+            color: trace.color,
+            lineStyle: {
+                width: trace.width,
+                type: trace.style
+            },
+            smooth: trace.smooth ?? false
+        };
+    }
+}
+KiwiChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+KiwiChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: KiwiChartComponent, selector: "kiwi-chart", inputs: { chart: "chart", width: "width", height: "height" }, outputs: { addPoint: "addPoint" }, usesOnChanges: true, ngImport: i0, template: `
+    <div 
+      echarts 
+      [options]="chartOption" 
+      [merge]="updateOption"
+      [ngStyle]="{
+        'width': width,
+        'height': height
+      }"
+      (chartInit)="onChartInit($event)"
+    ></div> 
+  `, isInline: true, styles: [""], directives: [{ type: i1.NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "loading", "initOpts", "merge", "autoResize", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartPieSelectChanged", "chartPieSelected", "chartPieUnselected", "chartMapSelectChanged", "chartMapSelected", "chartMapUnselected", "chartAxisAreaSelected", "chartFocusNodeAdjacency", "chartUnfocusNodeAdjacency", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartRendered", "chartFinished"], exportAs: ["echarts"] }, { type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kiwi-chart',
+                    template: `
+    <div 
+      echarts 
+      [options]="chartOption" 
+      [merge]="updateOption"
+      [ngStyle]="{
+        'width': width,
+        'height': height
+      }"
+      (chartInit)="onChartInit($event)"
+    ></div> 
+  `,
+                    styles: [`
+  `]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { chart: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], addPoint: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../../projects/kiwibit/chart/src/lib/chart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, Output, SimpleChanges } from '@angular/core';\nimport { CustomSeriesOption, ECharts, EChartsOption, LineSeriesOption, ScatterSeriesOption, zrender } from 'echarts';\nimport { ADD_POINT_IMG_OFF, ADD_POINT_IMG_ON } from './constants/chart.constants';\nimport { Chart, Shape, ShapeVariant, Trace, Point, TraceType, BasePoint } from './models/chart.models';\n\n@Component({\n  selector: 'kiwi-chart',\n  template: `\n    <div \n      echarts \n      [options]=\"chartOption\" \n      [merge]=\"updateOption\"\n      [ngStyle]=\"{\n        'width': width,\n        'height': height\n      }\"\n      (chartInit)=\"onChartInit($event)\"\n    ></div> \n  `,\n  styles: [`\n  `]\n})\nexport class KiwiChartComponent implements OnChanges {\n\n  @Input() chart: Chart | null = null;\n  @Input() width: string = '100%';\n  @Input() height: string = '480px';\n\n  @Output() addPoint: EventEmitter<BasePoint> = new EventEmitter<BasePoint>();\n\n  chartOption: EChartsOption = {\n    title: {\n      text: \"Chart\",\n    },\n    tooltip: {\n      axisPointer: {\n        type: 'cross',\n        crossStyle: {\n          color: '#bebebe'\n        }\n      }\n    },\n    toolbox: {\n      orient: 'horizontal',\n      feature: {\n        dataZoom: {\n          brushStyle: {\n            borderColor: '#000',\n            borderWidth: 1,\n            borderType: 'dashed'\n          },\n        },\n        saveAsImage: {},\n      },\n      left: 'center'\n    },\n    dataZoom: [\n      {\n        type: 'inside',\n        xAxisIndex: [0],\n        throttle: 0,\n        filterMode: 'none'\n      },\n      {\n        type: 'inside',\n        yAxisIndex: [0],\n        throttle: 0,\n        filterMode: 'none'\n      }\n    ],\n    xAxis: {\n      type: \"value\",\n      name: \"X\",\n      nameLocation: 'middle',\n      nameGap: 30,\n    },\n    yAxis: {\n      type: \"value\",\n      name: \"Y\",\n      nameLocation: 'middle',\n      nameGap: 50,\n    },\n    series: [],\n    animation: false\n  };\n\n  updateOption: EChartsOption = {};\n\n  echartsInstance: ECharts | null = null;\n\n  zr: zrender.ZRenderType | null = null;\n\n  constructor() { }\n\n  onChartInit(ec: ECharts) {\n    this.echartsInstance = ec;\n    this.setupZrEventHandler(ec);\n  }\n\n  setupZrEventHandler(ec: ECharts) {\n    this.zr = ec.getZr();\n    this.zr.on('click', params => {\n      let option: any = ec.getOption();\n      let active = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;\n      if (active && this.chart?.clickToAddPoint) {\n        const pointInPixel = [params.offsetX, params.offsetY];\n        const pointInGrid = ec.convertFromPixel('grid', pointInPixel);\n        if (ec.containPixel('grid', pointInPixel) && pointInGrid) {\n          let newPoint: { x: number, y: number } = {\n            x: +pointInGrid[0].toFixed(3),\n            y: +pointInGrid[1].toFixed(3)\n          };\n          this.addPoint.emit(newPoint);\n          ec.setOption({\n            series: this.createSeries([...this.chart.shapes, {\n              color: 'crimson',\n              points: [newPoint],\n              type: TraceType.SCATTER,\n              variant: ShapeVariant.TRACE,\n              smooth: false\n            }])\n          });\n        }\n      }\n    });\n    this.zr.on('mousemove', params => {\n      const pointInPixel = [params.offsetX, params.offsetY];\n      const option: any = ec.getOption();\n      const active = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;\n      if (active) {\n        this.zr?.setCursorStyle(\n          ec.containPixel('grid', pointInPixel) ? 'copy' : 'default'\n        );\n      }\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    let chart: Chart = changes['chart']?.currentValue;\n    if (chart) {\n      this.updateOption = {\n        title: {\n          text: chart.title,\n        },\n        toolbox: {\n          feature: {\n            myAddPoint: {\n              show: chart.clickToAddPoint,\n              title: 'Add Point',\n              icon: ADD_POINT_IMG_OFF,\n              iconStatus: false,\n              onclick: () => {\n                let option: any = this.echartsInstance?.getOption();\n                let status = option.toolbox[0].feature.myAddPoint.iconStatus;\n                this.echartsInstance?.setOption({\n                  toolbox: {\n                    feature: {\n                      myAddPoint: {\n                        iconStatus: !status,\n                        icon: !status ? ADD_POINT_IMG_ON : ADD_POINT_IMG_OFF\n                      }\n                    }\n                  }\n                })\n              }\n            }\n          },\n        },\n        legend: {\n          data: chart.shapes.map(\n            (shape: Shape) => ({\n              name: shape.name,\n              icon: 'circle'\n            })\n          ),\n          show: chart.showLegend ?? false,\n          orient: 'vertical',\n          left: 'right',\n          padding: [60, 20],\n          type: 'scroll',\n          textStyle: {\n            width: 100,\n            fontWeight: 'bold',\n            overflow: 'break'\n          }\n        },\n        xAxis: {\n          type: chart.xAxisType,\n          name: chart.xAxisName,\n        },\n        yAxis: {\n          type: chart.yAxisType,\n          name: chart.yAxisName,\n        },\n        series: this.createSeries(chart.shapes),\n        animation: chart.hasAnimations,\n      };\n    }\n  }\n\n  createSeries(shapes: Shape[]): Array<LineSeriesOption | CustomSeriesOption | ScatterSeriesOption> {\n    let series: Array<LineSeriesOption | CustomSeriesOption | ScatterSeriesOption> = [];\n    shapes.forEach(\n      (shape: Shape) => {\n        switch (shape.variant) {\n          case ShapeVariant.TRACE:\n            series.push(this.createTrace(shape as Trace))\n            break;\n          default:\n            break;\n        }\n      }\n    );\n    return series;\n  }\n\n  createTrace(trace: Trace): LineSeriesOption | ScatterSeriesOption {\n    return {\n      type: trace.type,\n      name: trace.name,\n      data: trace.points.map(\n        (point: Point) => ({\n          value: [point.x, point.y],\n          symbol: point.symbol,\n          name: point.name,\n          symbolSize: point.symbolSize,\n          label: {\n            show: true,\n            position: 'bottom',\n            align: 'left',\n            verticalAlign: 'bottom',\n            formatter: () => `${point.name ?? ''}`,\n            color: '#000',\n            fontSize: 13,\n            padding: [0, 0, 0, 10],\n            width: 100,\n            overflow: 'truncate',\n            ellipsis: '...',\n            fontWeight: 'bold'\n          },\n          tooltip: {\n            formatter: ({ value }: { value: number[] }) => `\n              ${point.name ? `<strong>${point.name}</strong><br>` : ''}\n              <strong>${this.chart?.xAxisName}:</strong> ${value[0]}\n              <br>\n              <strong>${this.chart?.yAxisName}:</strong> ${value[1]}\n            `\n          }\n        })\n      ),\n      color: trace.color,\n      lineStyle: {\n        width: trace.width,\n        type: trace.style\n      },\n      smooth: trace.smooth ?? false\n    };\n  }\n\n}\n"]}

package/esm2020/lib/chart.module.mjs

@@ -0,0 +1,45 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { KiwiChartComponent } from './chart.component';
+import { NgxEchartsModule } from 'ngx-echarts';
+import * as echarts from 'echarts/core';
+import { TitleComponent, TooltipComponent, GridComponent, LegendComponent, DataZoomComponent, ToolboxComponent } from 'echarts/components';
+import { LineChart, ScatterChart } from 'echarts/charts';
+import { CanvasRenderer } from 'echarts/renderers';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-echarts";
+echarts.use([
+    TitleComponent,
+    TooltipComponent,
+    GridComponent,
+    LineChart,
+    CanvasRenderer,
+    LegendComponent,
+    DataZoomComponent,
+    ToolboxComponent,
+    ScatterChart
+]);
+export class KiwiChartModule {
+}
+KiwiChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KiwiChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartModule, declarations: [KiwiChartComponent], imports: [CommonModule, i1.NgxEchartsModule], exports: [KiwiChartComponent] });
+KiwiChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartModule, imports: [[
+            CommonModule,
+            NgxEchartsModule.forRoot({ echarts })
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: KiwiChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        KiwiChartComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        NgxEchartsModule.forRoot({ echarts })
+                    ],
+                    exports: [
+                        KiwiChartComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/constants/chart.constants.mjs

@@ -0,0 +1,3 @@
+export const ADD_POINT_IMG_OFF = "image://data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAEZklEQVRYhcWXX2xTVRzHP797t+FgSAkmpCskkGCYmcP23nZBmpiZYUKyIBIdUR80JiYmSnzQGPDBGNRoYsAXQ0wwvvgCYRqGgUj4o4txiRu9ZQUGqCNogm0lsNXVSGHt+flQumxlZR24+X1qz/n2+/2ec27v7/zgf4bMhNza2royn8+vF5HVwAPAfCAjIkljTKK+vv54b29v9j8N0NLSsriurm4r8DTwCHAd+F1ErqjqCLAUWAb4gTxwQlW/jMfj+wG96wBtbW33ZbPZrcDbgFHVfarabVnWD57njZXzW1tblxhjOlR1M7ARGDDGbDt16tSJGQcIhUKNItItIs3Ap8BHnuf9Nd1qSnBdtwl4D+gUkT0NDQ2v9fT05KsKEIlEIsaYg8AwsMnzvIvVGpcjHA4/p6pfqGpPbW3ts319faPlHGviF8dxVhljjohIoqamZt29mAPEYrG9xpjHRCQ0Nja2r7Oz0y7njA9Eo9GFhULhGHAN2HDy5Mm/78W8hHQ6nWxsbPxeRHaMjIz4UqnU0Ynz4zuQy+V2AUvy+fyTnuf9M51wJBJZ57ruhWpCeJ4XF5GXgTdDoVD7bQHC4fBq4CVVfSuRSPxRjagxJgCsroYLxeMADluWtYsJCy99+BA4G4/H91YreDcQke3Aw47jPDMeoKWlZbGqbhSRjwEzmwFisdhZ4JCIvDAeoLa2tgMwtm0fnk3zElS1G1gfjUYXQvEIOoCeqf6jswEROQTU5HK5dgBLRNYAZ+bCHMDzvKtAClgDxR1YdmtgLpEElgPUAAtU9Uo5IxQKhS3L6gXq7qTkuu6dKt7Pnuc1lQ+KyJ/GmIZSgBsicn85KZvNnvH5fFtUtVKAtcAbwJZK7saYyxWmFonItVKAqxRr+SQMDQ3dAA5WEnddFwDP87oqcSpBVf0i0gfFZ+ACsHKmIneL5ubmOorP3QUAS1WPAxva2tpq5iLAvHnzHgfq8/n8d1DcgQPAktHR0UfnIoCIbALiAwMDvwFY8Xh8CDgtIq/MtnkwGPQBW1T169KYBaCqO4DnHcdxZzOAbdvbARWR3ZMCxOPxAyLyk2VZn0x1a5kKInITuFmteTAYfBB4Hfhg4v2yVI5VRF5V1fClS5d2ViOYyWSOGGOi1XBd111k2/Y3wOlcLvfZxLnx1SaTybTf7x8CdgYCgWvJZLL/TqLDw8OFdDqdrMJ8PvAVxVdveyKRmHS7nrTdqVRqMBAIXFfVXYFAwBeNRo+fO3du2uaiEiKRyHJVPQo8BHR4nvdrOee2804mk71+v/888H4mk3nC7/efTqVSMy1WluM4LwL7gZxt2+2xWOz8VMSKnVEkEgkWCoXdIrIW2GdZ1p4VK1b82NXVVaj0m2Aw6LMsq0NEtgFNwOe5XG7b4OBgxRv2tL2h4zibReRdin3hVeAYcPFWRRsRkaUislxVm4E2iv1gt23b7/T39/8ynX7V3bHjOKtE5CkRaVfVJord8QIgA1ym+DI7pKrfzqSN+xdx6bFz0kwqIAAAAABJRU5ErkJggg==";
+export const ADD_POINT_IMG_ON = "image://data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAEUUlEQVRYhcWXbWiVZRjHf9f9nJ3Nt6ZTWr4FguFgYoUT3Dnb2RkTioaZmKP6IEQvZ2sy6FX7EK2IssggdK8ig74ok9oMRSF1ZzsvOJgjp8GKJAPTJk6dibmzc56rD8eZ285xZ8ut/8fnvu7/9btvHu7ruuB/lkwk2LOnfZlEHesUVoAsQHSmwnVRLgpyOuq0j4VeKfjrgQIU1AbmiWVtNaqbFB4H/gZ+By4D14BsYAmwEIgCx0G/6fC5mxHRSQN4m9oy7MH0raDvAzYi+1VpvSXOjlO+vKHR8SW7O+cPOWKlgm5UWC8iP9rKtkC56/iEAdy7gossh7Qi5AK7nJL+2TFf3sB4p7kL3xDOsVU/BjYDjebPSKW/ujiaEkBRY2iN2hwUuGoJG0743OdSTTzGqz78oqJ7UfEPDpkXOqvW3hgdY0aQ14SXq81RRU/fjliu/5IcoL3ctc+gHsR+Mj3N3r+5udlKCuDeG5xjW9oCnL8lGZsS0U5G/vKCLhWrFNGivv7FnycFMEOyE5jvUHn2lC/v1njGnsawq6g+1JsKRMCX3y3IqwhvF9aHS8YAuGuDKwReRvXdExWuP1IxFWVx/D1ITe3lrn3AYYPupFr/PTiAZcynwNmOPve+VA0nI6NsV1jpyQ49f/dbQW1gHuh6Qb6gWuypBPBXuM8ChxDZchdAjCkF7NsRc3gqkw9LlVZgnXtvcA6AMUIp4H9Qf/14skzkEOAwUVMCYFRlFeiZ6UgO4PcVXwEuGbVXARjQJYJcmi6AO7qIylIABzDLjle2EfLWB/NsJAQ4Ezmoxgudpz6UtOIJ/Nxe7s5JsNKH0dnDAIMGHhodMiNy48xNZ2aZEUkIYKuuFXhLRMqSAaB6IclCJkr/MMAVjdfyETpS9cwgcDCZd1FDGFWl3ec6kBQguRaCdEL8IeoFlk3CZFLKbf7JCSxRpRfAqOgx4GlvdZtjOgCy+geKgRkGOQFgrKhpAebrw2n50wEAugHo9lfknwcw/krXr4j2qBHfVKf2NrXNFaFMRL8d/havSspHwEsFtYHVUwlgDzq3A5pGRs0IgA6fuwU4aYz5KlHXktBMNQJEUk3uqT/5GFAF8sm9/WX8BkTUGN4A8vquLvoyFcPZkYGjBnWnEruuoSsTYt+D9PRnZdbduzaiKfXUBcvi7bdWBSoKdqdiPp5WN3TNnKWD3wErVWJrAj7PiGd/bFdcF3pPhR2gX2dnXXznQFlZbLLJPTXtS7EcrcCjKuapgC+/e3RMwrngzk00AV0q5s1EG++rajWF2eEtIuwALmNFN3S8VvRbotDkk1Fj6Ak7Rg3CWlT3q2UaH5l7IXi/G/E2tc21b6eVIrINyAH2mFhkm7+y+GayPePOhkV14Y2IfnhnLryi8IPAOVXtE7gmItmKLgXJBbyAgrTaJvZB8PXCX8bzT3k69taEl9sWzyl2iSA5wAJgFnAduAD0qHIo3aQfmcgY9w8YoaK2AOtXYQAAAABJRU5ErkJggg==";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/chart.models.mjs

@@ -0,0 +1,33 @@
+export var TraceType;
+(function (TraceType) {
+    TraceType["LINE"] = "line";
+    TraceType["SCATTER"] = "scatter";
+})(TraceType || (TraceType = {}));
+export var PointSymbol;
+(function (PointSymbol) {
+    PointSymbol["NONE"] = "none";
+    PointSymbol["CIRCLE"] = "circle";
+    PointSymbol["TRIANGLE"] = "triangle";
+    PointSymbol["PIN"] = "pin";
+    PointSymbol["DIAMOND"] = "diamond";
+})(PointSymbol || (PointSymbol = {}));
+export var TraceStyle;
+(function (TraceStyle) {
+    TraceStyle["SOLID"] = "solid";
+    TraceStyle["DASHED"] = "dashed";
+    TraceStyle["DOTTED"] = "dotted";
+})(TraceStyle || (TraceStyle = {}));
+export var AxisType;
+(function (AxisType) {
+    AxisType["VALUE"] = "value";
+    AxisType["CATEGORY"] = "category";
+    AxisType["TIME"] = "time";
+    AxisType["LOG"] = "log";
+})(AxisType || (AxisType = {}));
+export var ShapeVariant;
+(function (ShapeVariant) {
+    ShapeVariant[ShapeVariant["TRACE"] = 0] = "TRACE";
+    ShapeVariant[ShapeVariant["POLYGON"] = 1] = "POLYGON";
+    ShapeVariant[ShapeVariant["CIRCLE"] = 2] = "CIRCLE";
+})(ShapeVariant || (ShapeVariant = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of chart
+ */
+export * from './lib/chart.component';
+export * from './lib/chart.module';
+export * from './lib/models/chart.models';
+export * from './lib/constants/chart.constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2tpd2liaXQvY2hhcnQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjaGFydFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzL2NoYXJ0Lm1vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb25zdGFudHMvY2hhcnQuY29uc3RhbnRzJzsiXX0=