igniteui-angular-charts
Version:
Ignite UI Angular charting components for building rich data visualizations for modern web apps.
1,045 lines (1,044 loc) • 33.8 kB
JavaScript
/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE: you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { XYChart } from "./XYChart";
import { typeCast, runOn, delegateCombine, enumGetBox, markType, TypeRegistrar, getInstanceType } from "igniteui-angular-core";
import { CategoryChartType_$type } from "./CategoryChartType";
import { CategorySeriesMarkerCollisionAvoidance_$type } from "./CategorySeriesMarkerCollisionAvoidance";
import { CategoryTransitionInMode_$type } from "./CategoryTransitionInMode";
import { TransitionInSpeedType_$type } from "./TransitionInSpeedType";
import { AutoMarginsAndAngleUpdateMode_$type } from "./AutoMarginsAndAngleUpdateMode";
import { AxisRangeBufferMode_$type } from "./AxisRangeBufferMode";
import { CategoryXAxis } from "./CategoryXAxis";
import { List$1 } from "igniteui-angular-core";
import { DataSeriesType_$type } from "igniteui-angular-core";
import { NumericYAxis } from "./NumericYAxis";
import { IDataSeriesAdapterRule_$type } from "igniteui-angular-core";
import { SimpleCategorySeriesRule } from "igniteui-angular-core";
import { SubCollectionsRule } from "igniteui-angular-core";
import { DVContainer } from "igniteui-angular-core";
import { Brush } from "igniteui-angular-core";
import { AxisDefaults } from "./AxisDefaults";
import { Defaults } from "./Defaults";
import { Series } from "./Series";
import { HorizontalAnchoredCategorySeries } from "./HorizontalAnchoredCategorySeries";
import { ArrayExtension } from "igniteui-angular-core";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { DeviceUtils } from "igniteui-angular-core";
import { CategoryChartMockDataGenerator } from "./CategoryChartMockDataGenerator";
import { stringIsNullOrEmpty } from "igniteui-angular-core";
/**
* @hidden
*/
export let CategoryChart = /*@__PURE__*/ (() => {
class CategoryChart extends XYChart {
constructor() {
super();
this.ald = 1000;
this.ale = 1000;
this.ajg = null;
this.ajh = null;
this.ai0 = 9;
this.ai2 = 1;
this.ajm = false;
this.ajn = true;
this.ai4 = 0;
this.aje = 0;
this.aka = 0;
this.akd = 0;
this.aj9 = 0;
this.akc = 0;
this.akb = 1;
this.ake = 0;
this.akk = NaN;
this.aiw = 1;
this.ajo = true;
this.ajp = true;
this.aj7 = DeviceUtils.g(2);
this.aj8 = DeviceUtils.g(60);
this.ajt = true;
this.ajq = true;
this.ajs = false;
this.aiy = 0;
this.aju = false;
this.alf = 10;
this.akm = NaN;
this.akl = NaN;
this.akn = 0;
this.ais = null;
this.ait = null;
this.ajr = true;
this.akf = 3;
this.akg = NaN;
this.akh = NaN;
this.aki = NaN;
this.akj = NaN;
this.ajk = false;
this.ajl = false;
this.aj6 = null;
DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
this.vn();
}
v9() {
super.v9();
if (this.dataChart == null) {
return;
}
let a = this.dataChart.dw.j.e();
this.aiu = a.d;
this.aiv = a.e;
if (this.ah4 == null) {
this.ah4 = a.k;
}
if (this.aib == null) {
this.aib = a.k;
}
this.adz = 0;
this.aic = AxisDefaults.axis_MajorBrush;
this.aif = null;
this.ah8 = AxisDefaults.axis_LineBrush;
this.ah5 = null;
this.adg = AxisDefaults.categoryAxis_TickLength;
this.ah9 = AxisDefaults.axis_TickBrush;
this.adh = AxisDefaults.axis_TickStroke;
this.crosshairsAnnotationEnabled = true;
this.g0 = true;
this.crosshairsDisplayMode = 0;
this.j3 = Defaults.crosshairLineThickness;
this.zt = Defaults.crosshairLineBrush;
this.zo = Defaults.crosshairXAxisAnnotationBackground;
this.zp = Defaults.crosshairXAxisAnnotationTextColor;
this.ajy = true;
}
wb(a, b) {
super.wb(a, b);
a.kn = this.alg;
a.ko = this.alh;
a.df = this.aji;
a.dg = this.ajj;
}
w5(a, b, c) {
super.w5(a, b, c);
switch (a) {
case "TransitionInDuration":
this.vy((d) => d.kn = this.alg);
break;
case "TransitionOutDuration":
this.vy((d) => d.ko = this.alh);
break;
case "TransitionInEasingFunction":
this.vy((d) => d.df = this.aji);
break;
case "TransitionOutEasingFunction":
this.vy((d) => d.dg = this.ajj);
break;
}
}
get alg() {
return this.ald;
}
set alg(a) {
let b = this.alg;
if (a != b) {
this.ald = a;
this.w1("TransitionInDuration", b, this.alg);
}
}
get alh() {
return this.ale;
}
set alh(a) {
let b = this.alh;
if (a != b) {
this.ale = a;
this.w1("TransitionOutDuration", b, this.alh);
}
}
get aji() {
return this.ajg;
}
set aji(a) {
let b = this.aji;
if (a != b) {
this.ajg = a;
this.w1("TransitionInEasingFunction", b, this.aji);
}
}
get ajj() {
return this.ajh;
}
set ajj(a) {
let b = this.ajj;
if (a != b) {
this.ajh = a;
this.w1("TransitionOutEasingFunction", b, this.ajj);
}
}
aln() {
let cvd_ = this.mj();
cvd_.scaleByViewport();
return (cvd_.serialize());
}
v4(a, b) {
super.v4(a, b);
a.e8 = this.gr;
a.aal = this.ajz;
a.aao = this.aj0;
a.abc = this.ako;
a.abd = this.akp;
a.zg = this.aix;
}
wa(a, b) {
super.wa(a, b);
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c == null) {
return;
}
c.abj = this.ai3;
c.z5 = this.ajy;
c.zp = this.ai5;
c.c6 = this.ajf;
c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
c.trendLineType = this.ee;
c.trendLineThickness = this.k0;
c.xu = this.c4(a, b);
if (a.fp) {
a.sk(ArrayExtension.getModulus$1(Brush.$, this.aiu, b), ArrayExtension.getModulus$1(Brush.$, this.aiv, b));
}
}
ai6() {
return new CategoryXAxis();
}
aja() {
return new NumericYAxis();
}
vi() {
this.xAxis = this.ai6();
this.xAxis.name = "xAxis";
let a = this.xAxis;
a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.amr));
this.yAxis = this.aja();
this.yAxis.name = "yAxis";
let b = this.yAxis;
b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.ams));
if (this.xAxis.a4 == null) {
this.xAxis.a4 = new AxisLabelSettings();
}
if (this.yAxis.a4 == null) {
this.yAxis.a4 = new AxisLabelSettings();
}
}
ag4(a) {
super.ag4(a);
a.p3 = this.aj2;
a.p8 = this.aj4;
a.cy = this.aj3;
}
ag2(a) {
super.ag2(a);
a.cy = this.aj1;
a.zoomMaximumCategoryRange = this.ak2;
a.zoomToCategoryRange = this.ak4;
a.zoomToCategoryStart = this.ak5;
a.zoomMaximumItemSpan = this.ak3;
a.zoomToItemSpan = this.ak6;
}
get_cd() {
return 0;
}
get cd() {
return this.get_cd();
}
get ai1() {
return this.ai0;
}
set ai1(a) {
if (a != this.ai0) {
let b = this.ai1;
this.ai0 = a;
this.w1("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ai1));
}
}
get ai3() {
return this.ai2;
}
set ai3(a) {
let b = this.ai3;
if (a != b) {
this.ai2 = a;
this.w1("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ai3));
}
}
get ajx() {
return this.ajm;
}
set ajx(a) {
let b = this.ajx;
if (a != b) {
this.ajm = a;
this.w1("IsSplineShapePartOfRange", b, this.ajx);
}
}
get ajy() {
return this.ajn;
}
set ajy(a) {
let b = this.ajy;
if (a != b) {
this.ajn = a;
this.w1("IsTransitionInEnabled", b, this.ajy);
}
}
get ai5() {
return this.ai4;
}
set ai5(a) {
let b = this.ai5;
if (a != b) {
this.ai4 = a;
this.w1("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ai5));
}
}
get ajf() {
return this.aje;
}
set ajf(a) {
let b = this.ajf;
if (a != b) {
this.aje = a;
this.w1("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ajf));
}
}
get akx() {
return this.aka;
}
set akx(a) {
let b = this.akx;
if (a != b) {
this.aka = a;
this.w1("XAxisInterval", b, this.akx);
}
}
get ak0() {
return this.akd;
}
set ak0(a) {
let b = this.ak0;
if (a != b) {
this.akd = a;
this.w1("XAxisMinorInterval", b, this.ak0);
}
}
get akw() {
return this.aj9;
}
set akw(a) {
let b = this.akw;
if (a != b) {
this.aj9 = a;
this.w1("XAxisGap", b, this.akw);
}
}
get akz() {
return this.akc;
}
set akz(a) {
let b = this.akz;
if (a != b) {
this.akc = a;
this.w1("XAxisMinimumGapSize", b, this.akz);
}
}
get aky() {
return this.akb;
}
set aky(a) {
let b = this.aky;
if (a != b) {
this.akb = a;
this.w1("XAxisMaximumGap", b, this.aky);
}
}
get ak1() {
return this.ake;
}
set ak1(a) {
let b = this.ak1;
if (a != b) {
this.ake = a;
this.w1("XAxisOverlap", b, this.ak1);
}
}
get ak9() {
return this.akk;
}
set ak9(a) {
let b = this.ak9;
if (a != b) {
this.akk = a;
this.w1("YAxisInterval", b, this.ak9);
}
}
get aix() {
return this.aiw;
}
set aix(a) {
let b = this.aix;
if (a != b) {
this.aiw = a;
this.w1("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.aix));
}
}
amt() {
if (this.dataChart != null) {
this.dataChart.ac0();
}
}
get ajz() {
return this.ajo;
}
set ajz(a) {
let b = this.ajz;
if (a != b) {
this.ajo = a;
this.w1("ShouldAutoExpandMarginForInitialLabels", b, this.ajz);
}
}
get aj0() {
return this.ajp;
}
set aj0(a) {
let b = this.aj0;
if (a != b) {
this.ajp = a;
this.w1(CategoryChart.alw, b, this.aj0);
}
}
get ako() {
return this.aj7;
}
set ako(a) {
let b = this.ako;
if (a != b) {
this.aj7 = a;
this.w1("AutoExpandMarginExtraPadding", b, this.ako);
}
}
get akp() {
return this.aj8;
}
set akp(a) {
let b = this.akp;
if (a != b) {
this.aj8 = a;
this.w1("AutoExpandMarginMaximumValue", b, this.akp);
}
}
get aj4() {
return this.ajt;
}
set aj4(a) {
let b = this.aj4;
if (a != b) {
this.ajt = a;
this.w1("YAxisFavorLabellingScaleEnd", b, this.aj4);
}
}
get aj1() {
return this.ajq;
}
set aj1(a) {
let b = this.aj1;
if (a != b) {
this.ajq = a;
this.w1(CategoryChart.al3, b, this.aj1);
}
}
get aj3() {
return this.ajs;
}
set aj3(a) {
let b = this.aj3;
if (a != b) {
this.ajs = a;
this.w1(CategoryChart.amh, b, this.aj3);
}
}
get aiz() {
return this.aiy;
}
set aiz(a) {
let b = this.aiz;
if (a != b) {
this.aiy = a;
this.w1("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.aiz));
}
}
get aj5() {
return this.aju;
}
set aj5(a) {
let b = this.aj5;
if (a != b) {
this.aju = a;
this.w1("YAxisIsLogarithmic", b, this.aj5);
}
}
get ali() {
return this.alf;
}
set ali(a) {
let b = this.ali;
if (a != b) {
this.alf = a;
this.w1("YAxisLogarithmBase", b, this.ali);
}
}
get alb() {
return this.akm;
}
set alb(a) {
let b = this.alb;
if (a != b) {
this.akm = a;
this.w1("YAxisMinimumValue", b, this.alb);
}
}
get ala() {
return this.akl;
}
set ala(a) {
let b = this.ala;
if (a != b) {
this.akl = a;
this.w1("YAxisMaximumValue", b, this.ala);
}
}
get alc() {
return this.akn;
}
set alc(a) {
let b = this.alc;
if (a != b) {
this.akn = a;
this.w1("YAxisMinorInterval", b, this.alc);
}
}
get akv() {
return this.xAxis.rr;
}
get aku() {
return this.xAxis.rq;
}
akr() {
return this.akv;
}
akt() {
return this.ak8;
}
akq() {
return this.aku;
}
aks() {
return this.ak7;
}
get ak8() {
return this.yAxis.qt;
}
get ak7() {
return this.yAxis.qs;
}
get aiu() {
return this.ais;
}
set aiu(a) {
let b = this.aiu;
if (a != b) {
this.ais = a;
this.w1("NegativeBrushes", b, this.aiu);
}
}
get aiv() {
return this.ait;
}
set aiv(a) {
let b = this.aiv;
if (a != b) {
this.ait = a;
this.w1("NegativeOutlines", b, this.aiv);
}
}
get aj2() {
return this.ajr;
}
set aj2(a) {
let b = this.aj2;
if (a != b) {
this.ajr = a;
this.w1("YAxisAbbreviateLargeNumbers", b, this.aj2);
}
}
get ak2() {
return this.akf;
}
set ak2(a) {
let b = this.ak2;
if (a != b) {
this.akf = a;
this.w1("XAxisZoomMaximumCategoryRange", b, this.ak2);
}
}
get ak3() {
return this.akg;
}
set ak3(a) {
let b = this.ak3;
if (a != b) {
this.akg = a;
this.w1("XAxisZoomMaximumItemSpan", b, this.ak3);
}
}
get ak4() {
return this.akh;
}
set ak4(a) {
let b = this.ak4;
if (a != b) {
this.akh = a;
this.w1("XAxisZoomToCategoryRange", b, this.ak4);
}
}
get ak5() {
return this.aki;
}
set ak5(a) {
let b = this.ak5;
if (a != b) {
this.aki = a;
this.w1("XAxisZoomToCategoryStart", b, this.ak5);
}
}
get ak6() {
return this.akj;
}
set ak6(a) {
let b = this.ak6;
if (a != b) {
this.akj = a;
this.w1("XAxisZoomToItemSpan", b, this.ak6);
}
}
get ajv() {
return this.ajk;
}
set ajv(a) {
let b = this.ajv;
if (a != b) {
this.ajk = a;
this.w1("IsCategoryHighlightingEnabled", b, this.ajv);
}
}
get ajw() {
return this.ajl;
}
set ajw(a) {
let b = this.ajw;
if (a != b) {
this.ajl = a;
this.w1("IsItemHighlightingEnabled", b, this.ajw);
}
}
get_ie() {
let a = new List$1(DataSeriesType_$type, 0);
if (TypeRegistrar.isRegistered("AreaSeries")) {
a.add(2);
}
if (TypeRegistrar.isRegistered("ColumnSeries")) {
a.add(1);
}
if (TypeRegistrar.isRegistered("LineSeries")) {
a.add(0);
}
if (TypeRegistrar.isRegistered("PointSeries")) {
a.add(10);
}
if (TypeRegistrar.isRegistered("SplineSeries")) {
a.add(6);
}
if (TypeRegistrar.isRegistered("SplineAreaSeries")) {
a.add(7);
}
if (TypeRegistrar.isRegistered("StepAreaSeries")) {
a.add(5);
}
if (TypeRegistrar.isRegistered("StepLineSeries")) {
a.add(4);
}
if (TypeRegistrar.isRegistered("WaterfallSeries")) {
a.add(8);
}
return a;
}
get ie() {
return this.get_ie();
}
il() {
if (this.aj6 == null) {
this.aj6 = CategoryChartMockDataGenerator.a();
}
return this.aj6;
}
c3(a) {
if (a != null) {
let b = super.c3(a);
if (b == 2) {
if (a.fo && this.hb) {
return 13;
}
}
}
return super.c3(a);
}
c5(a) {
if (a != null) {
let b = super.c3(a);
if (b == 2) {
if (a.fo && this.hb) {
return 13;
}
}
}
return super.c5(a);
}
get_hw() {
return true;
}
amr(a, b) {
switch (b.propertyName) {
case "ActualMinimum":
this.xk("XAxisActualMinimum");
break;
case "ActualMaximum":
this.xk("XAxisActualMaximum");
break;
}
}
ams(a, b) {
switch (b.propertyName) {
case "ActualMinimumValue":
this.xk("YAxisActualMinimum");
break;
case "ActualMaximumValue":
this.xk("YAxisActualMaximum");
break;
}
}
x1() {
super.x1();
this.xAxis.hw = this.ad9 == null ? XYChart.ael(this.xAxis, this.bg.dataSeries) : this.ad9;
this.xAxis.itemsSource = this.dataChart != null && this.dataChart.b9.count > 0 ? this.dataChart.b9._inner[0].itemsSource : null;
if (this.ajz) {
this.wp((a) => a.ac0());
}
}
get xAxis() {
return this._xAxis;
}
set xAxis(a) {
this._xAxis = a;
}
get yAxis() {
return this._yAxis;
}
set yAxis(a) {
this._yAxis = a;
}
ai9(a, b) {
switch (a) {
case 2: return this.dh(1);
case 3: return this.dh(10);
case 0: return this.dh(0);
case 1: return this.dh(2);
case 6: return this.dh(6);
case 7: return this.dh(7);
case 4: return this.dh(4);
case 5: return this.dh(5);
case 8: return this.dh(8);
case 9: return this.ai8(b);
default: return this.dh(1);
}
}
ai8(a) {
return this.dh(a);
}
bf(a) {
switch (this.ai1) {
case 1: return 2;
case 0: return 0;
case 3: return 10;
case 6: return 6;
case 7: return 7;
case 5: return 5;
case 4: return 4;
case 8: return 8;
case 9: return a.suggestedSeries;
default:
case 2: return 1;
}
}
de(a, b) {
let c = this.ai9(this.ai1, a.suggestedSeries);
c.ab9 = a.findMatchingHint(0).path;
c.xAxis = this.xAxis;
c.yAxis = this.yAxis;
return c;
}
xz(a) {
if (a.suggestedSecondaryAxis == 2) {
this.yAxis.qd = true;
this.yAxis.rg = 10;
}
}
x2() {
this.yAxis.qd = this.aj5;
this.yAxis.rg = this.ali;
}
get_id() {
return ((() => {
let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
$ret.add(new SimpleCategorySeriesRule());
$ret.add(new SubCollectionsRule());
return $ret;
})());
}
get id() {
return this.get_id();
}
vb(a, b) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c != null) {
c.abj = this.ai3;
c.xu = this.c4(a, b);
}
}
amp(a) {
this.amq((b, c) => a(b));
}
amq(a) {
if (this.dataChart == null) {
return;
}
for (let b = 0; b < this.dataChart.b9.count; b++) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, this.dataChart.b9._inner[b]);
if (c == null) {
continue;
}
a(c, b);
}
}
abj() {
return this.xAxis;
}
abk() {
return this.yAxis;
}
ajc() {
return this.dh(30);
}
ajd() {
return this.dh(31);
}
ia(a, b) {
let c = super.ia(a, b);
if (c != null) {
let d = new List$1(Series.$, 0);
if (this.ajk) {
d.add(this.ajc());
}
if (this.ajl) {
d.add(this.ajd());
}
for (let e = 0; e < d.count; e++) {
let f = d._inner[e];
f.name = a + getInstanceType(f).typeName;
c.add(f);
}
}
return c;
}
bb() {
if (this.ba == 0) {
return 1;
}
else {
return this.ba;
}
}
x6(a, b, c) {
super.x6(a, b, c);
if (this.bg.dataSeries.count > 0) {
if (stringIsNullOrEmpty(this.od)) {
this.cg.setXMemberPath(a, c.getMemberPathFor(16));
}
if (stringIsNullOrEmpty(this.of)) {
this.cg.setYMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.n0)) {
this.cg.setLabelMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.nw)) {
this.cg.setContentMemberPath(a, c.getMemberPathFor(0));
}
}
}
he() {
if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
return true;
}
else if (this.crosshairsDisplayMode == 0) {
if (this.ai1 == 2 || this.ai1 == 8) {
return false;
}
else if (this.ai1 == 9 && this.bg != null && this.bg.dataSeries != null && this.bg.dataSeries.count > 0) {
let a = this.bg.dataSeries._inner[0].suggestedSeries;
if (a == 1 || a == 8) {
return false;
}
}
return true;
}
return false;
}
get_hl() {
return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
}
w1(a, b, c) {
super.w1(a, b, c);
switch (a) {
case "ChartType":
this.vv();
break;
case "MarkerCollisionAvoidance":
this.amp((d) => d.abj = this.ai3);
break;
case "IsTransitionInEnabled":
this.amp((d) => d.z5 = this.ajy);
break;
case "IsSplineShapePartOfRange":
this.amp((d) => {
if (d.f3) {
d.sl(this.ajx);
}
});
break;
case "TransitionInMode":
this.amp((d) => d.zp = this.ai5);
break;
case "TransitionInSpeedType":
this.amp((d) => d.c6 = this.ajf);
break;
case "XAxisInterval":
this.xAxis.rm = this.akx;
break;
case "XAxisMinorInterval":
this.xAxis.rn = this.ak0;
break;
case "XAxisGap":
this.xAxis.pt = this.akw;
break;
case "XAxisOverlap":
this.xAxis.p2 = this.ak1;
break;
case "XAxisMinimumGapSize":
this.xAxis.p1 = this.akz;
break;
case "XAxisMaximumGap":
this.xAxis.p0 = this.aky;
break;
case "XAxisZoomMaximumCategoryRange":
this.xAxis.zoomMaximumCategoryRange = this.ak2;
break;
case "XAxisZoomMaximumItemSpan":
this.xAxis.zoomMaximumItemSpan = this.ak3;
break;
case "XAxisZoomToCategoryRange":
this.xAxis.zoomToCategoryRange = this.ak4;
break;
case "XAxisZoomToCategoryStart":
this.xAxis.zoomToCategoryStart = this.ak5;
break;
case "XAxisZoomToItemSpan":
this.xAxis.zoomToItemSpan = this.ak6;
break;
case "YAxisInterval":
this.yAxis.q1 = this.ak9;
break;
case "YAxisFavorLabellingScaleEnd":
this.yAxis.p8 = this.aj4;
break;
case "YAxisAutoRangeBufferMode":
this.yAxis.pm = this.aiz;
break;
case "YAxisIsLogarithmic":
this.yAxis.qd = this.aj5;
break;
case "YAxisLogarithmBase":
this.yAxis.rg = this.ali;
break;
case "YAxisMinimumValue":
this.yAxis.q5 = this.alb;
break;
case "YAxisMaximumValue":
this.yAxis.q4 = this.ala;
break;
case "YAxisMinorInterval":
this.yAxis.q6 = this.alc;
break;
case "NegativeBrushes":
case "NegativeOutlines":
this.amq((d, e) => {
if (d.fp) {
d.sk(ArrayExtension.getModulus$1(Brush.$, this.aiu, e), ArrayExtension.getModulus$1(Brush.$, this.aiv, e));
}
});
break;
case "YAxisAbbreviateLargeNumbers":
this.ahb((d) => d.p3 = this.aj2);
break;
case "IsCategoryHighlightingEnabled":
case "IsItemHighlightingEnabled":
this.vv();
break;
case "AutoMarginAndAngleUpdateMode":
this.wp((d) => d.zg = this.aix);
break;
case "ShouldAutoExpandMarginForInitialLabels":
this.wp((d) => d.aal = this.ajz);
break;
case CategoryChart.alw:
this.wp((d) => d.aao = this.aj0);
break;
case "AutoExpandMarginExtraPadding":
this.wp((d) => d.abc = this.ako);
break;
case "AutoExpandMarginMaximumValue":
this.wp((d) => d.abd = this.akp);
break;
case CategoryChart.al3:
this.ag7((d) => d.cy = this.aj1, a);
break;
case CategoryChart.amh:
this.ahb((d) => d.cy = this.aj3);
break;
}
}
}
CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
CategoryChart.alw = "ShouldConsiderAutoRotationForInitialLabels";
CategoryChart.al3 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
CategoryChart.amh = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
return CategoryChart;
})();