@tetacom/svg-charts 1.4.21 → 1.4.23

package/esm2022/chart/chart-container/series/linear-series-base.mjs

@@ -0,0 +1,210 @@
+import { SeriesBaseComponent } from '../../base/series-base.component';
+import { Component, Input, } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, tap, withLatestFrom } from 'rxjs';
+import * as d3 from 'd3';
+import { TooltipTracking } from '../../model/enum/tooltip-tracking';
+import { ClipPointsDirection } from '../../model/enum/clip-points-direction';
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/chart.service";
+import * as i2 from "../../service/scale.service";
+import * as i3 from "../../service/zoom.service";
+export class LinearSeriesBase extends SeriesBaseComponent {
+    svc;
+    cdr;
+    scaleService;
+    zoomService;
+    element;
+    defaultClipPointsMapping = new Map();
+    transform;
+    display;
+    path;
+    x;
+    y;
+    markers;
+    __series;
+    _update = new BehaviorSubject(null);
+    set series(series) {
+        this.__series = series;
+        this.markers = this.__series.data?.filter((_) => _?.marker && _?.x !== undefined && _?.y !== undefined && _?.x !== null && _?.y !== null);
+    }
+    get series() {
+        return this.__series;
+    }
+    constructor(svc, cdr, scaleService, zoomService, element) {
+        super(svc, cdr, scaleService, zoomService, element);
+        this.svc = svc;
+        this.cdr = cdr;
+        this.scaleService = scaleService;
+        this.zoomService = zoomService;
+        this.element = element;
+    }
+    ngOnInit() {
+        const filterX = (min, max) => (point, idx, arr) => {
+            const bigger = min > max ? min : max;
+            const smaller = min > max ? max : min;
+            return (point.x <= bigger ||
+                point.x1 <= bigger ||
+                (arr[idx - 1] && arr[idx - 1].x <= bigger) ||
+                (arr[idx - 1] && arr[idx - 1].x1 <= bigger)) &&
+                (point.x >= smaller ||
+                    point.x1 >= smaller ||
+                    (arr[idx + 1] && arr[idx + 1].x >= smaller) ||
+                    (arr[idx + 1] && arr[idx + 1].x1 >= smaller));
+        };
+        const filterY = (min, max) => (point, idx, arr) => {
+            const bigger = min > max ? min : max;
+            const smaller = min > max ? max : min;
+            return (point.y <= bigger ||
+                point.y1 <= bigger ||
+                (arr[idx - 1] && arr[idx - 1].y <= bigger) ||
+                (arr[idx - 1] && arr[idx - 1].y1 <= bigger)) &&
+                (point.y >= smaller ||
+                    point.y1 >= smaller ||
+                    (arr[idx + 1] && arr[idx + 1].y >= smaller) ||
+                    (arr[idx + 1] && arr[idx + 1].y1 >= smaller));
+        };
+        this.defaultClipPointsMapping.set(ClipPointsDirection.x, filterX);
+        this.defaultClipPointsMapping.set(ClipPointsDirection.y, filterY);
+        this.transform = this.svc.pointerMove.pipe(withLatestFrom(this.scaleService.scales), map((data) => {
+            const [event, { x, y }] = data;
+            return this.getTransform(event, x.get(this.series.xAxisIndex).scale, y.get(this.series.yAxisIndex).scale);
+        }), tap(() => setTimeout(() => this.cdr.detectChanges())));
+        this.path = combineLatest([this.scaleService.scales, this._update]).pipe(map(([data]) => {
+            const { x, y } = data;
+            this.x = x.get(this.series.xAxisIndex)?.scale;
+            this.y = y.get(this.series.yAxisIndex)?.scale;
+            if (!this.x || !this.y) {
+                return '';
+            }
+            const filter = this.defaultClipPointsMapping.get(this.series.clipPointsDirection);
+            const line = d3
+                .line()
+                .defined((point) => point.x !== null &&
+                point.y !== null &&
+                point.x !== undefined &&
+                point.y !== undefined &&
+                !isNaN(point.x) &&
+                !isNaN(point.y))
+                .x((point) => this.x(point.x))
+                .y((point) => this.y(point.y));
+            let filteredData = this.series.data;
+            if (this.series.clipPointsDirection === ClipPointsDirection.x) {
+                let [min, max] = this.x.domain();
+                min = min instanceof Date ? min.getTime() : min;
+                max = max instanceof Date ? max.getTime() : max;
+                filteredData = filteredData?.filter(filter(min, max));
+            }
+            if (this.series.clipPointsDirection === ClipPointsDirection.y) {
+                let [min, max] = this.y.domain();
+                min = min instanceof Date ? min.getTime() : min;
+                max = max instanceof Date ? max.getTime() : max;
+                filteredData = filteredData?.filter(filter(min, max));
+            }
+            return line(filteredData);
+        }));
+    }
+    ngOnDestroy() {
+        this.svc.setTooltip({
+            point: null,
+            series: this.series,
+        });
+    }
+    ngAfterViewInit() {
+    }
+    getTransform(event, scaleX, scaleY) {
+        if (event.type === 'mouseleave') {
+            return null;
+        }
+        const mouse = [event?.offsetX, event?.offsetY];
+        const tooltipTracking = this.config?.tooltip?.tracking;
+        const lineIntersection = (p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y) => {
+            const rV = {};
+            let s1_x, s1_y, s2_x, s2_y;
+            s1_x = p1_x - p0_x;
+            s1_y = p1_y - p0_y;
+            s2_x = p3_x - p2_x;
+            s2_y = p3_y - p2_y;
+            let s, t;
+            s =
+                (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) /
+                    (-s2_x * s1_y + s1_x * s2_y);
+            t =
+                (s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) /
+                    (-s2_x * s1_y + s1_x * s2_y);
+            if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+                // Collision detected
+                rV.x = p0_x + t * s1_x;
+                rV.y = p0_y + t * s1_y;
+            }
+            return rV;
+        };
+        if (tooltipTracking === TooltipTracking.x) {
+            const bisect = d3.bisector((_) => _.x).right;
+            const pointer = mouse[0];
+            let x0 = scaleX.invert(pointer);
+            if (x0 instanceof Date) {
+                x0 = x0.getTime();
+            }
+            const rightId = bisect(this.series.data, x0);
+            const range = scaleY.range();
+            const intersect = lineIntersection(pointer, range[0], pointer, Number.MAX_SAFE_INTEGER, scaleX(this.series.data[rightId - 1]?.x), scaleY(this.series.data[rightId - 1]?.y), scaleX(this.series.data[rightId]?.x), scaleY(this.series.data[rightId]?.y));
+            const x = scaleX.invert(intersect.x);
+            const y = scaleY.invert(intersect.y);
+            if (x !== null && x !== undefined && !isNaN(x) && y !== null && y !== undefined && !isNaN(y)) {
+                this.svc.setTooltip({
+                    point: { x: scaleX.invert(intersect.x), y: scaleY.invert(intersect.y) },
+                    series: this.series,
+                });
+            }
+            else {
+                this.svc.setTooltip({
+                    point: null,
+                    series: this.series,
+                });
+            }
+            return {
+                x: intersect.x,
+                y: intersect.y,
+            };
+        }
+        if (tooltipTracking === TooltipTracking.y) {
+            const bisect = d3.bisector((_) => _.y).right;
+            let y0 = scaleY.invert(mouse[1]);
+            if (y0 instanceof Date) {
+                y0 = y0.getTime();
+            }
+            const rightId = bisect(this.series.data, y0);
+            const range = scaleX.range();
+            const intersect = lineIntersection(range[0], mouse[1], Number.MAX_SAFE_INTEGER, mouse[1], scaleX(this.series.data[rightId - 1]?.x), scaleY(this.series.data[rightId - 1]?.y), scaleX(this.series.data[rightId]?.x), scaleY(this.series.data[rightId]?.y));
+            const x = scaleX.invert(intersect.x);
+            const y = scaleY.invert(intersect.y);
+            if (x !== null && x !== undefined && !isNaN(x) && y !== null && y !== undefined && !isNaN(y)) {
+                this.svc.setTooltip({
+                    point: { x: scaleX.invert(intersect.x), y: scaleY.invert(intersect.y) },
+                    series: this.series,
+                });
+            }
+            else {
+                this.svc.setTooltip({
+                    point: null,
+                    series: this.series,
+                });
+            }
+            return {
+                x: intersect.x,
+                y: intersect.y,
+            };
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: LinearSeriesBase, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ScaleService }, { token: i3.ZoomService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: LinearSeriesBase, selector: "ng-component", inputs: { series: "series" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: LinearSeriesBase, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ScaleService }, { type: i3.ZoomService }, { type: i0.ElementRef }]; }, propDecorators: { series: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linear-series-base.js","sourceRoot":"","sources":["../../../../../src/chart/chart-container/series/linear-series-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {BasePoint} from '../../model/base-point';\nimport {SeriesBaseComponent} from '../../base/series-base.component';\nimport {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport {BehaviorSubject, combineLatest, map, Observable, tap, withLatestFrom} from 'rxjs';\nimport {ChartService} from '../../service/chart.service';\nimport {ScaleService} from '../../service/scale.service';\nimport {ZoomService} from '../../service/zoom.service';\nimport * as d3 from 'd3';\nimport {TooltipTracking} from '../../model/enum/tooltip-tracking';\nimport {ClipPointsDirection} from '../../model/enum/clip-points-direction';\nimport {IScalesMap} from '../../model/i-scales-map';\nimport {Series} from '../../model/series';\n\n@Component({\n  template: '',\n})\nexport class LinearSeriesBase<T extends BasePoint>\n  extends SeriesBaseComponent<T>\n  implements OnInit, OnDestroy {\n\n  public defaultClipPointsMapping: Map<ClipPointsDirection, (min: number, max: number) => (point: BasePoint, idx: number, arr: Array<BasePoint>) => {}> = new Map();\n\n  transform: Observable<Pick<BasePoint, 'x' | 'y'>>;\n  display: Observable<number>;\n  path: Observable<string>;\n  x: any;\n  y: any;\n  markers: BasePoint[];\n\n  private __series: Series<T>;\n  protected _update = new BehaviorSubject<void>(null);\n\n  @Input()\n  override set series(series: Series<T>) {\n    this.__series = series;\n\n    this.markers = this.__series.data?.filter((_) =>\n      _?.marker && _?.x !== undefined && _?.y !== undefined && _?.x !== null && _?.y !== null);\n  }\n\n  override get series() {\n    return this.__series;\n  }\n\n  constructor(\n    protected override svc: ChartService,\n    protected override cdr: ChangeDetectorRef,\n    protected override scaleService: ScaleService,\n    protected override zoomService: ZoomService,\n    protected override element: ElementRef\n  ) {\n    super(svc, cdr, scaleService, zoomService, element);\n  }\n\n  override ngOnInit(): void {\n    const filterX = (min: number, max: number) => (\n      point: BasePoint,\n      idx: number,\n      arr: Array<BasePoint>\n    ) => {\n      const bigger = min > max ? min : max;\n      const smaller = min > max ? max : min;\n      return (point.x <= bigger ||\n          point.x1 <= bigger ||\n          (arr[idx - 1] && arr[idx - 1].x <= bigger) ||\n          (arr[idx - 1] && arr[idx - 1].x1 <= bigger)) &&\n        (point.x >= smaller ||\n          point.x1 >= smaller ||\n          (arr[idx + 1] && arr[idx + 1].x >= smaller) ||\n          (arr[idx + 1] && arr[idx + 1].x1 >= smaller))\n        ;\n    };\n\n    const filterY = (min: number, max: number) => (\n      point: BasePoint,\n      idx: number,\n      arr: Array<BasePoint>\n    ) => {\n      const bigger = min > max ? min : max;\n      const smaller = min > max ? max : min;\n      return (point.y <= bigger ||\n          point.y1 <= bigger ||\n          (arr[idx - 1] && arr[idx - 1].y <= bigger) ||\n          (arr[idx - 1] && arr[idx - 1].y1 <= bigger)) &&\n        (point.y >= smaller ||\n          point.y1 >= smaller ||\n          (arr[idx + 1] && arr[idx + 1].y >= smaller) ||\n          (arr[idx + 1] && arr[idx + 1].y1 >= smaller));\n    };\n\n    this.defaultClipPointsMapping.set(ClipPointsDirection.x, filterX);\n    this.defaultClipPointsMapping.set(ClipPointsDirection.y, filterY);\n\n    this.transform = this.svc.pointerMove.pipe(\n      withLatestFrom(this.scaleService.scales),\n      map((data: [PointerEvent, IScalesMap]) => {\n        const [event, {x, y}] = data;\n\n        return this.getTransform(event, x.get(this.series.xAxisIndex).scale, y.get(this.series.yAxisIndex).scale);\n      }),\n      tap(() => setTimeout(() => this.cdr.detectChanges()))\n    );\n\n    this.path = combineLatest([this.scaleService.scales, this._update]).pipe(\n      map(([data]) => {\n        const {x, y} = data;\n        this.x = x.get(this.series.xAxisIndex)?.scale;\n        this.y = y.get(this.series.yAxisIndex)?.scale;\n\n        if (!this.x || !this.y) {\n          return '';\n        }\n\n        const filter = this.defaultClipPointsMapping.get(this.series.clipPointsDirection);\n\n        const line = d3\n          .line<BasePoint>()\n          .defined(\n            (point) =>\n              point.x !== null &&\n              point.y !== null &&\n              point.x !== undefined &&\n              point.y !== undefined &&\n              !isNaN(point.x) &&\n              !isNaN(point.y)\n          )\n          .x((point) => this.x(point.x))\n          .y((point) => this.y(point.y));\n\n        let filteredData = this.series.data;\n\n        if (this.series.clipPointsDirection === ClipPointsDirection.x) {\n          let [min, max] = this.x.domain();\n\n          min = min instanceof Date ? min.getTime() : min;\n          max = max instanceof Date ? max.getTime() : max;\n\n          filteredData = filteredData?.filter(filter(min, max));\n        }\n\n\n        if (this.series.clipPointsDirection === ClipPointsDirection.y) {\n          let [min, max] = this.y.domain();\n\n          min = min instanceof Date ? min.getTime() : min;\n          max = max instanceof Date ? max.getTime() : max;\n\n          filteredData = filteredData?.filter(filter(min, max));\n        }\n\n        return line(filteredData);\n      })\n    );\n  }\n\n  ngOnDestroy() {\n    this.svc.setTooltip({\n      point: null,\n      series: this.series,\n    });\n  }\n\n  ngAfterViewInit() {\n  }\n\n  getTransform(\n    event: any,\n    scaleX: any,\n    scaleY: any\n  ): Pick<BasePoint, 'x' | 'y'> {\n    if (event.type === 'mouseleave') {\n      return null;\n    }\n    const mouse = [event?.offsetX, event?.offsetY];\n\n    const tooltipTracking = this.config?.tooltip?.tracking;\n    const lineIntersection = (\n      p0_x,\n      p0_y,\n      p1_x,\n      p1_y,\n      p2_x,\n      p2_y,\n      p3_x,\n      p3_y\n    ) => {\n      const rV = {} as any;\n      let s1_x, s1_y, s2_x, s2_y;\n      s1_x = p1_x - p0_x;\n      s1_y = p1_y - p0_y;\n      s2_x = p3_x - p2_x;\n      s2_y = p3_y - p2_y;\n\n      let s, t;\n      s =\n        (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) /\n        (-s2_x * s1_y + s1_x * s2_y);\n      t =\n        (s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) /\n        (-s2_x * s1_y + s1_x * s2_y);\n\n      if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\n        // Collision detected\n        rV.x = p0_x + t * s1_x;\n        rV.y = p0_y + t * s1_y;\n      }\n\n      return rV;\n    };\n\n    if (tooltipTracking === TooltipTracking.x) {\n      const bisect = d3.bisector((_: BasePoint) => _.x).right;\n      const pointer = mouse[0];\n\n      let x0 = scaleX.invert(pointer);\n      if (x0 instanceof Date) {\n        x0 = x0.getTime();\n      }\n      const rightId = bisect(this.series.data, x0);\n      const range = scaleY.range();\n      const intersect = lineIntersection(\n        pointer,\n        range[0],\n        pointer,\n        Number.MAX_SAFE_INTEGER,\n        scaleX(this.series.data[rightId - 1]?.x),\n        scaleY(this.series.data[rightId - 1]?.y),\n        scaleX(this.series.data[rightId]?.x),\n        scaleY(this.series.data[rightId]?.y)\n      );\n      const x = scaleX.invert(intersect.x);\n      const y = scaleY.invert(intersect.y);\n      if (x !== null && x !== undefined && !isNaN(x) && y !== null && y !== undefined && !isNaN(y)) {\n        this.svc.setTooltip({\n          point: {x: scaleX.invert(intersect.x), y: scaleY.invert(intersect.y)},\n          series: this.series,\n        });\n      } else {\n        this.svc.setTooltip({\n          point: null,\n          series: this.series,\n        });\n      }\n\n      return {\n        x: intersect.x,\n        y: intersect.y,\n      };\n    }\n\n    if (tooltipTracking === TooltipTracking.y) {\n      const bisect = d3.bisector((_: BasePoint) => _.y).right;\n\n      let y0 = scaleY.invert(mouse[1]);\n      if (y0 instanceof Date) {\n        y0 = y0.getTime();\n      }\n      const rightId = bisect(this.series.data, y0);\n      const range = scaleX.range();\n\n      const intersect = lineIntersection(\n        range[0],\n        mouse[1],\n        Number.MAX_SAFE_INTEGER,\n        mouse[1],\n        scaleX(this.series.data[rightId - 1]?.x),\n        scaleY(this.series.data[rightId - 1]?.y),\n        scaleX(this.series.data[rightId]?.x),\n        scaleY(this.series.data[rightId]?.y)\n      );\n\n      const x = scaleX.invert(intersect.x);\n      const y = scaleY.invert(intersect.y);\n\n      if (x !== null && x !== undefined && !isNaN(x) && y !== null && y !== undefined && !isNaN(y)) {\n        this.svc.setTooltip({\n          point: {x: scaleX.invert(intersect.x), y: scaleY.invert(intersect.y)},\n          series: this.series,\n        });\n      } else {\n        this.svc.setTooltip({\n          point: null,\n          series: this.series,\n        });\n      }\n\n      return {\n        x: intersect.x,\n        y: intersect.y,\n      };\n    }\n  }\n}\n"]}

package/esm2022/chart/chart-container/series/scatter-series/scatter-series.component.mjs

@@ -0,0 +1,53 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { SeriesBaseComponent } from '../../../base/series-base.component';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../service/chart.service";
+import * as i2 from "../../../service/scale.service";
+import * as i3 from "../../../service/zoom.service";
+import * as i4 from "@angular/common";
+export class ScatterSeriesComponent extends SeriesBaseComponent {
+    svc;
+    cdr;
+    scaleService;
+    zoomService;
+    element;
+    transform;
+    display;
+    path;
+    x;
+    y;
+    constructor(svc, cdr, scaleService, zoomService, element) {
+        super(svc, cdr, scaleService, zoomService, element);
+        this.svc = svc;
+        this.cdr = cdr;
+        this.scaleService = scaleService;
+        this.zoomService = zoomService;
+        this.element = element;
+    }
+    ngOnInit() {
+        this.x = this.scaleService.scales.pipe(map(_ => _.x.get(this.series.xAxisIndex)?.scale));
+        this.y = this.scaleService.scales.pipe(map(_ => _.y.get(this.series.yAxisIndex)?.scale));
+    }
+    ngAfterViewInit() {
+    }
+    mouseenter(point) {
+        this.svc.setTooltip({
+            point: point,
+            series: this.series,
+        });
+    }
+    mouseleave(point) {
+        this.svc.setTooltip({
+            point: null,
+            series: this.series,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ScatterSeriesComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ScaleService }, { token: i3.ZoomService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: ScatterSeriesComponent, selector: "svg:svg[teta-scatter-series]", usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"{\n  y: y | async,\n  x: x | async\n} as scales\">\n  <ng-container *ngIf=\"scales.x && scales.y\">\n    <svg:circle\n      class=\"line\"\n      *ngFor=\"let point of series.data\"\n      (mouseenter)=\"mouseenter(point)\"\n      (mouseleave)=\"mouseleave(point)\"\n      [attr.cx]=\"scales.x(point.x)\"\n      [attr.cy]=\"scales.y(point.y)\"\n      [attr.r]=\"series.style?.radius ?? 1\"\n      [attr.stroke]=\"point.color ?? series.color\"\n      [attr.fill]=\"point.color ?? series.color\"\n      [attr.stroke-width]=\"series.style?.strokeWidth\">\n    </svg:circle>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [".draggable-marker{cursor:move}.active{stroke-opacity:.5}.marker-grab{opacity:0}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ScatterSeriesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'svg:svg[teta-scatter-series]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"{\n  y: y | async,\n  x: x | async\n} as scales\">\n  <ng-container *ngIf=\"scales.x && scales.y\">\n    <svg:circle\n      class=\"line\"\n      *ngFor=\"let point of series.data\"\n      (mouseenter)=\"mouseenter(point)\"\n      (mouseleave)=\"mouseleave(point)\"\n      [attr.cx]=\"scales.x(point.x)\"\n      [attr.cy]=\"scales.y(point.y)\"\n      [attr.r]=\"series.style?.radius ?? 1\"\n      [attr.stroke]=\"point.color ?? series.color\"\n      [attr.fill]=\"point.color ?? series.color\"\n      [attr.stroke-width]=\"series.style?.strokeWidth\">\n    </svg:circle>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [".draggable-marker{cursor:move}.active{stroke-opacity:.5}.marker-grab{opacity:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ScaleService }, { type: i3.ZoomService }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/chart-container/series-host/series-host.component.mjs

@@ -0,0 +1,50 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { SeriesBaseComponent } from '../../base/series-base.component';
+import { LineSeriesComponent } from '../series/line/line-series.component';
+import { defaultSeriesTypeMapping } from '../../default/defaultSeriesTypeMapping';
+import * as i0 from "@angular/core";
+export class SeriesHostComponent {
+    viewContainerRef;
+    config;
+    series;
+    _init = false;
+    _componentRef;
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+    }
+    ngOnInit() {
+        if (!SeriesBaseComponent.isPrototypeOf(this.series.component)) {
+            this.series.component =
+                defaultSeriesTypeMapping.get(this.series.type) || LineSeriesComponent;
+        }
+        this._componentRef = this.viewContainerRef.createComponent(this.series.component);
+        this._componentRef.instance.config = this.config;
+        this._componentRef.instance.series = this.series;
+        this._init = true;
+    }
+    ngOnDestroy() {
+        this._componentRef.destroy();
+    }
+    ngOnChanges(changes) {
+        if (this._init && (changes.hasOwnProperty('series') || changes.hasOwnProperty('config'))) {
+            this._componentRef.instance.config = this.config;
+            this._componentRef.instance.series = this.series;
+            this._componentRef.injector.get(ChangeDetectorRef).detectChanges();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: SeriesHostComponent, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: SeriesHostComponent, selector: "[teta-series-host]", inputs: { config: "config", series: "series" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: SeriesHostComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[teta-series-host]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { config: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/chart/chart-container/tooltip/tooltip.component.mjs

@@ -9,6 +9,19 @@ import * as i3 from "@angular/platform-browser";
 import * as i4 from "@angular/common";
 import * as i5 from "@tetacom/ng-components";
 export class TooltipComponent {
+    svc;
+    cdr;
+    zoomService;
+    sanitizer;
+    _zone;
+    _elementRef;
+    size;
+    config;
+    tooltip;
+    position;
+    displayTooltips;
+    display;
+    tooltips;
     constructor(svc, cdr, zoomService, sanitizer, _zone, _elementRef) {
         this.svc = svc;
         this.cdr = cdr;
@@ -78,12 +91,12 @@ export class TooltipComponent {
         const format = d3.format(',.5~r');
         return format(input);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ZoomService }, { token: i3.DomSanitizer }, { token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: TooltipComponent, selector: "teta-tooltip", inputs: { size: "size", config: "config" }, viewQueries: [{ propertyName: "tooltip", first: true, predicate: ["tooltip"], descendants: true, read: ElementRef }], ngImport: i0, template: "<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-global-bgcard shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [":host{position:absolute;z-index:2}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i5.LetDirective, selector: "[tetaLet]", inputs: ["tetaLet"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-TooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: TooltipComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ZoomService }, { token: i3.DomSanitizer }, { token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
-TooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.2", type: TooltipComponent, selector: "teta-tooltip", inputs: { size: "size", config: "config" }, viewQueries: [{ propertyName: "tooltip", first: true, predicate: ["tooltip"], descendants: true, read: ElementRef }], ngImport: i0, template: "<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-background-50 shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [":host{position:absolute;z-index:2}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i5.LetDirective, selector: "[tetaLet]", inputs: ["tetaLet"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: TooltipComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'teta-tooltip', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-background-50 shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [":host{position:absolute;z-index:2}\n"] }]
+            args: [{ selector: 'teta-tooltip', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-global-bgcard shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n", styles: [":host{position:absolute;z-index:2}\n"] }]
         }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ZoomService }, { type: i3.DomSanitizer }, { type: i0.NgZone }, { type: i0.ElementRef }]; }, propDecorators: { size: [{
                 type: Input
             }], config: [{
@@ -92,4 +105,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImpor
                 type: ViewChild,
                 args: ['tooltip', { static: false, read: ElementRef }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"","sources":["../../../../../src/chart/chart-container/tooltip/tooltip.component.ts","../../../../../src/chart/chart-container/tooltip/tooltip.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  NgZone,\n  OnInit,\n  ViewChild,\n} from '@angular/core';\nimport {filter, map, Observable, tap} from 'rxjs';\nimport {ChartService} from '../../service/chart.service';\nimport {ZoomService} from '../../service/zoom.service';\nimport {IDisplayTooltip} from '../../model/i-display-tooltip';\nimport {DomSanitizer, SafeHtml} from '@angular/platform-browser';\nimport {IChartConfig} from '../../model/i-chart-config';\nimport {Series} from '../../model/series';\nimport * as d3 from 'd3';\nimport {Align, PositionUtil, VerticalAlign} from '@tetacom/ng-components';\n\n@Component({\n  selector: 'teta-tooltip',\n  templateUrl: './tooltip.component.html',\n  styleUrls: ['./tooltip.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TooltipComponent implements OnInit {\n  @Input() size: DOMRect;\n  @Input() config: IChartConfig;\n\n  @ViewChild('tooltip', {static: false, read: ElementRef}) tooltip: ElementRef;\n\n  position: Observable<{\n    left?: number;\n    top?: number;\n    bottom?: number;\n    right?: number;\n  }>;\n\n  displayTooltips: Observable<SafeHtml>;\n  display: Observable<number>;\n  tooltips: Observable<IDisplayTooltip[]>;\n\n  constructor(\n    private svc: ChartService,\n    private cdr: ChangeDetectorRef,\n    private zoomService: ZoomService,\n    private sanitizer: DomSanitizer,\n    private _zone: NgZone,\n    private _elementRef: ElementRef\n  ) {\n    this.tooltips = this.svc.tooltips.pipe(map((_) => [..._.values()]));\n  }\n\n  ngOnInit(): void {\n    this.display = this.svc.pointerMove.pipe(\n      map((event: PointerEvent) => {\n        return event.type === 'mousemove' ? 1 : 0;\n      }),\n      tap(() => {\n        setTimeout(() => {\n          this.cdr.detectChanges();\n        });\n      })\n    );\n\n    this.position = this.svc.pointerMove.pipe(\n      filter((event) => !!event),\n      map((_) => {\n        return this.getPosition(_);\n      }),\n      tap(() => this.cdr.detectChanges())\n    );\n\n    const transformHtml = (html): SafeHtml => {\n      return this.sanitizer.bypassSecurityTrustHtml(html);\n    };\n\n    const defaultFormatter = (tooltips: IDisplayTooltip[]): SafeHtml => {\n      let html = '';\n      const format = d3.timeFormat('%d.%m.%Y');\n      tooltips.forEach((_) => {\n        const indicatorStyle = `display:block; width: 10px; height: 2px; background-color: ${_?.series?.color}`;\n\n        html += `<div class=\"display-flex align-center\"><span class=\"margin-right-1\" style=\"${indicatorStyle}\"></span>\n          <span class=\"font-title-3\">${_.series.name}\n            <span class=\"font-body-3\">\n              x: ${(_.point.x as any) instanceof Date ? format(_.point.x as any) : _.point.x?.toFixed(2)}\n              y: ${(_.point.y as any) instanceof Date ? format(_.point.y as any) : _.point.y?.toFixed(2)}\n            </span>\n          </span></div>`;\n      });\n\n      return transformHtml(html);\n    };\n\n    const formatter = this.config?.tooltip?.format;\n\n    this.displayTooltips = this.svc.tooltips.pipe(\n      map((tooltips: Map<Series<any>, IDisplayTooltip>) => {\n        const tooltipList = [...tooltips.values()];\n        if (tooltipList?.length < 1) {\n          return '';\n        }\n        const formatted = formatter\n          ? transformHtml(formatter(tooltipList))\n          : defaultFormatter(tooltipList);\n        return formatted;\n      })\n    );\n  }\n\n  private getPosition(event: PointerEvent) {\n    if (!this.tooltip) {\n      return null;\n    }\n    return PositionUtil.getPosition(\n      {\n        top: event.pageY,\n        bottom: event.pageY,\n        left: event.pageX,\n        right: event.pageX,\n      },\n      this.tooltip?.nativeElement?.getBoundingClientRect(),\n      Align.auto,\n      VerticalAlign.top,\n      12\n    );\n  }\n\n\n  format(input: number | Date): string {\n    if (input instanceof Date) {\n      const format = d3.timeFormat('%d.%m.%Y');\n      return format(input);\n    }\n\n    const format = d3.format(',.5~r');\n    return format(input);\n  }\n}\n","<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-background-50 shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"","sources":["../../../../../src/chart/chart-container/tooltip/tooltip.component.ts","../../../../../src/chart/chart-container/tooltip/tooltip.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  NgZone,\n  OnInit,\n  ViewChild,\n} from '@angular/core';\nimport {filter, map, Observable, tap} from 'rxjs';\nimport {ChartService} from '../../service/chart.service';\nimport {ZoomService} from '../../service/zoom.service';\nimport {IDisplayTooltip} from '../../model/i-display-tooltip';\nimport {DomSanitizer, SafeHtml} from '@angular/platform-browser';\nimport {IChartConfig} from '../../model/i-chart-config';\nimport {Series} from '../../model/series';\nimport * as d3 from 'd3';\nimport {Align, PositionUtil, VerticalAlign} from '@tetacom/ng-components';\n\n@Component({\n  selector: 'teta-tooltip',\n  templateUrl: './tooltip.component.html',\n  styleUrls: ['./tooltip.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TooltipComponent implements OnInit {\n  @Input() size: DOMRect;\n  @Input() config: IChartConfig;\n\n  @ViewChild('tooltip', {static: false, read: ElementRef}) tooltip: ElementRef;\n\n  position: Observable<{\n    left?: number;\n    top?: number;\n    bottom?: number;\n    right?: number;\n  }>;\n\n  displayTooltips: Observable<SafeHtml>;\n  display: Observable<number>;\n  tooltips: Observable<IDisplayTooltip[]>;\n\n  constructor(\n    private svc: ChartService,\n    private cdr: ChangeDetectorRef,\n    private zoomService: ZoomService,\n    private sanitizer: DomSanitizer,\n    private _zone: NgZone,\n    private _elementRef: ElementRef\n  ) {\n    this.tooltips = this.svc.tooltips.pipe(map((_) => [..._.values()]));\n  }\n\n  ngOnInit(): void {\n    this.display = this.svc.pointerMove.pipe(\n      map((event: PointerEvent) => {\n        return event.type === 'mousemove' ? 1 : 0;\n      }),\n      tap(() => {\n        setTimeout(() => {\n          this.cdr.detectChanges();\n        });\n      })\n    );\n\n    this.position = this.svc.pointerMove.pipe(\n      filter((event) => !!event),\n      map((_) => {\n        return this.getPosition(_);\n      }),\n      tap(() => this.cdr.detectChanges())\n    );\n\n    const transformHtml = (html): SafeHtml => {\n      return this.sanitizer.bypassSecurityTrustHtml(html);\n    };\n\n    const defaultFormatter = (tooltips: IDisplayTooltip[]): SafeHtml => {\n      let html = '';\n      const format = d3.timeFormat('%d.%m.%Y');\n      tooltips.forEach((_) => {\n        const indicatorStyle = `display:block; width: 10px; height: 2px; background-color: ${_?.series?.color}`;\n\n        html += `<div class=\"display-flex align-center\"><span class=\"margin-right-1\" style=\"${indicatorStyle}\"></span>\n          <span class=\"font-title-3\">${_.series.name}\n            <span class=\"font-body-3\">\n              x: ${(_.point.x as any) instanceof Date ? format(_.point.x as any) : _.point.x?.toFixed(2)}\n              y: ${(_.point.y as any) instanceof Date ? format(_.point.y as any) : _.point.y?.toFixed(2)}\n            </span>\n          </span></div>`;\n      });\n\n      return transformHtml(html);\n    };\n\n    const formatter = this.config?.tooltip?.format;\n\n    this.displayTooltips = this.svc.tooltips.pipe(\n      map((tooltips: Map<Series<any>, IDisplayTooltip>) => {\n        const tooltipList = [...tooltips.values()];\n        if (tooltipList?.length < 1) {\n          return '';\n        }\n        const formatted = formatter\n          ? transformHtml(formatter(tooltipList))\n          : defaultFormatter(tooltipList);\n        return formatted;\n      })\n    );\n  }\n\n  private getPosition(event: PointerEvent) {\n    if (!this.tooltip) {\n      return null;\n    }\n    return PositionUtil.getPosition(\n      {\n        top: event.pageY,\n        bottom: event.pageY,\n        left: event.pageX,\n        right: event.pageX,\n      },\n      this.tooltip?.nativeElement?.getBoundingClientRect(),\n      Align.auto,\n      VerticalAlign.top,\n      12\n    );\n  }\n\n\n  format(input: number | Date): string {\n    if (input instanceof Date) {\n      const format = d3.timeFormat('%d.%m.%Y');\n      return format(input);\n    }\n\n    const format = d3.format(',.5~r');\n    return format(input);\n  }\n}\n","<ng-container *tetaLet=\"position | async as p\">\n  <ng-container *ngIf=\"tooltips | async as t\">\n    <div class=\"chart-tooltip color-text-90 bg-global-bgcard shadow-2\"\n         #tooltip\n         [style.position]=\"'fixed'\"\n         *ngIf=\"t.length > 0\"\n         [style.opacity]=\"display | async\"\n         [hidden]=\"!p\"\n         style=\"pointer-events: none; min-width: 200px;\"\n         [style.left.px]=\"p?.left\"\n         [style.top.px]=\"p?.top\"\n         [style.bottom.px]=\"p?.bottom\"\n         [style.right.px]=\"p?.right\"\n    >\n      <ng-container *ngIf=\"config.tooltip?.template\">\n        <ng-container *ngTemplateOutlet=\"config.tooltip.template; context: {$implicit: t}\"></ng-container>\n      </ng-container>\n\n      <ng-container *ngIf=\"config.tooltip?.format; else default\">\n        <div [innerHTML]=\"displayTooltips | async\"></div>\n      </ng-container>\n\n      <ng-template #default>\n        <div *ngIf=\"!config.tooltip?.template\" class=\"padding-2 border-radius-1\">\n          <ng-container *ngFor=\"let tooltip of t\">\n            <div class=\"display-flex align-center\">\n            <span class=\"display-block margin-right-1\" [style.width.px]=\"10\" [style.height.px]=\"2\"\n                  [style.background-color]=\"tooltip.series?.color\"></span>\n              <span class=\"font-title-3\">\n            {{ tooltip.series?.name }}\n                <span class=\"font-body-3\">\n              x: {{ format(tooltip.point?.x) }}\n                  y: {{ format(tooltip.point?.y) }}\n            </span>\n          </span>\n            </div>\n          </ng-container>\n        </div>\n      </ng-template>\n    </div>\n  </ng-container>\n</ng-container>\n\n\n\n"]}

package/esm2022/chart/chart-container/x-axis/x-axis.component.mjs

@@ -0,0 +1,54 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, withLatestFrom } from 'rxjs';
+import { getTextWidth } from '../../core/utils/get-text-width';
+import * as d3 from 'd3';
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/scale.service";
+import * as i2 from "../../service/chart.service";
+import * as i3 from "@angular/common";
+export class XAxisComponent {
+    scaleService;
+    _svc;
+    x;
+    ticks;
+    axis;
+    size;
+    update$ = new BehaviorSubject(null);
+    _alive = true;
+    constructor(scaleService, _svc) {
+        this.scaleService = scaleService;
+        this._svc = _svc;
+        this.x = this.scaleService.scales.pipe(map((_) => {
+            return _.x.get(this.axis.index)?.scale;
+        }));
+        this.ticks = combineLatest([this.x, this.update$]).pipe(withLatestFrom(this._svc.size), map((_) => {
+            const [[x], size] = _;
+            const tickSize = x.ticks().map((_) => getTextWidth(this.axis.options.tickFormat ? this.axis.options.tickFormat(_) : this.axis.defaultFormatter()(_), 0.45, 11));
+            return x.ticks(size.width / parseInt(d3.max(tickSize), 10) / 5);
+        }));
+    }
+    getLabelTransform() {
+        return `translate(${this.size.width / 2}, ${this.axis.options.opposite ? -32 : 32})`;
+    }
+    ngOnInit() {
+    }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('axis')) {
+            this.update$.next();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: XAxisComponent, deps: [{ token: i1.ScaleService }, { token: i2.ChartService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: XAxisComponent, selector: "[teta-x-axis]", inputs: { axis: "axis", size: "size" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"{x: x | async, ticks: ticks | async} as data\">\n  <svg:g text-anchor=\"middle\" *ngFor=\"let tick of data.ticks\" [attr.transform]=\"'translate('+ data.x(tick) +', 0)'\">\n    <text fill=\"var(--color-text-70)\" [attr.dy]=\"axis.options.opposite ? '-0.71em' : '0.71em'\" [attr.y]=\"axis.options.opposite ? 0 : 9\">{{ this.axis.options.tickFormat ? this.axis.options.tickFormat(tick) : this.axis.defaultFormatter()(tick) }}</text>\n    <line stroke=\"var(--color-text-30)\" [attr.y2]=\"axis.options.opposite ? -6 : 6\"></line>\n  </svg:g>\n\n  <svg:g class=\"label-axis font-caption\" [attr.transform]=\"getLabelTransform()\">\n    <text fill=\"var(--color-text-70)\"  text-anchor=\"middle\" dominant-baseline=\"middle\">{{ axis.options.title }}</text>\n  </svg:g>\n</ng-container>\n\n", styles: [":host .tick{stroke:var(--color-text-20)}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: XAxisComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[teta-x-axis]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"{x: x | async, ticks: ticks | async} as data\">\n  <svg:g text-anchor=\"middle\" *ngFor=\"let tick of data.ticks\" [attr.transform]=\"'translate('+ data.x(tick) +', 0)'\">\n    <text fill=\"var(--color-text-70)\" [attr.dy]=\"axis.options.opposite ? '-0.71em' : '0.71em'\" [attr.y]=\"axis.options.opposite ? 0 : 9\">{{ this.axis.options.tickFormat ? this.axis.options.tickFormat(tick) : this.axis.defaultFormatter()(tick) }}</text>\n    <line stroke=\"var(--color-text-30)\" [attr.y2]=\"axis.options.opposite ? -6 : 6\"></line>\n  </svg:g>\n\n  <svg:g class=\"label-axis font-caption\" [attr.transform]=\"getLabelTransform()\">\n    <text fill=\"var(--color-text-70)\"  text-anchor=\"middle\" dominant-baseline=\"middle\">{{ axis.options.title }}</text>\n  </svg:g>\n</ng-container>\n\n", styles: [":host .tick{stroke:var(--color-text-20)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ScaleService }, { type: i2.ChartService }]; }, propDecorators: { axis: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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