igniteui-webcomponents-charts
Version:
Ignite UI Web Components charting components for building rich data visualizations using TypeScript APIs.
1,045 lines (1,044 loc) • 32.9 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-webcomponents-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-webcomponents-core";
import { DataSeriesType_$type } from "igniteui-webcomponents-core";
import { NumericYAxis } from "./NumericYAxis";
import { IDataSeriesAdapterRule_$type } from "igniteui-webcomponents-core";
import { SimpleCategorySeriesRule } from "igniteui-webcomponents-core";
import { SubCollectionsRule } from "igniteui-webcomponents-core";
import { DVContainer } from "igniteui-webcomponents-core";
import { Brush } from "igniteui-webcomponents-core";
import { AxisDefaults } from "./AxisDefaults";
import { Defaults } from "./Defaults";
import { Series } from "./Series";
import { HorizontalAnchoredCategorySeries } from "./HorizontalAnchoredCategorySeries";
import { ArrayExtension } from "igniteui-webcomponents-core";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { DeviceUtils } from "igniteui-webcomponents-core";
import { CategoryChartMockDataGenerator } from "./CategoryChartMockDataGenerator";
import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
/**
* @hidden
*/
export let CategoryChart = /*@__PURE__*/ (() => {
class CategoryChart extends XYChart {
vm() {
super.vm();
if (this.dataChart == null) {
return;
}
let a = this.dataChart.c9.j.e();
this.ahn = a.d;
this.aho = a.e;
if (this.agx == null) {
this.agx = a.k;
}
if (this.ag4 == null) {
this.ag4 = a.k;
}
this.acw = 0;
this.ag5 = AxisDefaults.axis_MajorBrush;
this.ag8 = null;
this.ag1 = AxisDefaults.axis_LineBrush;
this.agy = null;
this.acf = AxisDefaults.categoryAxis_TickLength;
this.ag2 = AxisDefaults.axis_TickBrush;
this.acg = AxisDefaults.axis_TickStroke;
this.crosshairsAnnotationEnabled = true;
this.gq = true;
this.crosshairsDisplayMode = 0;
this.jq = Defaults.crosshairLineThickness;
this.yy = Defaults.crosshairLineBrush;
this.yt = Defaults.crosshairXAxisAnnotationBackground;
this.yu = Defaults.crosshairXAxisAnnotationTextColor;
this.air = true;
}
vo(a, b) {
super.vo(a, b);
a.kf = this.aj9;
a.kg = this.aka;
a.df = this.aib;
a.dg = this.aic;
}
wh(a, b, c) {
super.wh(a, b, c);
switch (a) {
case "TransitionInDuration":
this.vb((d) => d.kf = this.aj9);
break;
case "TransitionOutDuration":
this.vb((d) => d.kg = this.aka);
break;
case "TransitionInEasingFunction":
this.vb((d) => d.df = this.aib);
break;
case "TransitionOutEasingFunction":
this.vb((d) => d.dg = this.aic);
break;
}
}
get aj9() {
return this.aj6;
}
set aj9(a) {
let b = this.aj9;
if (a != b) {
this.aj6 = a;
this.wd("TransitionInDuration", b, this.aj9);
}
}
get aka() {
return this.aj7;
}
set aka(a) {
let b = this.aka;
if (a != b) {
this.aj7 = a;
this.wd("TransitionOutDuration", b, this.aka);
}
}
get aib() {
return this.ah9;
}
set aib(a) {
let b = this.aib;
if (a != b) {
this.ah9 = a;
this.wd("TransitionInEasingFunction", b, this.aib);
}
}
get aic() {
return this.aia;
}
set aic(a) {
let b = this.aic;
if (a != b) {
this.aia = a;
this.wd("TransitionOutEasingFunction", b, this.aic);
}
}
akg() {
let cvd_ = this.l5();
cvd_.scaleByViewport();
return (cvd_.serialize());
}
vh(a, b) {
super.vh(a, b);
a.ej = this.gj;
a.x1 = this.ais;
a.x4 = this.ait;
a.yr = this.ajh;
a.ys = this.aji;
a.w6 = this.ahq;
}
vn(a, b) {
super.vn(a, b);
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c == null) {
return;
}
c.aa1 = this.ahw;
c.zq = this.air;
c.za = this.ahy;
c.c6 = this.ah8;
c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
c.trendLineType = this.ec;
c.trendLineThickness = this.km;
c.xf = this.c2(a, b);
if (a.fn) {
a.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, b), ArrayExtension.getModulus$1(Brush.$, this.aho, b));
}
}
ahz() {
return new CategoryXAxis();
}
ah3() {
return new NumericYAxis();
}
ux() {
this.xAxis = this.ahz();
this.xAxis.name = "xAxis";
let a = this.xAxis;
a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.alk));
this.yAxis = this.ah3();
this.yAxis.name = "yAxis";
let b = this.yAxis;
b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.all));
if (this.xAxis.az == null) {
this.xAxis.az = new AxisLabelSettings();
}
if (this.yAxis.az == null) {
this.yAxis.az = new AxisLabelSettings();
}
}
afx(a) {
super.afx(a);
a.lf = this.aiv;
a.lj = this.aix;
a.b1 = this.aiw;
}
afv(a) {
super.afv(a);
a.b1 = this.aiu;
a.zoomMaximumCategoryRange = this.ajv;
a.zoomToCategoryRange = this.ajx;
a.zoomToCategoryStart = this.ajy;
a.zoomMaximumItemSpan = this.ajw;
a.zoomToItemSpan = this.ajz;
}
get_cb() {
return 0;
}
get cb() {
return this.get_cb();
}
get ahu() {
return this.aht;
}
set ahu(a) {
if (a != this.aht) {
let b = this.ahu;
this.aht = a;
this.wd("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ahu));
}
}
get ahw() {
return this.ahv;
}
set ahw(a) {
let b = this.ahw;
if (a != b) {
this.ahv = a;
this.wd("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ahw));
}
}
get aiq() {
return this.aif;
}
set aiq(a) {
let b = this.aiq;
if (a != b) {
this.aif = a;
this.wd("IsSplineShapePartOfRange", b, this.aiq);
}
}
get air() {
return this.aig;
}
set air(a) {
let b = this.air;
if (a != b) {
this.aig = a;
this.wd("IsTransitionInEnabled", b, this.air);
}
}
get ahy() {
return this.ahx;
}
set ahy(a) {
let b = this.ahy;
if (a != b) {
this.ahx = a;
this.wd("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ahy));
}
}
get ah8() {
return this.ah7;
}
set ah8(a) {
let b = this.ah8;
if (a != b) {
this.ah7 = a;
this.wd("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ah8));
}
}
get ajq() {
return this.ai3;
}
set ajq(a) {
let b = this.ajq;
if (a != b) {
this.ai3 = a;
this.wd("XAxisInterval", b, this.ajq);
}
}
get ajt() {
return this.ai6;
}
set ajt(a) {
let b = this.ajt;
if (a != b) {
this.ai6 = a;
this.wd("XAxisMinorInterval", b, this.ajt);
}
}
get ajp() {
return this.ai2;
}
set ajp(a) {
let b = this.ajp;
if (a != b) {
this.ai2 = a;
this.wd("XAxisGap", b, this.ajp);
}
}
get ajs() {
return this.ai5;
}
set ajs(a) {
let b = this.ajs;
if (a != b) {
this.ai5 = a;
this.wd("XAxisMinimumGapSize", b, this.ajs);
}
}
get ajr() {
return this.ai4;
}
set ajr(a) {
let b = this.ajr;
if (a != b) {
this.ai4 = a;
this.wd("XAxisMaximumGap", b, this.ajr);
}
}
get aju() {
return this.ai7;
}
set aju(a) {
let b = this.aju;
if (a != b) {
this.ai7 = a;
this.wd("XAxisOverlap", b, this.aju);
}
}
get aj2() {
return this.ajd;
}
set aj2(a) {
let b = this.aj2;
if (a != b) {
this.ajd = a;
this.wd("YAxisInterval", b, this.aj2);
}
}
get ahq() {
return this.ahp;
}
set ahq(a) {
let b = this.ahq;
if (a != b) {
this.ahp = a;
this.wd("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ahq));
}
}
alm() {
if (this.dataChart != null) {
this.dataChart.aac();
}
}
get ais() {
return this.aih;
}
set ais(a) {
let b = this.ais;
if (a != b) {
this.aih = a;
this.wd("ShouldAutoExpandMarginForInitialLabels", b, this.ais);
}
}
get ait() {
return this.aii;
}
set ait(a) {
let b = this.ait;
if (a != b) {
this.aii = a;
this.wd(CategoryChart.akp, b, this.ait);
}
}
get ajh() {
return this.ai0;
}
set ajh(a) {
let b = this.ajh;
if (a != b) {
this.ai0 = a;
this.wd("AutoExpandMarginExtraPadding", b, this.ajh);
}
}
get aji() {
return this.ai1;
}
set aji(a) {
let b = this.aji;
if (a != b) {
this.ai1 = a;
this.wd("AutoExpandMarginMaximumValue", b, this.aji);
}
}
get aix() {
return this.aim;
}
set aix(a) {
let b = this.aix;
if (a != b) {
this.aim = a;
this.wd("YAxisFavorLabellingScaleEnd", b, this.aix);
}
}
get aiu() {
return this.aij;
}
set aiu(a) {
let b = this.aiu;
if (a != b) {
this.aij = a;
this.wd(CategoryChart.akw, b, this.aiu);
}
}
get aiw() {
return this.ail;
}
set aiw(a) {
let b = this.aiw;
if (a != b) {
this.ail = a;
this.wd(CategoryChart.ala, b, this.aiw);
}
}
get ahs() {
return this.ahr;
}
set ahs(a) {
let b = this.ahs;
if (a != b) {
this.ahr = a;
this.wd("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ahs));
}
}
get aiy() {
return this.ain;
}
set aiy(a) {
let b = this.aiy;
if (a != b) {
this.ain = a;
this.wd("YAxisIsLogarithmic", b, this.aiy);
}
}
get akb() {
return this.aj8;
}
set akb(a) {
let b = this.akb;
if (a != b) {
this.aj8 = a;
this.wd("YAxisLogarithmBase", b, this.akb);
}
}
get aj4() {
return this.ajf;
}
set aj4(a) {
let b = this.aj4;
if (a != b) {
this.ajf = a;
this.wd("YAxisMinimumValue", b, this.aj4);
}
}
get aj3() {
return this.aje;
}
set aj3(a) {
let b = this.aj3;
if (a != b) {
this.aje = a;
this.wd("YAxisMaximumValue", b, this.aj3);
}
}
get aj5() {
return this.ajg;
}
set aj5(a) {
let b = this.aj5;
if (a != b) {
this.ajg = a;
this.wd("YAxisMinorInterval", b, this.aj5);
}
}
get ajo() {
return this.xAxis.m1;
}
get ajn() {
return this.xAxis.m0;
}
ajk() {
return this.ajo;
}
ajm() {
return this.aj1;
}
ajj() {
return this.ajn;
}
ajl() {
return this.aj0;
}
get aj1() {
return this.yAxis.l4;
}
get aj0() {
return this.yAxis.l3;
}
get ahn() {
return this.ahl;
}
set ahn(a) {
let b = this.ahn;
if (a != b) {
this.ahl = a;
this.wd("NegativeBrushes", b, this.ahn);
}
}
get aho() {
return this.ahm;
}
set aho(a) {
let b = this.aho;
if (a != b) {
this.ahm = a;
this.wd("NegativeOutlines", b, this.aho);
}
}
get aiv() {
return this.aik;
}
set aiv(a) {
let b = this.aiv;
if (a != b) {
this.aik = a;
this.wd("YAxisAbbreviateLargeNumbers", b, this.aiv);
}
}
get ajv() {
return this.ai8;
}
set ajv(a) {
let b = this.ajv;
if (a != b) {
this.ai8 = a;
this.wd("XAxisZoomMaximumCategoryRange", b, this.ajv);
}
}
get ajw() {
return this.ai9;
}
set ajw(a) {
let b = this.ajw;
if (a != b) {
this.ai9 = a;
this.wd("XAxisZoomMaximumItemSpan", b, this.ajw);
}
}
get ajx() {
return this.aja;
}
set ajx(a) {
let b = this.ajx;
if (a != b) {
this.aja = a;
this.wd("XAxisZoomToCategoryRange", b, this.ajx);
}
}
get ajy() {
return this.ajb;
}
set ajy(a) {
let b = this.ajy;
if (a != b) {
this.ajb = a;
this.wd("XAxisZoomToCategoryStart", b, this.ajy);
}
}
get ajz() {
return this.ajc;
}
set ajz(a) {
let b = this.ajz;
if (a != b) {
this.ajc = a;
this.wd("XAxisZoomToItemSpan", b, this.ajz);
}
}
get aio() {
return this.aid;
}
set aio(a) {
let b = this.aio;
if (a != b) {
this.aid = a;
this.wd("IsCategoryHighlightingEnabled", b, this.aio);
}
}
get aip() {
return this.aie;
}
set aip(a) {
let b = this.aip;
if (a != b) {
this.aie = a;
this.wd("IsItemHighlightingEnabled", b, this.aip);
}
}
constructor() {
super();
this.aj6 = 1000;
this.aj7 = 1000;
this.ah9 = null;
this.aia = null;
this.aht = 9;
this.ahv = 1;
this.aif = false;
this.aig = true;
this.ahx = 0;
this.ah7 = 0;
this.ai3 = 0;
this.ai6 = 0;
this.ai2 = 0;
this.ai5 = 0;
this.ai4 = 1;
this.ai7 = 0;
this.ajd = NaN;
this.ahp = 1;
this.aih = true;
this.aii = true;
this.ai0 = DeviceUtils.g(2);
this.ai1 = DeviceUtils.g(60);
this.aim = true;
this.aij = true;
this.ail = false;
this.ahr = 0;
this.ain = false;
this.aj8 = 10;
this.ajf = NaN;
this.aje = NaN;
this.ajg = 0;
this.ahl = null;
this.ahm = null;
this.aik = true;
this.ai8 = 3;
this.ai9 = NaN;
this.aja = NaN;
this.ajb = NaN;
this.ajc = NaN;
this.aid = false;
this.aie = false;
this.aiz = null;
DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
this.u2();
}
get_h2() {
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 h2() {
return this.get_h2();
}
h8() {
if (this.aiz == null) {
this.aiz = CategoryChartMockDataGenerator.a();
}
return this.aiz;
}
c1(a) {
if (a != null) {
let b = super.c1(a);
if (b == 2) {
if (a.fm && this.g1) {
return 13;
}
}
}
return super.c1(a);
}
c3(a) {
if (a != null) {
let b = super.c1(a);
if (b == 2) {
if (a.fm && this.g1) {
return 13;
}
}
}
return super.c3(a);
}
get_hk() {
return true;
}
alk(a, b) {
switch (b.propertyName) {
case "ActualMinimum":
this.wv("XAxisActualMinimum");
break;
case "ActualMaximum":
this.wv("XAxisActualMaximum");
break;
}
}
all(a, b) {
switch (b.propertyName) {
case "ActualMinimumValue":
this.wv("YAxisActualMinimum");
break;
case "ActualMaximumValue":
this.wv("YAxisActualMaximum");
break;
}
}
xa() {
super.xa();
this.xAxis.f2 = this.ac6 == null ? XYChart.adi(this.xAxis, this.bf.dataSeries) : this.ac6;
this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
if (this.ais) {
this.v1((a) => a.aac());
}
}
get xAxis() {
return this._xAxis;
}
set xAxis(a) {
this._xAxis = a;
}
get yAxis() {
return this._yAxis;
}
set yAxis(a) {
this._yAxis = a;
}
ah2(a, b) {
switch (a) {
case 2: return this.df(1);
case 3: return this.df(10);
case 0: return this.df(0);
case 1: return this.df(2);
case 6: return this.df(6);
case 7: return this.df(7);
case 4: return this.df(4);
case 5: return this.df(5);
case 8: return this.df(8);
case 9: return this.ah1(b);
default: return this.df(1);
}
}
ah1(a) {
return this.df(a);
}
be(a) {
switch (this.ahu) {
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;
}
}
dc(a, b) {
let c = this.ah2(this.ahu, a.suggestedSeries);
c.abr = a.findMatchingHint(0).path;
c.xAxis = this.xAxis;
c.yAxis = this.yAxis;
return c;
}
w8(a) {
if (a.suggestedSecondaryAxis == 2) {
this.yAxis.lo = true;
this.yAxis.mm = 10;
}
}
xb() {
this.yAxis.lo = this.aiy;
this.yAxis.mm = this.akb;
}
get_h1() {
return ((() => {
let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
$ret.add(new SimpleCategorySeriesRule());
$ret.add(new SubCollectionsRule());
return $ret;
})());
}
get h1() {
return this.get_h1();
}
ur(a, b) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c != null) {
c.aa1 = this.ahw;
c.xf = this.c2(a, b);
}
}
ali(a) {
this.alj((b, c) => a(b));
}
alj(a) {
if (this.dataChart == null) {
return;
}
for (let b = 0; b < this.dataChart.series.count; b++) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, this.dataChart.series._inner[b]);
if (c == null) {
continue;
}
a(c, b);
}
}
aao() {
return this.xAxis;
}
aap() {
return this.yAxis;
}
ah5() {
return this.df(30);
}
ah6() {
return this.df(31);
}
hy(a, b) {
let c = super.hy(a, b);
if (c != null) {
let d = new List$1(Series.$, 0);
if (this.aid) {
d.add(this.ah5());
}
if (this.aie) {
d.add(this.ah6());
}
for (let e = 0; e < d.count; e++) {
let f = d._inner[e];
f.name = a + getInstanceType(f).typeName;
c.add(f);
}
}
return c;
}
ba() {
if (this.a9 == 0) {
return 1;
}
else {
return this.a9;
}
}
xf(a, b, c) {
super.xf(a, b, c);
if (this.bf.dataSeries.count > 0) {
if (stringIsNullOrEmpty(this.nz)) {
this.ce.setXMemberPath(a, c.getMemberPathFor(16));
}
if (stringIsNullOrEmpty(this.n1)) {
this.ce.setYMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.nm)) {
this.ce.setLabelMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.ni)) {
this.ce.setContentMemberPath(a, c.getMemberPathFor(0));
}
}
}
g4() {
if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
return true;
}
else if (this.crosshairsDisplayMode == 0) {
if (this.ahu == 2 || this.ahu == 8) {
return false;
}
else if (this.ahu == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
let a = this.bf.dataSeries._inner[0].suggestedSeries;
if (a == 1 || a == 8) {
return false;
}
}
return true;
}
return false;
}
get_hb() {
return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
}
wd(a, b, c) {
super.wd(a, b, c);
switch (a) {
case "ChartType":
this.u8();
break;
case "MarkerCollisionAvoidance":
this.ali((d) => d.aa1 = this.ahw);
break;
case "IsTransitionInEnabled":
this.ali((d) => d.zq = this.air);
break;
case "IsSplineShapePartOfRange":
this.ali((d) => {
if (d.f1) {
d.r8(this.aiq);
}
});
break;
case "TransitionInMode":
this.ali((d) => d.za = this.ahy);
break;
case "TransitionInSpeedType":
this.ali((d) => d.c6 = this.ah8);
break;
case "XAxisInterval":
this.xAxis.mw = this.ajq;
break;
case "XAxisMinorInterval":
this.xAxis.mx = this.ajt;
break;
case "XAxisGap":
this.xAxis.k5 = this.ajp;
break;
case "XAxisOverlap":
this.xAxis.le = this.aju;
break;
case "XAxisMinimumGapSize":
this.xAxis.ld = this.ajs;
break;
case "XAxisMaximumGap":
this.xAxis.lc = this.ajr;
break;
case "XAxisZoomMaximumCategoryRange":
this.xAxis.zoomMaximumCategoryRange = this.ajv;
break;
case "XAxisZoomMaximumItemSpan":
this.xAxis.zoomMaximumItemSpan = this.ajw;
break;
case "XAxisZoomToCategoryRange":
this.xAxis.zoomToCategoryRange = this.ajx;
break;
case "XAxisZoomToCategoryStart":
this.xAxis.zoomToCategoryStart = this.ajy;
break;
case "XAxisZoomToItemSpan":
this.xAxis.zoomToItemSpan = this.ajz;
break;
case "YAxisInterval":
this.yAxis.l8 = this.aj2;
break;
case "YAxisFavorLabellingScaleEnd":
this.yAxis.lj = this.aix;
break;
case "YAxisAutoRangeBufferMode":
this.yAxis.ky = this.ahs;
break;
case "YAxisIsLogarithmic":
this.yAxis.lo = this.aiy;
break;
case "YAxisLogarithmBase":
this.yAxis.mm = this.akb;
break;
case "YAxisMinimumValue":
this.yAxis.mc = this.aj4;
break;
case "YAxisMaximumValue":
this.yAxis.mb = this.aj3;
break;
case "YAxisMinorInterval":
this.yAxis.md = this.aj5;
break;
case "NegativeBrushes":
case "NegativeOutlines":
this.alj((d, e) => {
if (d.fn) {
d.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, e), ArrayExtension.getModulus$1(Brush.$, this.aho, e));
}
});
break;
case "YAxisAbbreviateLargeNumbers":
this.af4((d) => d.lf = this.aiv);
break;
case "IsCategoryHighlightingEnabled":
case "IsItemHighlightingEnabled":
this.u8();
break;
case "AutoMarginAndAngleUpdateMode":
this.v1((d) => d.w6 = this.ahq);
break;
case "ShouldAutoExpandMarginForInitialLabels":
this.v1((d) => d.x1 = this.ais);
break;
case CategoryChart.akp:
this.v1((d) => d.x4 = this.ait);
break;
case "AutoExpandMarginExtraPadding":
this.v1((d) => d.yr = this.ajh);
break;
case "AutoExpandMarginMaximumValue":
this.v1((d) => d.ys = this.aji);
break;
case CategoryChart.akw:
this.af0((d) => d.b1 = this.aiu, a);
break;
case CategoryChart.ala:
this.af4((d) => d.b1 = this.aiw);
break;
}
}
}
CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
CategoryChart.akp = "ShouldConsiderAutoRotationForInitialLabels";
CategoryChart.akw = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
CategoryChart.ala = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
return CategoryChart;
})();