@alauda-fe/common 1.0.0-next.0

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

@@ -0,0 +1,109 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { Subject, map, takeUntil } from 'rxjs';
+import { ContextChartService } from '../../chart.service';
+import { DATE_TIME_FORMAT_X_AXIS } from '../../constants';
+import { Orientation } from '../../types';
+import { ScaleType } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../chart.service";
+const _c0 = ["aclXAxis", ""];
+function XAxisComponent__svg_g_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "g", 2);
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("label", ctx_r0.title)("offsetX", ctx_r0.labelOffsetX)("offsetY", ctx_r0.labelOffsetY)("align", ctx_r0.align)("height", ctx_r0.view.height)("width", ctx_r0.view.width)("rotation", ctx_r0.rotation);
+} }
+export class XAxisComponent {
+    get view() {
+        return this.context.chartView;
+    }
+    constructor(context, cdr) {
+        this.context = context;
+        this.cdr = cdr;
+        this.align = 'middle';
+        this.labelOffsetX = 0;
+        this.labelOffsetY = 0;
+        this.axisLabelFormats = DATE_TIME_FORMAT_X_AXIS;
+        this.destroy$$ = new Subject();
+    }
+    ngOnInit() {
+        this.context.showXLabel = !!this.title;
+        if (this.scaleType) {
+            this.context.scaleType = this.scaleType;
+        }
+        this.context.update$$
+            .pipe(map(() => `translate(0,${this.context.barOptions.orientation === Orientation.VERTICAL
+            ? this.context.chartView.height
+            : 0})`), takeUntil(this.destroy$$))
+            .subscribe(res => {
+            this.transform = res;
+            this.cdr.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function XAxisComponent_Factory(t) { return new (t || XAxisComponent)(i0.ɵɵdirectiveInject(i1.ContextChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAxisComponent, selectors: [["g", "aclXAxis", ""]], inputs: { title: "title", tickCount: "tickCount", align: "align", labelOffsetX: "labelOffsetX", labelOffsetY: "labelOffsetY", dateTimeLabelFormats: "dateTimeLabelFormats", rotation: "rotation", scaleType: "scaleType", translation: "translation" }, attrs: _c0, decls: 3, vars: 4, consts: [["aclXAxisTicks", "", 3, "dateFormat", "translation"], ["aclAxisLabel", "", 3, "label", "offsetX", "offsetY", "align", "height", "width", "rotation", 4, "ngIf"], ["aclAxisLabel", "", 3, "label", "offsetX", "offsetY", "align", "height", "width", "rotation"]], template: function XAxisComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵnamespaceSVG();
+            i0.ɵɵelementStart(0, "g");
+            i0.ɵɵelement(1, "g", 0);
+            i0.ɵɵtemplate(2, XAxisComponent__svg_g_2_Template, 1, 7, "g", 1);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵattribute("transform", ctx.transform);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("dateFormat", ctx.dateTimeLabelFormats || ctx.axisLabelFormats)("translation", ctx.translation);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngIf", ctx.title);
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAxisComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclXAxis]',
+                template: `
+    <svg:g [attr.transform]="transform">
+      <svg:g
+        aclXAxisTicks
+        [dateFormat]="dateTimeLabelFormats || axisLabelFormats"
+        [translation]="translation"
+      />
+      <svg:g
+        aclAxisLabel
+        *ngIf="title"
+        [label]="title"
+        [offsetX]="labelOffsetX"
+        [offsetY]="labelOffsetY"
+        [align]="align"
+        [height]="view.height"
+        [width]="view.width"
+        [rotation]="rotation"
+      ></svg:g>
+    </svg:g>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.ContextChartService }, { type: i0.ChangeDetectorRef }]; }, { title: [{
+            type: Input
+        }], tickCount: [{
+            type: Input
+        }], align: [{
+            type: Input
+        }], labelOffsetX: [{
+            type: Input
+        }], labelOffsetY: [{
+            type: Input
+        }], dateTimeLabelFormats: [{
+            type: Input
+        }], rotation: [{
+            type: Input
+        }], scaleType: [{
+            type: Input
+        }], translation: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/common/axis/x-plot-lines.component.mjs

@@ -0,0 +1,101 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { Observable, Subject, merge, takeUntil } from 'rxjs';
+import { ObservableInput } from '../../../core/public-api';
+import { ContextChartService } from '../../chart.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../chart.service";
+import * as i2 from "@angular/common";
+const _c0 = ["aclXPlotLines", ""];
+function XPlotLinesComponent__svg_g_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g")(1, "text", 1);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(3, "path", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("y", ctx_r0.y)("fill", ctx_r0.color || "#FF0000");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", ctx_r0.value, " ");
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("d", ctx_r0.path)("stroke-width", ctx_r0.width || 1)("stroke", ctx_r0.color || "#FF0000")("stroke-dasharray", ctx_r0.dasharray);
+} }
+export class XPlotLinesComponent {
+    get dasharray() {
+        return this.dashType === 'dash' ? [4, 2] : [0, 0];
+    }
+    get view() {
+        return this.context.chartView;
+    }
+    constructor(context, cdr) {
+        this.context = context;
+        this.cdr = cdr;
+        this.dashType = 'solid';
+        this.y = 0;
+        this.destroy$$ = new Subject();
+    }
+    ngOnInit() {
+        merge([this.value$, this.context.seriesData$])
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => {
+            this.y = this.context.y(this.value);
+            this.path = `M0 ${this.y}L${this.view.width} ${this.y}`;
+            this.cdr.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function XPlotLinesComponent_Factory(t) { return new (t || XPlotLinesComponent)(i0.ɵɵdirectiveInject(i1.ContextChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XPlotLinesComponent, selectors: [["g", "aclXPlotLines", ""]], inputs: { value: "value", color: "color", dashType: "dashType", width: "width" }, attrs: _c0, decls: 1, vars: 1, consts: [[4, "ngIf"], ["x", "-8", "text-anchor", "end", "font-size", "11", "alignment-baseline", "middle"], ["fill", "none"]], template: function XPlotLinesComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, XPlotLinesComponent__svg_g_0_Template, 4, 7, "g", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", !!ctx.path);
+        } }, dependencies: [i2.NgIf], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], XPlotLinesComponent.prototype, "value$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XPlotLinesComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclXPlotLines]',
+                template: `
+    <svg:g *ngIf="!!path">
+      <text
+        x="-8"
+        [attr.y]="y"
+        [attr.fill]="color || '#FF0000'"
+        text-anchor="end"
+        font-size="11"
+        alignment-baseline="middle"
+      >
+        {{ value }}
+      </text>
+      <path
+        [attr.d]="path"
+        fill="none"
+        [attr.stroke-width]="width || 1"
+        [attr.stroke]="color || '#FF0000'"
+        [attr.stroke-dasharray]="dasharray"
+      />
+    </svg:g>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.ContextChartService }, { type: i0.ChangeDetectorRef }]; }, { value: [{
+            type: Input
+        }], value$: [], color: [{
+            type: Input
+        }], dashType: [{
+            type: Input
+        }], width: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,233 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { Subject, merge, map, takeUntil } from 'rxjs';
+import { ContextChartService } from '../../chart.service';
+import { Orientation } from '../../types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../chart.service";
+const _c0 = ["aclYAxisTicks", ""];
+function YAxisTicksComponent_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, "pure");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(4, "line", 5)(5, "line", 6);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const tick_r4 = ctx.$implicit;
+    const ctx_r3 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("y", tick_r4.y);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate2(" ", i0.ɵɵpipeBind2(3, 8, tick_r4.value, ctx_r3.conversionMaximum), "", ctx_r3.suffix, " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("y1", tick_r4.y)("y2", tick_r4.y);
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("x2", ctx_r3.context == null ? null : ctx_r3.context.chartView == null ? null : ctx_r3.context.chartView.width)("y1", tick_r4.y)("y2", tick_r4.y);
+} }
+function YAxisTicksComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, YAxisTicksComponent_ng_container_0__svg_g_1_Template, 6, 11, "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.yAxisLine);
+} }
+function YAxisTicksComponent_ng_template_1__svg_g_0__svg_line_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "line", 9);
+} if (rf & 2) {
+    const tick_r6 = i0.ɵɵnextContext().$implicit;
+    const ctx_r8 = i0.ɵɵnextContext(2);
+    i0.ɵɵattribute("x1", tick_r6.x)("x2", tick_r6.x)("y1", 0)("y2", -(ctx_r8.context == null ? null : ctx_r8.context.chartView == null ? null : ctx_r8.context.chartView.height));
+} }
+function YAxisTicksComponent_ng_template_1__svg_g_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g")(1, "text", 7);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "pure");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(4, YAxisTicksComponent_ng_template_1__svg_g_0__svg_line_4_Template, 1, 4, "line", 8);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const tick_r6 = ctx.$implicit;
+    const i_r7 = ctx.index;
+    const ctx_r5 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵattribute("x", i_r7 === 0 && ctx_r5.suffix ? tick_r6.x - 5 : tick_r6.x)("y", tick_r6.y + 16)("text-anchor", ctx_r5.textAnchor);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate2(" ", i0.ɵɵpipeBind2(3, 6, tick_r6.value, ctx_r5.conversionMaximum), "", ctx_r5.suffix, " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", i_r7 !== ctx_r5.ticks.length - 1);
+} }
+function YAxisTicksComponent_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, YAxisTicksComponent_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.xAxisLine);
+} }
+export class YAxisTicksComponent {
+    get yAxisLine() {
+        return `M${0} ${0}L${0} ${this.context.chartView.height}Z`;
+    }
+    get xAxisLine() {
+        const { width } = this.context.chartView;
+        return `M0 0L${width} 0Z`;
+    }
+    getTicks() {
+        const ticks = this.context.y.ticks(this.getMaxTicks(this.intervalWidth));
+        return ticks.map(value => {
+            const res = this.context.y(value);
+            return {
+                value,
+                y: this.context.horizontal ? 0 : res,
+                x: res,
+            };
+        });
+    }
+    getMaxTicks(tickHeight) {
+        const height = this.context.horizontal
+            ? this.context.chartView.width
+            : this.context.chartView.height;
+        return Math.floor(height / tickHeight);
+    }
+    constructor(context, cd) {
+        this.context = context;
+        this.cd = cd;
+        this.intervalWidth = 40;
+        this.orientation = Orientation;
+        this.textAnchor = 'middle';
+        this.destroy$$ = new Subject();
+    }
+    ngOnInit() {
+        this.ticks = this.getTicks();
+        this.cd.detectChanges();
+        merge(this.context.seriesData$, this.context.legendChange$$)
+            .pipe(takeUntil(this.destroy$$), map(() => this.getTicks()))
+            .subscribe(res => {
+            this.ticks = res;
+            this.cd.detectChanges();
+        });
+    }
+    conversionMaximum(value) {
+        const unit = 'k';
+        if (value >= 1000) {
+            const num = +(value / 1000).toFixed(2);
+            return `${num}${unit}`;
+        }
+        return value;
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+    }
+    static { this.ɵfac = function YAxisTicksComponent_Factory(t) { return new (t || YAxisTicksComponent)(i0.ɵɵdirectiveInject(i1.ContextChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: YAxisTicksComponent, selectors: [["g", "aclYAxisTicks", ""]], inputs: { intervalWidth: "intervalWidth", suffix: "suffix" }, attrs: _c0, decls: 3, vars: 2, consts: [[4, "ngIf", "ngIfElse"], ["elseTemplate", ""], [4, "ngFor", "ngForOf"], ["stroke", "#ccd6eb", "fill", "none"], ["x", "-8", "fill", "#666", "text-anchor", "end", "font-size", "11", "alignment-baseline", "middle"], ["x1", "-4", "x2", "0", "stroke-width", "1", "stroke", "#ccd6eb"], ["x1", "0", "stroke-width", "1", "stroke-dasharray", "4 1", "stroke", "#e8e8e8"], ["fill", "#666", "font-size", "11"], ["stroke-width", "1", "stroke-dasharray", "4 1", "stroke", "#e8e8e8", 4, "ngIf"], ["stroke-width", "1", "stroke-dasharray", "4 1", "stroke", "#e8e8e8"]], template: function YAxisTicksComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, YAxisTicksComponent_ng_container_0_Template, 4, 2, "ng-container", 0);
+            i0.ɵɵtemplate(1, YAxisTicksComponent_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(YAxisTicksComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclYAxisTicks]',
+                template: `
+    <ng-container
+      *ngIf="
+        context.barOptions.orientation === orientation.VERTICAL;
+        else elseTemplate
+      "
+    >
+      <svg:g *ngFor="let tick of ticks">
+        <text
+          x="-8"
+          [attr.y]="tick.y"
+          fill="#666"
+          text-anchor="end"
+          font-size="11"
+          alignment-baseline="middle"
+        >
+          {{ tick.value | pure: conversionMaximum }}{{ suffix }}
+        </text>
+        <line
+          x1="-4"
+          x2="0"
+          [attr.y1]="tick.y"
+          [attr.y2]="tick.y"
+          stroke-width="1"
+          stroke="#ccd6eb"
+        ></line>
+        <line
+          x1="0"
+          [attr.x2]="context?.chartView?.width"
+          [attr.y1]="tick.y"
+          [attr.y2]="tick.y"
+          stroke-width="1"
+          stroke-dasharray="4 1"
+          stroke="#e8e8e8"
+        ></line>
+      </svg:g>
+      <svg:g>
+        <path
+          [attr.d]="yAxisLine"
+          stroke="#ccd6eb"
+          fill="none"
+        />
+      </svg:g>
+    </ng-container>
+
+    <ng-template #elseTemplate>
+      <svg:g *ngFor="let tick of ticks; let i = index">
+        <text
+          [attr.x]="i === 0 && suffix ? tick.x - 5 : tick.x"
+          [attr.y]="tick.y + 16"
+          fill="#666"
+          [attr.text-anchor]="textAnchor"
+          font-size="11"
+        >
+          {{ tick.value | pure: conversionMaximum }}{{ suffix }}
+        </text>
+        <line
+          *ngIf="i !== ticks.length - 1"
+          [attr.x1]="tick.x"
+          [attr.x2]="tick.x"
+          [attr.y1]="0"
+          [attr.y2]="-context?.chartView?.height"
+          stroke-width="1"
+          stroke-dasharray="4 1"
+          stroke="#e8e8e8"
+        ></line>
+      </svg:g>
+      <svg:g>
+        <path
+          [attr.d]="xAxisLine"
+          stroke="#ccd6eb"
+          fill="none"
+        />
+      </svg:g>
+    </ng-template>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.ContextChartService }, { type: i0.ChangeDetectorRef }]; }, { intervalWidth: [{
+            type: Input
+        }], suffix: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"y-axis-ticks.component.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/chart/common/axis/y-axis-ticks.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport { Subject, merge, map, takeUntil } from 'rxjs';\n\nimport { ContextChartService } from '../../chart.service';\nimport { Orientation } from '../../types';\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'g[aclYAxisTicks]',\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\">\n        <text\n          x=\"-8\"\n          [attr.y]=\"tick.y\"\n          fill=\"#666\"\n          text-anchor=\"end\"\n          font-size=\"11\"\n          alignment-baseline=\"middle\"\n        >\n          {{ tick.value | pure: conversionMaximum }}{{ suffix }}\n        </text>\n        <line\n          x1=\"-4\"\n          x2=\"0\"\n          [attr.y1]=\"tick.y\"\n          [attr.y2]=\"tick.y\"\n          stroke-width=\"1\"\n          stroke=\"#ccd6eb\"\n        ></line>\n        <line\n          x1=\"0\"\n          [attr.x2]=\"context?.chartView?.width\"\n          [attr.y1]=\"tick.y\"\n          [attr.y2]=\"tick.y\"\n          stroke-width=\"1\"\n          stroke-dasharray=\"4 1\"\n          stroke=\"#e8e8e8\"\n        ></line>\n      </svg:g>\n      <svg:g>\n        <path\n          [attr.d]=\"yAxisLine\"\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          [attr.x]=\"i === 0 && suffix ? tick.x - 5 : tick.x\"\n          [attr.y]=\"tick.y + 16\"\n          fill=\"#666\"\n          [attr.text-anchor]=\"textAnchor\"\n          font-size=\"11\"\n        >\n          {{ tick.value | pure: conversionMaximum }}{{ suffix }}\n        </text>\n        <line\n          *ngIf=\"i !== ticks.length - 1\"\n          [attr.x1]=\"tick.x\"\n          [attr.x2]=\"tick.x\"\n          [attr.y1]=\"0\"\n          [attr.y2]=\"-context?.chartView?.height\"\n          stroke-width=\"1\"\n          stroke-dasharray=\"4 1\"\n          stroke=\"#e8e8e8\"\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-template>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class YAxisTicksComponent implements OnInit, OnDestroy {\n  @Input() intervalWidth = 40;\n\n  @Input() suffix: string;\n\n  ticks: Array<{ value: number; y: number; x: number }>;\n  orientation = Orientation;\n  textAnchor = 'middle';\n\n  destroy$$ = new Subject<void>();\n\n  get yAxisLine() {\n    return `M${0} ${0}L${0} ${this.context.chartView.height}Z`;\n  }\n\n  get xAxisLine() {\n    const { width } = this.context.chartView;\n    return `M0 0L${width} 0Z`;\n  }\n\n  getTicks() {\n    const ticks = this.context.y.ticks(this.getMaxTicks(this.intervalWidth));\n    return ticks.map(value => {\n      const res = this.context.y(value);\n      return {\n        value,\n        y: this.context.horizontal ? 0 : res,\n        x: res,\n      };\n    });\n  }\n\n  getMaxTicks(tickHeight: number): number {\n    const height = this.context.horizontal\n      ? this.context.chartView.width\n      : this.context.chartView.height;\n    return Math.floor(height / tickHeight);\n  }\n\n  constructor(\n    public readonly context: ContextChartService,\n    private readonly cd: ChangeDetectorRef,\n  ) {}\n\n  ngOnInit() {\n    this.ticks = this.getTicks();\n    this.cd.detectChanges();\n    merge(this.context.seriesData$, this.context.legendChange$$)\n      .pipe(\n        takeUntil(this.destroy$$),\n        map(() => this.getTicks()),\n      )\n      .subscribe(res => {\n        this.ticks = res;\n        this.cd.detectChanges();\n      });\n  }\n\n  conversionMaximum(value: number) {\n    const unit = 'k';\n    if (value >= 1000) {\n      const num = +(value / 1000).toFixed(2);\n      return `${num}${unit}`;\n    }\n    return value;\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n  }\n}\n"]}

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

@@ -0,0 +1,122 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { Subject, map, takeUntil } from 'rxjs';
+import { ContextChartService } from '../../chart.service';
+import { Orientation } from '../../types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../chart.service";
+const _c0 = ["aclYAxis", ""];
+function YAxisComponent__svg_g_0__svg_g_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelement(0, "g", 3);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵstyleMap(ctx_r1.titleStyle);
+    i0.ɵɵproperty("label", ctx_r1.title)("offsetX", ctx_r1.labelOffsetX)("offsetY", ctx_r1.labelOffsetY)("align", ctx_r1.align)("height", ctx_r1.view.height)("width", ctx_r1.view.width)("isVertical", true)("rotation", ctx_r1.rotation);
+} }
+function YAxisComponent__svg_g_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g");
+    i0.ɵɵelement(1, "g", 1);
+    i0.ɵɵtemplate(2, YAxisComponent__svg_g_0__svg_g_2_Template, 1, 10, "g", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵattribute("transform", ctx_r0.transform);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("suffix", ctx_r0.tickSuffix)("intervalWidth", ctx_r0.intervalWidth || ctx_r0.INTERVAL_WIDTH);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.title);
+} }
+const INTERVAL_WIDTH = 40;
+export class YAxisComponent {
+    get view() {
+        return this.context.chartView;
+    }
+    constructor(context, cdr) {
+        this.context = context;
+        this.cdr = cdr;
+        this.align = 'middle';
+        this.labelOffsetX = 0;
+        this.labelOffsetY = 0;
+        this.INTERVAL_WIDTH = INTERVAL_WIDTH;
+        this.destroy$$ = new Subject();
+    }
+    ngOnInit() {
+        this.context.showYLabel = !!this.title;
+        this.context.yScaleMin = this.min;
+        this.context.yScaleMax = this.max;
+        this.context.update$$
+            .pipe(map(() => `translate(0,${this.context.barOptions.orientation === Orientation.VERTICAL
+            ? 0
+            : this.context.chartView.height})`), takeUntil(this.destroy$$))
+            .subscribe(res => {
+            this.transform = res;
+            this.cdr.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function YAxisComponent_Factory(t) { return new (t || YAxisComponent)(i0.ɵɵdirectiveInject(i1.ContextChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: YAxisComponent, selectors: [["g", "aclYAxis", ""]], inputs: { title: "title", align: "align", labelOffsetX: "labelOffsetX", labelOffsetY: "labelOffsetY", intervalWidth: "intervalWidth", tickSuffix: "tickSuffix", max: "max", min: "min", titleStyle: "titleStyle", rotation: "rotation" }, attrs: _c0, decls: 2, vars: 3, consts: [[4, "ngIf"], ["aclYAxisTicks", "", 3, "suffix", "intervalWidth"], ["aclAxisLabel", "", 3, "label", "offsetX", "offsetY", "align", "height", "width", "isVertical", "style", "rotation", 4, "ngIf"], ["aclAxisLabel", "", 3, "label", "offsetX", "offsetY", "align", "height", "width", "isVertical", "rotation"]], template: function YAxisComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, YAxisComponent__svg_g_0_Template, 3, 4, "g", 0);
+            i0.ɵɵpipe(1, "async");
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", !i0.ɵɵpipeBind1(1, 1, ctx.context.noData$));
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(YAxisComponent, [{
+        type: Component,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/component-selector
+                selector: 'g[aclYAxis]',
+                template: `
+    <svg:g
+      [attr.transform]="transform"
+      *ngIf="!(context.noData$ | async)"
+    >
+      <svg:g
+        aclYAxisTicks
+        [suffix]="tickSuffix"
+        [intervalWidth]="intervalWidth || INTERVAL_WIDTH"
+      />
+      <svg:g
+        aclAxisLabel
+        *ngIf="title"
+        [label]="title"
+        [offsetX]="labelOffsetX"
+        [offsetY]="labelOffsetY"
+        [align]="align"
+        [height]="view.height"
+        [width]="view.width"
+        [isVertical]="true"
+        [style]="titleStyle"
+        [rotation]="rotation"
+      ></svg:g>
+    </svg:g>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], function () { return [{ type: i1.ContextChartService }, { type: i0.ChangeDetectorRef }]; }, { title: [{
+            type: Input
+        }], align: [{
+            type: Input
+        }], labelOffsetX: [{
+            type: Input
+        }], labelOffsetY: [{
+            type: Input
+        }], intervalWidth: [{
+            type: Input
+        }], tickSuffix: [{
+            type: Input
+        }], max: [{
+            type: Input
+        }], min: [{
+            type: Input
+        }], titleStyle: [{
+            type: Input
+        }], rotation: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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