@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/chart/chart.service.mjs

@@ -0,0 +1,237 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { scaleBand, scaleLinear, scalePoint, scaleTime, } from 'd3';
+import { BehaviorSubject, Subject, map, tap } from 'rxjs';
+import { publishRef } from '../core/utils/public-api';
+import { DEFAULT_COLORS, basics } from './constants';
+import { Orientation, } from './types';
+import { ScaleType, calculateViewDimensions, getScaleType, getXDomain, getYDomain, } from './utils';
+import * as i0 from "@angular/core";
+export const CHART_COLORS_TOKEN = new InjectionToken('chart_colors');
+export class ContextChartService {
+    get scaleType() {
+        return this._scaleType || getScaleType(this.xSeriesValue);
+    }
+    set scaleType(type) {
+        this._scaleType = type;
+    }
+    get x() {
+        if (this.adoptCache('x')) {
+            return this.cacheXScale;
+        }
+        return (this.cacheXScale = this.getXScale(getXDomain(this.xSeriesValue, this.scaleType)));
+    }
+    get y() {
+        if (this.adoptCache('y')) {
+            return this.cacheYScale;
+        }
+        return (this.cacheYScale = this.calculateY());
+    }
+    get innerDomain() {
+        const domainSet = new Set();
+        for (const [, item] of this.chartData.entries()) {
+            for (const [, value] of item.values.entries()) {
+                domainSet.add(value.x);
+            }
+        }
+        return [...domainSet];
+    }
+    get colors() {
+        return this.chartColors?.length ? this.chartColors : DEFAULT_COLORS;
+    }
+    get horizontal() {
+        return (this.barOptions.isBand ||
+            this.barOptions.orientation === Orientation.HORIZONTAL);
+    }
+    constructor(chartColors) {
+        this.chartColors = chartColors;
+        this.chartView = {
+            width: 0,
+            height: 0,
+            xOffset: 0,
+        };
+        this.update$$ = new Subject();
+        this.legendChange$$ = new Subject();
+        this.legendActivate$$ = new Subject();
+        this.disabledLegend = new Set();
+        this.showXLabel = false;
+        this.showYLabel = false;
+        this.xSeriesValue = [];
+        this.ySeriesValue = [];
+        this.barOptions = {
+            isBand: false,
+            orientation: Orientation.VERTICAL,
+            type: 'standard',
+        };
+        this.chartData = [];
+        this.chartData$ = new BehaviorSubject([]);
+        this.seriesData$ = new BehaviorSubject([]);
+        this.triggerInitData$ = new BehaviorSubject([]);
+        this.ySeriesDomain = [0, 0];
+        this.xSeriesDomain = [0, 0];
+        this.cacheDomainParams = {
+            yDomain: [0, 0],
+            xDomain: [0, 0],
+            height: 0,
+            width: 0,
+        };
+        this.noData = true;
+        this.noData$ = this.chartData$.pipe(map(res => res.every(item => item.values.every(d => d.y === null))), tap(noData => (this.noData = noData)), publishRef());
+        this.barInnerScale = (barPadding = 8) => {
+            const width = this.x.bandwidth();
+            const spacing = this.innerDomain.length / (width / barPadding + 1);
+            return scaleBand()
+                .range([0, width])
+                .paddingInner(spacing)
+                .domain(this.innerDomain);
+        };
+        this.calculateY = () => {
+            const horizontal = this.barOptions.orientation === Orientation.HORIZONTAL;
+            const height = horizontal ? this.chartView.width : this.chartView.height;
+            this.cacheDomainParams = {
+                ...this.cacheDomainParams,
+                yDomain: this.ySeriesDomain,
+                height,
+            };
+            return scaleLinear().domain(this.ySeriesDomain).range([height, 0]).nice();
+        };
+        this.getChartDefaultColor = (index) => {
+            const colorIndex = index % this.colors.length;
+            return this.colors[colorIndex];
+        };
+    }
+    initContext() {
+        this.xSeriesValue = [];
+        this.ySeriesValue = [];
+    }
+    setChartData(data) {
+        this.chartData$.next(data);
+        this.calculationYDomain();
+        this.xSeriesDomain = getXDomain(this.xSeriesValue, this.scaleType);
+    }
+    updateChartView(width, height, margin) {
+        this.chartView = calculateViewDimensions({
+            width,
+            height,
+            margin: margin || basics.margin,
+            showXLabel: this.showXLabel,
+            showYLabel: this.showYLabel,
+        });
+        this.cacheDomainParams.width = this.chartView.width;
+        this.update$$.next();
+    }
+    calculationYDomain() {
+        const horizontal = this.barOptions.orientation === Orientation.HORIZONTAL;
+        const defaultDomain = getYDomain(this.ySeriesValue);
+        const min = Math.min(0, this.yScaleMin || 0, defaultDomain[0]);
+        const max = Math.max(0, this.yScaleMax || 0, defaultDomain[1]);
+        this.ySeriesDomain = horizontal ? [max, min] : [min, max];
+    }
+    calculationYAxisMax() {
+        this.ySeriesValue = this.chartData.reduce((prev, curr) => {
+            if (!this.disabledLegend.has(curr.name)) {
+                return [
+                    ...prev,
+                    ...(this.barOptions.isBand
+                        ? this.getYSeriesItemDomain(curr.values)
+                        : curr.values.map(d => d.y)),
+                ];
+            }
+            return prev;
+        }, []);
+        this.calculationYDomain();
+    }
+    getYSeriesItemDomain(values) {
+        return this.barOptions.type === 'stacked'
+            ? [
+                0,
+                values.reduce((prev, curr) => {
+                    if (!this.disabledLegend.has(curr.x)) {
+                        return curr.y + prev;
+                    }
+                    return prev;
+                }, 0),
+            ]
+            : values.reduce((prev, curr) => {
+                if (!this.disabledLegend.has(curr.x)) {
+                    return [...prev, curr.y];
+                }
+                return prev;
+            }, []);
+    }
+    getXScale(domain) {
+        const width = this.barOptions.orientation === Orientation.HORIZONTAL
+            ? this.chartView.height
+            : this.chartView.width;
+        if (this.barOptions.isBand) {
+            return scaleBand().range([0, width]).domain(domain).padding(0.2);
+        }
+        switch (this.scaleType) {
+            case ScaleType.TIME: {
+                return scaleTime().domain(domain).range([0, width]);
+            }
+            case ScaleType.LINEAR: {
+                return scaleLinear().domain(domain).range([0, width]);
+            }
+            case ScaleType.ORDINAL: {
+                return scalePoint().domain(domain).range([0, width]);
+            }
+            default: {
+                break;
+            }
+        }
+    }
+    adoptCache(type) {
+        const { xDomain, width, yDomain, height } = this.cacheDomainParams;
+        if (type === 'x') {
+            return (xDomain[0] === this.ySeriesDomain[0] &&
+                xDomain[1] === this.ySeriesDomain[1] &&
+                width === this.chartView.width &&
+                this.chartView.width &&
+                this.ySeriesDomain[1]);
+        }
+        return (yDomain[0] === this.ySeriesDomain[0] &&
+            yDomain[1] === this.ySeriesDomain[1] &&
+            height === this.chartView.height &&
+            this.chartView.height);
+    }
+    selectedLegend(payload) {
+        const legend = payload.legendItem;
+        this.disabledLegend.delete(legend.name);
+        this.legendActivate$$.next(legend.name);
+        this.calculationYAxisMax();
+        this.legendChange$$.next(payload);
+        this.legendActivate$$.next('');
+        this.update$$.next();
+    }
+    selectedAllLegend() {
+        this.disabledLegend.clear();
+        this.calculationYAxisMax();
+        this.legendChange$$.next(null);
+        this.update$$.next();
+    }
+    unselectAllLegend(legends) {
+        this.disabledLegend = new Set(legends);
+        this.calculationYAxisMax();
+        this.legendChange$$.next(null);
+        this.update$$.next();
+    }
+    deactivateLegend(payload) {
+        const legend = payload.legendItem;
+        this.disabledLegend.add(legend.name);
+        this.calculationYAxisMax();
+        this.legendActivate$$.next('');
+        this.legendChange$$.next(payload);
+        this.update$$.next();
+    }
+    static { this.ɵfac = function ContextChartService_Factory(t) { return new (t || ContextChartService)(i0.ɵɵinject(CHART_COLORS_TOKEN, 8)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ContextChartService, factory: ContextChartService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ContextChartService, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [CHART_COLORS_TOKEN]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/chart/chart.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport {\n  ScaleBand,\n  ScaleLinear,\n  ScalePoint,\n  ScaleTime,\n  scaleBand,\n  scaleLinear,\n  scalePoint,\n  scaleTime,\n} from 'd3';\nimport { BehaviorSubject, Subject, map, tap } from 'rxjs';\n\nimport { publishRef } from '../core/utils/public-api';\nimport { ChartData, ChartDataItem } from '../view-chart/types';\n\nimport { LegendItem } from './common/legend/legend.component';\nimport { DEFAULT_COLORS, basics } from './constants';\nimport {\n  ChartMargin,\n  ChartView,\n  DomainParams,\n  Orientation,\n  SeriesData,\n} from './types';\nimport {\n  ScaleType,\n  calculateViewDimensions,\n  getScaleType,\n  getXDomain,\n  getYDomain,\n} from './utils';\n\nexport const CHART_COLORS_TOKEN = new InjectionToken<string[]>('chart_colors');\n\ninterface LegendChangePayload {\n  legendItem: LegendItem;\n  legends: LegendItem[];\n}\n\n@Injectable()\nexport class ContextChartService {\n  margin: ChartMargin;\n\n  chartView: ChartView = {\n    width: 0,\n    height: 0,\n    xOffset: 0,\n  };\n\n  update$$ = new Subject<void>();\n\n  legendChange$$ = new Subject<LegendChangePayload>();\n\n  legendActivate$$ = new Subject<string>();\n\n  disabledLegend: Set<string> = new Set();\n\n  showXLabel = false;\n\n  showYLabel = false;\n\n  yScaleMin: number;\n\n  yScaleMax: number;\n\n  xSeriesValue: Array<string | number | Date> = [];\n\n  ySeriesValue: number[] = [];\n\n  _scaleType: ScaleType;\n\n  barOptions: {\n    isBand: boolean;\n    orientation: Orientation | string;\n    type: string;\n  } = {\n    isBand: false,\n    orientation: Orientation.VERTICAL,\n    type: 'standard',\n  };\n\n  chartData: ChartData[] = [];\n\n  chartData$ = new BehaviorSubject<ChartData[]>([]);\n\n  seriesData$ = new BehaviorSubject<SeriesData[]>([]);\n\n  triggerInitData$ = new BehaviorSubject<ChartData[]>([]);\n\n  ySeriesDomain = [0, 0];\n\n  xSeriesDomain: unknown[] = [0, 0];\n\n  cacheDomainParams: DomainParams = {\n    yDomain: [0, 0],\n    xDomain: [0, 0],\n    height: 0,\n    width: 0,\n  };\n\n  cacheXScale:\n    | ScaleLinear<number, number>\n    | ScaleTime<number, number>\n    | ScalePoint<string>;\n\n  cacheYScale: ScaleLinear<number, number>;\n\n  noData = true;\n\n  cacheScale: ScaleLinear<number, number>;\n\n  noData$ = this.chartData$.pipe(\n    map(res => res.every(item => item.values.every(d => d.y === null))),\n    tap(noData => (this.noData = noData)),\n    publishRef(),\n  );\n\n  get scaleType() {\n    return this._scaleType || getScaleType(this.xSeriesValue);\n  }\n\n  set scaleType(type) {\n    this._scaleType = type;\n  }\n\n  get x() {\n    if (this.adoptCache('x')) {\n      return this.cacheXScale;\n    }\n    return (this.cacheXScale = this.getXScale(\n      getXDomain(this.xSeriesValue, this.scaleType),\n    ));\n  }\n\n  get y() {\n    if (this.adoptCache('y')) {\n      return this.cacheYScale;\n    }\n    return (this.cacheYScale = this.calculateY());\n  }\n\n  get innerDomain() {\n    const domainSet: Set<string> = new Set();\n    for (const [, item] of this.chartData.entries()) {\n      for (const [, value] of item.values.entries()) {\n        domainSet.add(value.x as string);\n      }\n    }\n    return [...domainSet];\n  }\n\n  get colors() {\n    return this.chartColors?.length ? this.chartColors : DEFAULT_COLORS;\n  }\n\n  get horizontal() {\n    return (\n      this.barOptions.isBand ||\n      this.barOptions.orientation === Orientation.HORIZONTAL\n    );\n  }\n\n  constructor(\n    @Optional()\n    @Inject(CHART_COLORS_TOKEN)\n    private readonly chartColors: string[],\n  ) {}\n\n  initContext() {\n    this.xSeriesValue = [];\n    this.ySeriesValue = [];\n  }\n\n  setChartData(data: ChartData[]) {\n    this.chartData$.next(data);\n    this.calculationYDomain();\n    this.xSeriesDomain = getXDomain(this.xSeriesValue, this.scaleType);\n  }\n\n  barInnerScale = (barPadding = 8) => {\n    const width = (<ScaleBand<string>>this.x).bandwidth();\n    const spacing = this.innerDomain.length / (width / barPadding + 1);\n    return scaleBand()\n      .range([0, width])\n      .paddingInner(spacing)\n      .domain(this.innerDomain);\n  };\n\n  calculateY = () => {\n    const horizontal = this.barOptions.orientation === Orientation.HORIZONTAL;\n    const height = horizontal ? this.chartView.width : this.chartView.height;\n    this.cacheDomainParams = {\n      ...this.cacheDomainParams,\n      yDomain: this.ySeriesDomain,\n      height,\n    };\n    return scaleLinear().domain(this.ySeriesDomain).range([height, 0]).nice();\n  };\n\n  updateChartView(width?: number, height?: number, margin?: ChartMargin) {\n    this.chartView = calculateViewDimensions({\n      width,\n      height,\n      margin: margin || basics.margin,\n      showXLabel: this.showXLabel,\n      showYLabel: this.showYLabel,\n    });\n    this.cacheDomainParams.width = this.chartView.width;\n    this.update$$.next();\n  }\n\n  getChartDefaultColor = (index: number) => {\n    const colorIndex = index % this.colors.length;\n    return this.colors[colorIndex];\n  };\n\n  private calculationYDomain() {\n    const horizontal = this.barOptions.orientation === Orientation.HORIZONTAL;\n    const defaultDomain = getYDomain(this.ySeriesValue);\n    const min = Math.min(0, this.yScaleMin || 0, defaultDomain[0]);\n    const max = Math.max(0, this.yScaleMax || 0, defaultDomain[1]);\n    this.ySeriesDomain = horizontal ? [max, min] : [min, max];\n  }\n\n  calculationYAxisMax() {\n    this.ySeriesValue = this.chartData.reduce((prev, curr) => {\n      if (!this.disabledLegend.has(curr.name)) {\n        return [\n          ...prev,\n          ...(this.barOptions.isBand\n            ? this.getYSeriesItemDomain(curr.values)\n            : curr.values.map(d => d.y)),\n        ];\n      }\n      return prev;\n    }, []);\n    this.calculationYDomain();\n  }\n\n  private getYSeriesItemDomain(values: ChartDataItem[]) {\n    return this.barOptions.type === 'stacked'\n      ? [\n          0,\n          values.reduce((prev, curr) => {\n            if (!this.disabledLegend.has(curr.x as string)) {\n              return curr.y + prev;\n            }\n            return prev;\n          }, 0),\n        ]\n      : values.reduce((prev, curr) => {\n          if (!this.disabledLegend.has(curr.x as string)) {\n            return [...prev, curr.y];\n          }\n          return prev;\n        }, []);\n  }\n\n  private getXScale(domain: Array<Date | number | any>) {\n    const width =\n      this.barOptions.orientation === Orientation.HORIZONTAL\n        ? this.chartView.height\n        : this.chartView.width;\n    if (this.barOptions.isBand) {\n      return scaleBand().range([0, width]).domain(domain).padding(0.2);\n    }\n    switch (this.scaleType) {\n      case ScaleType.TIME: {\n        return scaleTime().domain(domain).range([0, width]);\n      }\n      case ScaleType.LINEAR: {\n        return scaleLinear().domain(domain).range([0, width]);\n      }\n      case ScaleType.ORDINAL: {\n        return scalePoint().domain(domain).range([0, width]);\n      }\n      default: {\n        break;\n      }\n    }\n  }\n\n  private adoptCache(type: 'y' | 'x') {\n    const { xDomain, width, yDomain, height } = this.cacheDomainParams;\n    if (type === 'x') {\n      return (\n        xDomain[0] === this.ySeriesDomain[0] &&\n        xDomain[1] === this.ySeriesDomain[1] &&\n        width === this.chartView.width &&\n        this.chartView.width &&\n        this.ySeriesDomain[1]\n      );\n    }\n    return (\n      yDomain[0] === this.ySeriesDomain[0] &&\n      yDomain[1] === this.ySeriesDomain[1] &&\n      height === this.chartView.height &&\n      this.chartView.height\n    );\n  }\n\n  selectedLegend(payload: LegendChangePayload) {\n    const legend = payload.legendItem;\n    this.disabledLegend.delete(legend.name);\n    this.legendActivate$$.next(legend.name);\n    this.calculationYAxisMax();\n    this.legendChange$$.next(payload);\n    this.legendActivate$$.next('');\n    this.update$$.next();\n  }\n\n  selectedAllLegend() {\n    this.disabledLegend.clear();\n    this.calculationYAxisMax();\n    this.legendChange$$.next(null);\n    this.update$$.next();\n  }\n\n  unselectAllLegend(legends: string[]) {\n    this.disabledLegend = new Set(legends);\n    this.calculationYAxisMax();\n    this.legendChange$$.next(null);\n    this.update$$.next();\n  }\n\n  deactivateLegend(payload: LegendChangePayload) {\n    const legend = payload.legendItem;\n    this.disabledLegend.add(legend.name);\n    this.calculationYAxisMax();\n    this.legendActivate$$.next('');\n    this.legendChange$$.next(payload);\n    this.update$$.next();\n  }\n}\n"]}

package/esm2022/chart/common/axis/axis-label.component.mjs

@@ -0,0 +1,106 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+const _c0 = ["aclAxisLabel", ""];
+export class AxisLabelComponent {
+    constructor() {
+        this.textHeight = 25;
+        this.margin = 10;
+    }
+    ngOnChanges() {
+        this.update();
+    }
+    update() {
+        this.strokeWidth = '0.01';
+        this.textAnchor = 'middle';
+        this.transform = '';
+        if (this.isVertical) {
+            this.transform = `rotate(${exist(this.rotation) ? this.rotation : 270})`;
+        }
+        switch (this.align) {
+            case 'low': {
+                if (this.isVertical) {
+                    this.x = -(this.height + this.offsetY) + this.margin;
+                    this.y = -this.textHeight + this.offsetX - this.margin;
+                }
+                else {
+                    this.y = this.textHeight + this.margin + this.offsetY;
+                    this.x = this.textHeight - this.margin + this.offsetX;
+                }
+                break;
+            }
+            case 'middle': {
+                if (this.isVertical) {
+                    this.y = -(-this.offsetX + this.textHeight + this.margin);
+                    this.x = -(this.offsetY + this.height / 2);
+                }
+                else {
+                    this.y = this.offsetY + this.textHeight + this.margin;
+                    this.x = this.offsetX + this.width / 2;
+                }
+                break;
+            }
+            case 'high': {
+                if (this.isVertical) {
+                    this.y = -this.textHeight + this.offsetX - this.margin;
+                    this.x = -(this.textHeight + this.offsetY) + this.margin;
+                }
+                else {
+                    this.y = this.textHeight + this.margin + this.offsetY;
+                    this.x = this.width - this.textHeight + this.margin + this.offsetX;
+                }
+                break;
+            }
+            default:
+        }
+    }
+    static { this.ɵfac = function AxisLabelComponent_Factory(t) { return new (t || AxisLabelComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: AxisLabelComponent, selectors: [["g", "aclAxisLabel", ""]], inputs: { align: "align", label: "label", offsetX: "offsetX", offsetY: "offsetY", width: "width", height: "height", isVertical: "isVertical", rotation: "rotation" }, features: [i0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 2, vars: 6, template: function AxisLabelComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵnamespaceSVG();
+            i0.ɵɵelementStart(0, "text");
+            i0.ɵɵtext(1);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵattribute("stroke-width", ctx.strokeWidth)("x", ctx.x)("y", ctx.y)("text-anchor", ctx.textAnchor)("transform", ctx.transform);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", ctx.label, " ");
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AxisLabelComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclAxisLabel]',
+                template: `
+    <svg:text
+      [attr.stroke-width]="strokeWidth"
+      [attr.x]="x"
+      [attr.y]="y"
+      [attr.text-anchor]="textAnchor"
+      [attr.transform]="transform"
+    >
+      {{ label }}
+    </svg:text>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], null, { align: [{
+            type: Input
+        }], label: [{
+            type: Input
+        }], offsetX: [{
+            type: Input
+        }], offsetY: [{
+            type: Input
+        }], width: [{
+            type: Input
+        }], height: [{
+            type: Input
+        }], isVertical: [{
+            type: Input
+        }], rotation: [{
+            type: Input
+        }] }); })();
+function exist(value) {
+    return value !== undefined && value !== null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/common/axis/x-axis-ticks.component.mjs

@@ -0,0 +1,217 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import dayjs from 'dayjs';
+import { map } from 'rxjs';
+import { ContextChartService } from '../../chart.service';
+import { Orientation } from '../../types';
+import { ScaleType, reduceTicks } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../chart.service";
+const _c0 = ["aclXAxisTicks", ""];
+const _c1 = function () { return {}; };
+function XAxisTicksComponent_ng_container_0__svg_g_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g")(1, "text", 4);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(4, "line", 5);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const tick_r4 = ctx.$implicit;
+    const i_r5 = ctx.index;
+    const ctx_r3 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("x", i_r5 === ctx_r3.ticks.length - 1 && tick_r4.x >= (ctx_r3.context.chartView == null ? null : ctx_r3.context.chartView.height) ? tick_r4.x - 5 : tick_r4.x)("y", tick_r4.y + 16)("text-anchor", ctx_r3.textAnchor);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", ctx_r3.translation ? i0.ɵɵpipeBind3(3, 8, tick_r4.value, i0.ɵɵpureFunction0(12, _c1), true) : tick_r4.value, " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("x1", tick_r4.x)("x2", tick_r4.x)("y1", tick_r4.y)("y2", tick_r4.y + 6);
+} }
+function XAxisTicksComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, XAxisTicksComponent_ng_container_0__svg_g_1_Template, 5, 13, "g", 2);
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(2, "g");
+    i0.ɵɵelement(3, "path", 3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r0.ticks);
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("d", ctx_r0.xAxisLine);
+} }
+function XAxisTicksComponent_ng_template_1__svg_g_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g")(1, "text", 6);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const tick_r7 = ctx.$implicit;
+    const ctx_r6 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("y", tick_r7.x);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", ctx_r6.translation ? i0.ɵɵpipeBind3(3, 2, i0.ɵɵpipeBind1(4, 6, tick_r7.value), i0.ɵɵpureFunction0(8, _c1), true) : tick_r7.value, " ");
+} }
+function XAxisTicksComponent_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, XAxisTicksComponent_ng_template_1__svg_g_0_Template, 5, 9, "g", 2);
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(1, "g");
+    i0.ɵɵelement(2, "path", 3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngForOf", ctx_r2.ticks);
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("d", ctx_r2.yAxisLine);
+} }
+export class XAxisTicksComponent {
+    get context() {
+        return this.contextService;
+    }
+    get yAxisLine() {
+        return `M${0} ${0}L${0} ${this.context.chartView.height}Z`;
+    }
+    get xAxisLine() {
+        const { width } = this.contextService.chartView;
+        return `M0 0L${width} 0Z`;
+    }
+    getTicks() {
+        let ticks;
+        if (this.context.scaleType === ScaleType.ORDINAL) {
+            const maxTicks = this.getMaxTicks(20);
+            ticks = reduceTicks(this.context.x.domain(), maxTicks).map(this.handleTicksData);
+        }
+        else {
+            ticks = this.context.x
+                .ticks(this.getMaxTicks(100))
+                .map(this.handleTicksData);
+        }
+        return ticks;
+    }
+    getMaxTicks(tickWidth) {
+        const width = this.context.horizontal
+            ? this.context.chartView.height
+            : this.context.chartView.width;
+        return Math.floor(width / tickWidth);
+    }
+    constructor(contextService, cdr) {
+        this.contextService = contextService;
+        this.cdr = cdr;
+        this.textAnchor = 'middle';
+        this.orientation = Orientation;
+        this.handleTicksData = (value) => {
+            const bandwidth = this.context.barOptions.isBand
+                ? this.context.x.bandwidth() * 0.5
+                : 0;
+            return {
+                value: this.format(value),
+                x: this.context.x(value) + bandwidth,
+                y: 0,
+            };
+        };
+    }
+    ngOnInit() {
+        this.contextService.seriesData$
+            .pipe(map(() => this.getTicks()))
+            .subscribe(res => {
+            this.ticks = res;
+            this.cdr.detectChanges();
+        });
+    }
+    format(value) {
+        return this.contextService.scaleType === ScaleType.TIME
+            ? dayjs(value).format(this.dateFormat)
+            : value;
+    }
+    static { this.ɵfac = function XAxisTicksComponent_Factory(t) { return new (t || XAxisTicksComponent)(i0.ɵɵdirectiveInject(i1.ContextChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAxisTicksComponent, selectors: [["g", "aclXAxisTicks", ""]], inputs: { dateFormat: "dateFormat", translation: "translation" }, attrs: _c0, decls: 3, vars: 2, consts: [[4, "ngIf", "ngIfElse"], ["elseTemplate", ""], [4, "ngFor", "ngForOf"], ["stroke", "#ccd6eb", "fill", "none"], ["fill", "#666", "font-size", "11"], ["stroke-width", "1", "stroke", "#ccd6eb"], ["x", "-8", "fill", "#666", "text-anchor", "end", "font-size", "11", "alignment-baseline", "middle"]], template: function XAxisTicksComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, XAxisTicksComponent_ng_container_0_Template, 4, 2, "ng-container", 0);
+            i0.ɵɵtemplate(1, XAxisTicksComponent_ng_template_1_Template, 3, 2, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            const _r1 = i0.ɵɵreference(2);
+            i0.ɵɵproperty("ngIf", ctx.context.barOptions.orientation === ctx.orientation.VERTICAL)("ngIfElse", _r1);
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAxisTicksComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclXAxisTicks]',
+                template: `
+    <ng-container
+      *ngIf="
+        context.barOptions.orientation === orientation.VERTICAL;
+        else elseTemplate
+      "
+    >
+      <svg:g *ngFor="let tick of ticks; let i = index">
+        <text
+          [attr.x]="
+            i === ticks.length - 1 && tick.x >= context.chartView?.height
+              ? tick.x - 5
+              : tick.x
+          "
+          [attr.y]="tick.y + 16"
+          fill="#666"
+          [attr.text-anchor]="textAnchor"
+          font-size="11"
+        >
+          {{ translation ? (tick.value | translate: {}:true) : tick.value }}
+        </text>
+        <line
+          [attr.x1]="tick.x"
+          [attr.x2]="tick.x"
+          [attr.y1]="tick.y"
+          [attr.y2]="tick.y + 6"
+          stroke-width="1"
+          stroke="#ccd6eb"
+        ></line>
+      </svg:g>
+      <svg:g>
+        <path
+          [attr.d]="xAxisLine"
+          stroke="#ccd6eb"
+          fill="none"
+        />
+      </svg:g>
+    </ng-container>
+
+    <ng-template #elseTemplate>
+      <svg:g *ngFor="let tick of ticks; let i = index">
+        <text
+          x="-8"
+          [attr.y]="tick.x"
+          fill="#666"
+          text-anchor="end"
+          font-size="11"
+          alignment-baseline="middle"
+        >
+          {{
+            translation
+              ? (tick.value | translate | translate: {}:true)
+              : tick.value
+          }}
+        </text>
+      </svg:g>
+      <svg:g>
+        <path
+          [attr.d]="yAxisLine"
+          stroke="#ccd6eb"
+          fill="none"
+        />
+      </svg:g>
+    </ng-template>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.ContextChartService }, { type: i0.ChangeDetectorRef }]; }, { dateFormat: [{
+            type: Input
+        }], translation: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"x-axis-ticks.component.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/chart/common/axis/x-axis-ticks.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnInit,\n} from '@angular/core';\nimport { ScalePoint, ScaleTime } from 'd3';\nimport dayjs from 'dayjs';\nimport { map } from 'rxjs';\n\nimport { ContextChartService } from '../../chart.service';\nimport { Orientation, Tick, TickValue } from '../../types';\nimport { ScaleType, reduceTicks } from '../../utils';\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'g[aclXAxisTicks]',\n  template: `\n    <ng-container\n      *ngIf=\"\n        context.barOptions.orientation === orientation.VERTICAL;\n        else elseTemplate\n      \"\n    >\n      <svg:g *ngFor=\"let tick of ticks; let i = index\">\n        <text\n          [attr.x]=\"\n            i === ticks.length - 1 && tick.x >= context.chartView?.height\n              ? tick.x - 5\n              : tick.x\n          \"\n          [attr.y]=\"tick.y + 16\"\n          fill=\"#666\"\n          [attr.text-anchor]=\"textAnchor\"\n          font-size=\"11\"\n        >\n          {{ translation ? (tick.value | translate: {}:true) : tick.value }}\n        </text>\n        <line\n          [attr.x1]=\"tick.x\"\n          [attr.x2]=\"tick.x\"\n          [attr.y1]=\"tick.y\"\n          [attr.y2]=\"tick.y + 6\"\n          stroke-width=\"1\"\n          stroke=\"#ccd6eb\"\n        ></line>\n      </svg:g>\n      <svg:g>\n        <path\n          [attr.d]=\"xAxisLine\"\n          stroke=\"#ccd6eb\"\n          fill=\"none\"\n        />\n      </svg:g>\n    </ng-container>\n\n    <ng-template #elseTemplate>\n      <svg:g *ngFor=\"let tick of ticks; let i = index\">\n        <text\n          x=\"-8\"\n          [attr.y]=\"tick.x\"\n          fill=\"#666\"\n          text-anchor=\"end\"\n          font-size=\"11\"\n          alignment-baseline=\"middle\"\n        >\n          {{\n            translation\n              ? (tick.value | translate | translate: {}:true)\n              : tick.value\n          }}\n        </text>\n      </svg:g>\n      <svg:g>\n        <path\n          [attr.d]=\"yAxisLine\"\n          stroke=\"#ccd6eb\"\n          fill=\"none\"\n        />\n      </svg:g>\n    </ng-template>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class XAxisTicksComponent implements OnInit {\n  @Input() dateFormat: string;\n\n  @Input() translation: boolean;\n\n  textAnchor = 'middle';\n  orientation = Orientation;\n  get context() {\n    return this.contextService;\n  }\n\n  ticks: Tick[];\n  get yAxisLine() {\n    return `M${0} ${0}L${0} ${this.context.chartView.height}Z`;\n  }\n\n  get xAxisLine() {\n    const { width } = this.contextService.chartView;\n    return `M0 0L${width} 0Z`;\n  }\n\n  getTicks() {\n    let ticks: Tick[];\n    if (this.context.scaleType === ScaleType.ORDINAL) {\n      const maxTicks = this.getMaxTicks(20);\n      ticks = reduceTicks(this.context.x.domain(), maxTicks).map(\n        this.handleTicksData,\n      );\n    } else {\n      ticks = (this.context.x as ScaleTime<number, number>)\n        .ticks(this.getMaxTicks(100))\n        .map(this.handleTicksData);\n    }\n    return ticks;\n  }\n\n  handleTicksData = (value: TickValue): Tick => {\n    const bandwidth = this.context.barOptions.isBand\n      ? (this.context.x as ScalePoint<string>).bandwidth() * 0.5\n      : 0;\n    return {\n      value: this.format(value),\n      x: this.context.x(value) + bandwidth,\n      y: 0,\n    } as Tick;\n  };\n\n  getMaxTicks(tickWidth: number): number {\n    const width = this.context.horizontal\n      ? this.context.chartView.height\n      : this.context.chartView.width;\n    return Math.floor(width / tickWidth);\n  }\n\n  constructor(\n    private readonly contextService: ContextChartService,\n    private readonly cdr: ChangeDetectorRef,\n  ) {}\n\n  ngOnInit() {\n    this.contextService.seriesData$\n      .pipe(map(() => this.getTicks()))\n      .subscribe(res => {\n        this.ticks = res;\n        this.cdr.detectChanges();\n      });\n  }\n\n  format(value: string | number | Date) {\n    return this.contextService.scaleType === ScaleType.TIME\n      ? dayjs(value).format(this.dateFormat)\n      : value;\n  }\n}\n"]}