@kiwibit/chart 15.0.0 → 16.0.0

package/README.md

@@ -4,6 +4,8 @@
 
 ### Latest versions @npm:
 
+> **v16.x** for Angular >= **16.x**
+> 
 > **v15.x** for Angular >= **15.x**
 > 
 > **v14.x** for Angular >= **14.x**
@@ -53,6 +55,10 @@ npm install @kiwibit/chart
 
 # Latest Updates
 
+## [15.0.1] - 2022-11-30
+### Added
+- Added initial chart configuration if not passed as an input to the chart, in order to suppress the echarts warning.
+
 ## [15.0.0] - 2022-11-30
 ### Added
 - Upgrade to Angular 15

package/{esm2020 → esm2022}/kiwibit-chart.mjs

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

package/esm2022/lib/chart.component.mjs

@@ -0,0 +1,456 @@
+// Angular General
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { interval, Subject, takeUntil } from 'rxjs';
+// Kiwi Chart
+import { ADD_POINT_IMG_OFF_DARK, ADD_POINT_IMG_OFF_LIGHT, 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 "@angular/common";
+import * as i2 from "ngx-echarts";
+export class KiwiChartComponent {
+    constructor(cd) {
+        this.cd = cd;
+        /**
+         * The Chart Object rendered by the canvas. For all the available options refer
+         * to Chart interface in the models folder.
+         *
+         * @type {(Chart | null)}
+         * @memberof KiwiChartComponent
+         */
+        this.chart = null;
+        /**
+         * Width and Height of the chart area. The dimensions refer to the father component
+         * into which the kiwi-chart is inserted. For example in an empty page the width/height
+         * of the chart can take the whole available space in the page.
+         *
+         * @type {string}
+         * @memberof KiwiChartComponent
+         */
+        this.width = '100%';
+        this.height = '480px';
+        /**
+         * This property simply activates or not the dark theme of the chart
+         * defined by the Echarts library. In addition the background color can be custom
+         * so that the chart can match the background of the application in which it's used.
+         *
+         * @type {boolean}
+         * @memberof KiwiChartComponent
+         */
+        this.darkTheme = false;
+        /**
+         * Output event used to emit to the father component the coordinates
+         * of the point clicked in the chart area. This functionality to be used must
+         * have the property "clickToAddPoint" in the Chart object set to true.
+         *
+         * @type {EventEmitter<BasePoint>}
+         * @memberof KiwiChartComponent
+         */
+        this.addPoint = new EventEmitter();
+        /**
+         * When the cursor hovers the chart area it emits to the father component the
+         * x and y coordinates relative to the chart reference system.
+         *
+         * @type {EventEmitter<BasePoint>}
+         * @memberof KiwiChartComponent
+         */
+        this.chartHover = new EventEmitter();
+        /**
+         * The object used by echarts to initially create the Chart.
+         * Has a default configuration that can be totally overrided using specific properties.
+         *
+         * @type {EChartsOption}
+         * @memberof KiwiChartComponent
+         */
+        this.chartOption = {
+            title: {
+                text: 'Kiwi Chart'
+            },
+            xAxis: {
+                name: 'X'
+            },
+            yAxis: {
+                name: 'Y'
+            },
+            series: [
+                {
+                    type: TraceType.LINE,
+                    data: [[0, 0]]
+                }
+            ]
+        };
+        /**
+         * The instance of the Chart.
+         *
+         * @type {(ECharts | null)}
+         * @memberof KiwiChartComponent
+         */
+        this.echartsInstance = null;
+        /**
+         * Used to perform actions (as point addition based on the cursor position) on the chart.
+         *
+         * @type {(zrender.ZRenderType | null)}
+         * @memberof KiwiChartComponent
+         */
+        this.zr = null;
+        /**
+         * Subject used to unsubscribe once the component gets destroyed.
+         *
+         * @private
+         * @type {Subject<void>}
+         * @memberof KiwiChartComponent
+         */
+        this.destroyed$ = new Subject();
+        /**
+         * Default number of decimals that can have
+         * the values on the x and y axes.
+         *
+         * @private
+         * @type {number}
+         * @memberof KiwiChartComponent
+         */
+        this.MAX_DECIMALS = 3;
+        this.legendSelected = {};
+        this.isLegendClicked = false;
+    }
+    ngOnInit() {
+        /**
+         * This is a manual change detection running every 200ms, the memory should not be much afflicted.
+         * It's necessary because when interacting with the chart (for example addPoint),
+         * Angular loses the change detection and the point is not added in the chart canvas.
+         */
+        interval(200)
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe({
+            next: () => {
+                this.cd.detectChanges();
+            }
+        });
+    }
+    onChartInit(ec) {
+        this.echartsInstance = ec;
+        this.setupZrEventHandler(ec);
+        this.setupLegendEventHandler(ec);
+    }
+    /**
+     * intercept a selection change event on the legend and save the state
+     * of all selections on the supporting variable legendSelected
+     *
+     * @param ec
+     */
+    setupLegendEventHandler(ec) {
+        if (this.echartsInstance != null) {
+            this.echartsInstance.on('legendselectchanged', (params) => {
+                this.isLegendClicked = true;
+                this.legendSelected = params.selected;
+            });
+        }
+    }
+    setupZrEventHandler(ec) {
+        this.zr = ec.getZr();
+        /**
+         * Intercepts the click event on the chart (if the clickToAddPoint property is set to true)
+         * and emits the point coordinates to the father component.
+         */
+        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);
+                }
+            }
+        });
+        /**
+         * This is used perform custom actions when the mouse is hovering the chart area
+         */
+        this.zr.on('mousemove', params => {
+            const pointInPixel = [params.offsetX, params.offsetY];
+            const pointInGrid = ec.convertFromPixel('grid', pointInPixel);
+            /*
+             * Logic to emit to the father component the x and y cdinates when the
+             * cursor is hovering the chart area .
+             */
+            if (ec.containPixel('grid', pointInPixel) && pointInGrid) {
+                let newPoint = {
+                    x: +pointInGrid[0].toFixed(3),
+                    y: +pointInGrid[1].toFixed(3)
+                };
+                this.chartHover.emit(newPoint);
+            }
+            /* Logic to change the cursor icon when the "Click to Add Point" feature is active and viceversa. */
+            const option = ec.getOption();
+            const addPointIsActive = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;
+            if (addPointIsActive) {
+                this.zr?.setCursorStyle(ec.containPixel('grid', pointInPixel) ? 'copy' : 'default');
+            }
+        });
+    }
+    getLegendItemSelection(shape) {
+        if (this.isLegendClicked) {
+            return this.legendSelected[shape.name] ?? true;
+        }
+        else {
+            return shape.selectedByDefault ?? true;
+        }
+    }
+    ngOnChanges(changes) {
+        let chart = changes['chart']?.currentValue;
+        if (chart) {
+            this.chartOption = {
+                title: {
+                    text: chart.title,
+                },
+                grid: {
+                    width: '70%'
+                },
+                backgroundColor: this.darkTheme ? this.darkThemeBackground ?? '#303030' : 'transparent', tooltip: {
+                    axisPointer: {
+                        type: 'cross',
+                        crossStyle: {
+                            color: '#bebebe'
+                        }
+                    }
+                },
+                toolbox: {
+                    orient: 'horizontal',
+                    left: 'center',
+                    top: '25px',
+                    feature: {
+                        dataZoom: {
+                            brushStyle: {
+                                borderColor: '#000',
+                                borderWidth: 1,
+                                borderType: 'dashed'
+                            },
+                            emphasis: {
+                                iconStyle: {
+                                    textPosition: 'top'
+                                }
+                            }
+                        },
+                        saveAsImage: {
+                            emphasis: {
+                                iconStyle: {
+                                    textPosition: 'top'
+                                }
+                            }
+                        },
+                        restore: {
+                            emphasis: {
+                                iconStyle: {
+                                    textPosition: 'top'
+                                }
+                            }
+                        },
+                        myAddPoint: {
+                            show: chart.clickToAddPoint ?? false,
+                            title: chart.addPointCustomName ?? 'Add Point',
+                            icon: this.darkTheme ? ADD_POINT_IMG_OFF_DARK : ADD_POINT_IMG_OFF_LIGHT,
+                            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 : this.darkTheme ? ADD_POINT_IMG_OFF_DARK : ADD_POINT_IMG_OFF_LIGHT
+                                            }
+                                        }
+                                    }
+                                });
+                            },
+                            emphasis: {
+                                iconStyle: {
+                                    textPosition: 'top'
+                                }
+                            }
+                        }
+                    },
+                },
+                dataZoom: [
+                    {
+                        type: 'inside',
+                        xAxisIndex: [0],
+                        throttle: 0,
+                        filterMode: 'none',
+                        disabled: !chart.scrollToZoom ?? true
+                    },
+                    {
+                        type: 'inside',
+                        yAxisIndex: [0],
+                        throttle: 0,
+                        filterMode: 'none',
+                        disabled: !chart.scrollToZoom ?? true
+                    },
+                ],
+                legend: {
+                    inactiveColor: this.darkTheme ? '#8b8b8b' : '#ccc',
+                    data: chart.shapes.map((shape) => ({
+                        name: shape.name,
+                        icon: 'circle',
+                    })),
+                    selected: chart.shapes.reduce((accumulator, shape) => ({
+                        ...accumulator,
+                        [shape.name]: this.getLegendItemSelection(shape),
+                    }), {}),
+                    show: chart.showLegend ?? false,
+                    orient: 'vertical',
+                    left: 'right',
+                    padding: [60, 20],
+                    type: 'scroll',
+                    textStyle: {
+                        width: 120,
+                        fontWeight: 'bold',
+                        overflow: 'break'
+                    }
+                },
+                xAxis: {
+                    type: chart.xAxisType,
+                    name: chart.xAxisUom ? `${chart.xAxisName} [ ${chart.xAxisUom} ]` : chart.xAxisName,
+                    nameLocation: 'middle',
+                    nameGap: 30,
+                    splitLine: {
+                        show: chart.showGrid ?? true,
+                        lineStyle: {
+                            color: this.darkTheme ? '#595959' : '#ccc'
+                        }
+                    },
+                    min: chart.xMin?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),
+                    max: chart.xMax?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),
+                },
+                yAxis: {
+                    type: chart.yAxisType,
+                    name: chart.yAxisUom ? `${chart.yAxisName} [ ${chart.yAxisUom} ]` : chart.yAxisName,
+                    nameLocation: 'middle',
+                    nameGap: 50,
+                    splitLine: {
+                        show: chart.showGrid ?? true,
+                        lineStyle: {
+                            color: this.darkTheme ? '#595959' : '#ccc'
+                        }
+                    },
+                    min: chart.yMin?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),
+                    max: chart.yMax?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),
+                },
+                series: this.createSeries(chart.shapes),
+                animation: chart.hasAnimations,
+                animationDuration: chart.animationDuration ?? 500,
+                animationEasing: 'cubicOut'
+            };
+        }
+    }
+    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 ?? 'circle',
+                name: point.name,
+                symbolSize: point.symbolSize ?? 2,
+                itemStyle: {
+                    color: point.color
+                },
+                emphasis: {
+                    disabled: true
+                },
+                label: {
+                    show: true,
+                    position: 'bottom',
+                    align: 'left',
+                    verticalAlign: 'bottom',
+                    formatter: () => `${point.name ?? ''}`,
+                    fontSize: 13,
+                    padding: [0, 0, 0, 10],
+                    width: 100,
+                    overflow: 'truncate',
+                    ellipsis: '...',
+                    fontWeight: 'bold',
+                    color: this.darkTheme ? '#fff' : '#000'
+                },
+                tooltip: {
+                    formatter: ({ value }) => `
+              <strong>${this.chart?.xAxisName}:</strong> ${value[0].toFixed(3).replace(/[.,]000$/, "")}
+              <br>
+              <strong>${this.chart?.yAxisName}:</strong> ${value[1].toFixed(3).replace(/[.,]000$/, "")}
+            `
+                }
+            })),
+            color: trace.color,
+            lineStyle: {
+                width: trace.width,
+                type: trace.style,
+                opacity: trace.opacity ?? 1
+            },
+            smooth: trace.smooth ?? false
+        };
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KiwiChartComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: KiwiChartComponent, selector: "kiwi-chart", inputs: { chart: "chart", width: "width", height: "height", darkTheme: "darkTheme", darkThemeBackground: "darkThemeBackground" }, outputs: { addPoint: "addPoint", chartHover: "chartHover" }, usesOnChanges: true, ngImport: i0, template: `
+    <div 
+      echarts 
+      [options]="chartOption" 
+      [ngStyle]="{
+        'width': width,
+        'height': height
+      }"
+      (chartInit)="onChartInit($event)"
+      [theme]="darkTheme ? 'dark' : ''"
+    ></div> 
+  `, isInline: true, styles: [""], dependencies: [{ kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "initOpts", "merge", "autoResize", "loading", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartHighlight", "chartDownplay", "chartSelectChanged", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendLegendSelectAll", "chartLegendLegendInverseSelect", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartGraphRoam", "chartGeoRoam", "chartTreeRoam", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartGeoSelectChanged", "chartGeoSelected", "chartGeoUnselected", "chartAxisAreaSelected", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartGlobalCursorTaken", "chartRendered", "chartFinished"], exportAs: ["echarts"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KiwiChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'kiwi-chart', template: `
+    <div 
+      echarts 
+      [options]="chartOption" 
+      [ngStyle]="{
+        'width': width,
+        'height': height
+      }"
+      (chartInit)="onChartInit($event)"
+      [theme]="darkTheme ? 'dark' : ''"
+    ></div> 
+  ` }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { chart: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], darkTheme: [{
+                type: Input
+            }], darkThemeBackground: [{
+                type: Input
+            }], addPoint: [{
+                type: Output
+            }], chartHover: [{
+                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":["// Angular General\r\nimport { ChangeDetectorRef, Component, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges } from '@angular/core';\r\nimport { interval, Subject, takeUntil } from 'rxjs';\r\n// Echarts\r\nimport { CustomSeriesOption, ECharts, EChartsOption, LineSeriesOption, ScatterSeriesOption, zrender } from 'echarts';\r\n// Kiwi Chart\r\nimport { ADD_POINT_IMG_OFF_DARK, ADD_POINT_IMG_OFF_LIGHT, ADD_POINT_IMG_ON } from './constants/chart.constants';\r\nimport { Chart, Shape, ShapeVariant, Trace, Point, BasePoint, TraceType } from './models/chart.models';\r\n@Component({\r\n  selector: 'kiwi-chart',\r\n  template: `\r\n    <div \r\n      echarts \r\n      [options]=\"chartOption\" \r\n      [ngStyle]=\"{\r\n        'width': width,\r\n        'height': height\r\n      }\"\r\n      (chartInit)=\"onChartInit($event)\"\r\n      [theme]=\"darkTheme ? 'dark' : ''\"\r\n    ></div> \r\n  `,\r\n  styles: [`\r\n  `]\r\n})\r\nexport class KiwiChartComponent implements OnInit, OnChanges, OnDestroy {\r\n\r\n  /**\r\n   * The Chart Object rendered by the canvas. For all the available options refer \r\n   * to Chart interface in the models folder.\r\n   *\r\n   * @type {(Chart | null)}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  @Input() chart: Chart | null = null;\r\n\r\n  /**\r\n   * Width and Height of the chart area. The dimensions refer to the father component \r\n   * into which the kiwi-chart is inserted. For example in an empty page the width/height \r\n   * of the chart can take the whole available space in the page.\r\n   *\r\n   * @type {string}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  @Input() width: string = '100%';\r\n  @Input() height: string = '480px';\r\n\r\n  /**\r\n   * This property simply activates or not the dark theme of the chart\r\n   * defined by the Echarts library. In addition the background color can be custom\r\n   * so that the chart can match the background of the application in which it's used.\r\n   *\r\n   * @type {boolean}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  @Input() darkTheme: boolean = false;\r\n  @Input() darkThemeBackground?: string;\r\n\r\n  /**\r\n   * Output event used to emit to the father component the coordinates\r\n   * of the point clicked in the chart area. This functionality to be used must\r\n   * have the property \"clickToAddPoint\" in the Chart object set to true.\r\n   *\r\n   * @type {EventEmitter<BasePoint>}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  @Output() addPoint: EventEmitter<BasePoint> = new EventEmitter<BasePoint>();\r\n\r\n  /**\r\n   * When the cursor hovers the chart area it emits to the father component the\r\n   * x and y coordinates relative to the chart reference system.\r\n   *\r\n   * @type {EventEmitter<BasePoint>}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  @Output() chartHover: EventEmitter<BasePoint> = new EventEmitter<BasePoint>();\r\n\r\n  /**\r\n   * The object used by echarts to initially create the Chart.\r\n   * Has a default configuration that can be totally overrided using specific properties.\r\n   *\r\n   * @type {EChartsOption}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  chartOption: EChartsOption = {\r\n    title: {\r\n      text: 'Kiwi Chart'\r\n    },\r\n    xAxis: {\r\n      name: 'X'\r\n    },\r\n    yAxis: {\r\n      name: 'Y'\r\n    },\r\n    series: [\r\n      {\r\n        type: TraceType.LINE,\r\n        data: [[0, 0]]\r\n      }\r\n    ]\r\n  };\r\n\r\n  /**\r\n   * The instance of the Chart.\r\n   *\r\n   * @type {(ECharts | null)}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  echartsInstance: ECharts | null = null;\r\n\r\n  /**\r\n   * Used to perform actions (as point addition based on the cursor position) on the chart.\r\n   *\r\n   * @type {(zrender.ZRenderType | null)}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  zr: zrender.ZRenderType | null = null;\r\n\r\n  /**\r\n   * Subject used to unsubscribe once the component gets destroyed.\r\n   *\r\n   * @private\r\n   * @type {Subject<void>}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  private destroyed$: Subject<void> = new Subject<void>();\r\n\r\n  /**\r\n   * Default number of decimals that can have\r\n   * the values on the x and y axes.\r\n   *\r\n   * @private\r\n   * @type {number}\r\n   * @memberof KiwiChartComponent\r\n   */\r\n  private readonly MAX_DECIMALS: number = 3;\r\n\r\n  private legendSelected: { [key: string]: boolean } = {};\r\n  private isLegendClicked: boolean = false;\r\n\r\n  constructor(\r\n    private cd: ChangeDetectorRef\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    /** \r\n     * This is a manual change detection running every 200ms, the memory should not be much afflicted.\r\n     * It's necessary because when interacting with the chart (for example addPoint),\r\n     * Angular loses the change detection and the point is not added in the chart canvas.\r\n     */\r\n    interval(200)\r\n      .pipe(\r\n        takeUntil(this.destroyed$)\r\n      )\r\n      .subscribe({\r\n        next: () => {\r\n          this.cd.detectChanges();\r\n        }\r\n      });\r\n  }\r\n\r\n  onChartInit(ec: ECharts) {\r\n    this.echartsInstance = ec;\r\n    this.setupZrEventHandler(ec);\r\n    this.setupLegendEventHandler(ec);\r\n  }\r\n\r\n  /**\r\n   * intercept a selection change event on the legend and save the state \r\n   * of all selections on the supporting variable legendSelected\r\n   * \r\n   * @param ec \r\n   */\r\n  setupLegendEventHandler(ec: ECharts) {\r\n    if(this.echartsInstance != null) {\r\n      this.echartsInstance.on('legendselectchanged', (params: any) => {\r\n        this.isLegendClicked = true;\r\n        this.legendSelected = params.selected;\r\n      });\r\n    }\r\n     \r\n  }\r\n\r\n  setupZrEventHandler(ec: ECharts) {\r\n    this.zr = ec.getZr();\r\n    /** \r\n     * Intercepts the click event on the chart (if the clickToAddPoint property is set to true)\r\n     * and emits the point coordinates to the father component.\r\n     */\r\n    this.zr.on('click', params => {\r\n      let option: any = ec.getOption();\r\n      let active = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;\r\n      if (active && this.chart?.clickToAddPoint) {\r\n        const pointInPixel = [params.offsetX, params.offsetY];\r\n        const pointInGrid = ec.convertFromPixel('grid', pointInPixel);\r\n        if (ec.containPixel('grid', pointInPixel) && pointInGrid) {\r\n          let newPoint: { x: number, y: number } = {\r\n            x: +pointInGrid[0].toFixed(3),\r\n            y: +pointInGrid[1].toFixed(3)\r\n          };\r\n          this.addPoint.emit(newPoint);\r\n        }\r\n      }\r\n    });\r\n    /** \r\n     * This is used perform custom actions when the mouse is hovering the chart area\r\n     */\r\n    this.zr.on('mousemove', params => {\r\n      const pointInPixel = [params.offsetX, params.offsetY];\r\n      const pointInGrid = ec.convertFromPixel('grid', pointInPixel);\r\n      /* \r\n       * Logic to emit to the father component the x and y cdinates when the\r\n       * cursor is hovering the chart area .\r\n       */\r\n      if (ec.containPixel('grid', pointInPixel) && pointInGrid) {\r\n        let newPoint: { x: number, y: number } = {\r\n          x: +pointInGrid[0].toFixed(3),\r\n          y: +pointInGrid[1].toFixed(3)\r\n        };\r\n        this.chartHover.emit(newPoint);\r\n      }\r\n      /* Logic to change the cursor icon when the \"Click to Add Point\" feature is active and viceversa. */\r\n      const option: any = ec.getOption();\r\n      const addPointIsActive = option?.toolbox?.[0]?.feature?.myAddPoint?.iconStatus;\r\n      if (addPointIsActive) {\r\n        this.zr?.setCursorStyle(\r\n          ec.containPixel('grid', pointInPixel) ? 'copy' : 'default'\r\n        );\r\n      }\r\n    });\r\n  }\r\n\r\n  getLegendItemSelection(shape: Shape): boolean {\r\n    if(this.isLegendClicked) {\r\n      return this.legendSelected[shape.name as string] ?? true;\r\n    }\r\n    else {\r\n      return shape.selectedByDefault ?? true\r\n    }\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    let chart: Chart = changes['chart']?.currentValue;\r\n    if (chart) {\r\n      this.chartOption = {\r\n        title: {\r\n          text: chart.title,\r\n        },\r\n        grid: {\r\n          width: '70%'\r\n        },\r\n        backgroundColor: this.darkTheme ? this.darkThemeBackground ?? '#303030' : 'transparent', tooltip: {\r\n          axisPointer: {\r\n            type: 'cross',\r\n            crossStyle: {\r\n              color: '#bebebe'\r\n            }\r\n          }\r\n        },\r\n        toolbox: {\r\n          orient: 'horizontal',\r\n          left: 'center',\r\n          top: '25px',\r\n          feature: {\r\n            dataZoom: {\r\n              brushStyle: {\r\n                borderColor: '#000',\r\n                borderWidth: 1,\r\n                borderType: 'dashed'\r\n              },\r\n              emphasis: {\r\n                iconStyle: {\r\n                  textPosition: 'top'\r\n                }\r\n              }\r\n            },\r\n            saveAsImage: {\r\n              emphasis: {\r\n                iconStyle: {\r\n                  textPosition: 'top'\r\n                }\r\n              }\r\n            },\r\n            restore: {\r\n              emphasis: {\r\n                iconStyle: {\r\n                  textPosition: 'top'\r\n                }\r\n              }\r\n            },\r\n            myAddPoint: {\r\n              show: chart.clickToAddPoint ?? false,\r\n              title: chart.addPointCustomName ?? 'Add Point',\r\n              icon: this.darkTheme ? ADD_POINT_IMG_OFF_DARK : ADD_POINT_IMG_OFF_LIGHT,\r\n              iconStatus: false,\r\n              onclick: () => {             \r\n                let option: any = this.echartsInstance?.getOption();\r\n                let status = option.toolbox[0].feature.myAddPoint.iconStatus;\r\n                this.echartsInstance?.setOption({\r\n                  toolbox: {\r\n                    feature: {\r\n                      myAddPoint: {\r\n                        iconStatus: !status,\r\n                        icon: !status ? ADD_POINT_IMG_ON : this.darkTheme ? ADD_POINT_IMG_OFF_DARK : ADD_POINT_IMG_OFF_LIGHT\r\n                      }\r\n                    }\r\n                  }\r\n                });\r\n              },\r\n              emphasis: { \r\n                iconStyle: {\r\n                  textPosition: 'top'\r\n                }\r\n              }\r\n            }\r\n          },\r\n        },\r\n        dataZoom: [\r\n          {\r\n            type: 'inside',\r\n            xAxisIndex: [0],\r\n            throttle: 0,\r\n            filterMode: 'none',\r\n            disabled: !chart.scrollToZoom ?? true\r\n          },\r\n          {\r\n            type: 'inside',\r\n            yAxisIndex: [0],\r\n            throttle: 0,\r\n            filterMode: 'none',\r\n            disabled: !chart.scrollToZoom ?? true\r\n          },\r\n        ],\r\n        legend: {\r\n          inactiveColor: this.darkTheme ? '#8b8b8b' : '#ccc',\r\n          data: chart.shapes.map(\r\n            (shape: Shape) => ({\r\n              name: shape.name,\r\n              icon: 'circle',\r\n            })\r\n          ),\r\n          selected: chart.shapes.reduce(\r\n            (accumulator, shape: Shape) => ({ \r\n              ...accumulator, \r\n              [shape.name as string]: this.getLegendItemSelection(shape),\r\n            }), \r\n          {}),\r\n          show: chart.showLegend ?? false,\r\n          orient: 'vertical',\r\n          left: 'right',\r\n          padding: [60, 20],\r\n          type: 'scroll',\r\n          textStyle: {\r\n            width: 120,\r\n            fontWeight: 'bold',\r\n            overflow: 'break'\r\n          }\r\n        },\r\n        xAxis: {\r\n          type: chart.xAxisType,\r\n          name: chart.xAxisUom ? `${chart.xAxisName} [ ${chart.xAxisUom} ]` : chart.xAxisName,\r\n          nameLocation: 'middle',\r\n          nameGap: 30,\r\n          splitLine: {\r\n            show: chart.showGrid ?? true,\r\n            lineStyle: {\r\n              color: this.darkTheme ? '#595959' : '#ccc'\r\n            }\r\n          },\r\n          min: chart.xMin?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),\r\n          max: chart.xMax?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),\r\n        },\r\n        yAxis: {\r\n          type: chart.yAxisType,\r\n          name: chart.yAxisUom ? `${chart.yAxisName} [ ${chart.yAxisUom} ]` : chart.yAxisName,\r\n          nameLocation: 'middle',\r\n          nameGap: 50,\r\n          splitLine: {\r\n            show: chart.showGrid ?? true,\r\n            lineStyle: {\r\n              color: this.darkTheme ? '#595959' : '#ccc'\r\n            }\r\n          },\r\n          min: chart.yMin?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),\r\n          max: chart.yMax?.toFixed(chart.maxAxesDecimals ?? this.MAX_DECIMALS),\r\n        },\r\n        series: this.createSeries(chart.shapes),\r\n        animation: chart.hasAnimations,\r\n        animationDuration: chart.animationDuration ?? 500,\r\n        animationEasing: 'cubicOut'\r\n      };\r\n    }\r\n  }\r\n\r\n  createSeries(shapes: Shape[]): Array<LineSeriesOption | CustomSeriesOption | ScatterSeriesOption> {\r\n    let series: Array<LineSeriesOption | CustomSeriesOption | ScatterSeriesOption> = [];\r\n    shapes.forEach(\r\n      (shape: Shape) => {\r\n        switch (shape.variant) {\r\n          case ShapeVariant.TRACE:\r\n            series.push(this.createTrace(shape as Trace))\r\n            break;\r\n          default:\r\n            break;\r\n        }\r\n      }\r\n    );\r\n    return series;\r\n  }\r\n\r\n  createTrace(trace: Trace): LineSeriesOption | ScatterSeriesOption {\r\n    return {\r\n      type: trace.type,\r\n      name: trace.name,\r\n      data: trace.points.map(\r\n        (point: Point) => ({\r\n          value: [point.x, point.y],\r\n          symbol: point.symbol ?? 'circle',\r\n          name: point.name,\r\n          symbolSize: point.symbolSize ?? 2,\r\n          itemStyle: {\r\n            color: point.color\r\n          },\r\n          emphasis: {\r\n            disabled: true\r\n          },\r\n          label: {\r\n            show: true,\r\n            position: 'bottom',\r\n            align: 'left',\r\n            verticalAlign: 'bottom',\r\n            formatter: () => `${point.name ?? ''}`,\r\n            fontSize: 13,\r\n            padding: [0, 0, 0, 10],\r\n            width: 100,\r\n            overflow: 'truncate',\r\n            ellipsis: '...',\r\n            fontWeight: 'bold',\r\n            color: this.darkTheme ? '#fff' : '#000'\r\n          },\r\n          tooltip: {\r\n            formatter: ({ value }: { value: number[] }) => `\r\n              <strong>${this.chart?.xAxisName}:</strong> ${value[0].toFixed(3).replace(/[.,]000$/, \"\")}\r\n              <br>\r\n              <strong>${this.chart?.yAxisName}:</strong> ${value[1].toFixed(3).replace(/[.,]000$/, \"\")}\r\n            `\r\n          }\r\n        })\r\n      ),\r\n      color: trace.color,\r\n      lineStyle: {\r\n        width: trace.width,\r\n        type: trace.style,\r\n        opacity: trace.opacity ?? 1\r\n      },\r\n      smooth: trace.smooth ?? false\r\n    };\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.destroyed$.next();\r\n    this.destroyed$.complete();\r\n  }\r\n\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/chart.module.mjs

@@ -1,43 +1,43 @@
-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: "15.0.1", ngImport: i0, type: KiwiChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-KiwiChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.1", ngImport: i0, type: KiwiChartModule, declarations: [KiwiChartComponent], imports: [CommonModule, i1.NgxEchartsModule], exports: [KiwiChartComponent] });
-KiwiChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.1", ngImport: i0, type: KiwiChartModule, imports: [CommonModule,
-        NgxEchartsModule.forRoot({ echarts })] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.1", 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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
+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 {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KiwiChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: KiwiChartModule, declarations: [KiwiChartComponent], imports: [CommonModule, i1.NgxEchartsModule], exports: [KiwiChartComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KiwiChartModule, imports: [CommonModule,
+            NgxEchartsModule.forRoot({ echarts })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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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