igniteui-webcomponents-charts 5.1.1 → 5.2.0

package/esm2015/lib/DataChartToolbarProvider.js

@@ -14,14 +14,16 @@ import { ToolActionLabelInfo } from "igniteui-webcomponents-core";
 import { ToolActionCheckboxInfo } from "igniteui-webcomponents-core";
 import { DeviceUtils } from "igniteui-webcomponents-core";
 import { ToolActionRadioInfo } from "igniteui-webcomponents-core";
+import { XamDataChart } from "./XamDataChart";
+import { Axis } from "./Axis";
+import { BrushUtilCore } from "igniteui-webcomponents-core";
 import { ToolCommandArgument } from "igniteui-webcomponents-core";
 import { AutomaticSeriesRequest } from "./AutomaticSeriesRequest";
-import { Axis } from "./Axis";
-import { XamDataChart } from "./XamDataChart";
+import { AxisStrokeSettings } from "./AxisStrokeSettings";
 import { FastIterationDictionary$2 } from "igniteui-webcomponents-core";
-import { Brush } from "igniteui-webcomponents-core";
-import { BrushUtil } from "igniteui-webcomponents-core";
 import { CaptureImageSettings } from "igniteui-webcomponents-core";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { isNaN_ } from "igniteui-webcomponents-core";
 /**
  * @hidden
  */
@@ -30,11 +32,11 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
         constructor() {
             super(...arguments);
             this._container = null;
-            this.j = null;
-            this.h = null;
-            this.f = null;
-            this.p = null;
-            this.q = new FastIterationDictionary$2(Axis.$, Brush.$, 0);
+            this.k = null;
+            this.i = null;
+            this.g = null;
+            this.q = null;
+            this.r = new FastIterationDictionary$2(Axis.$, AxisStrokeSettings.$, 0);
         }
         get container() {
             return this._container;
@@ -42,7 +44,7 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
         set container(a) {
             this._container = a;
         }
-        get k() {
+        get l() {
             if (TypeRegistrar.isRegistered("HorizontalAnchoredCategorySeriesProxy")) {
                 return TypeRegistrar.create("HorizontalAnchoredCategorySeriesProxy");
             }
@@ -50,10 +52,10 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 throw new BaseError(1, "category series module is not loaded, but is required.");
             }
         }
-        get t() {
+        get v() {
             return (TypeRegistrar.isRegistered("HorizontalAnchoredCategorySeriesProxy"));
         }
-        get i() {
+        get j() {
             if (TypeRegistrar.isRegistered("FinancialPriceSeriesProxy")) {
                 return TypeRegistrar.create("FinancialPriceSeriesProxy");
             }
@@ -61,22 +63,22 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 throw new BaseError(1, "category series module is not loaded, but is required.");
             }
         }
-        get s() {
+        get u() {
             return (TypeRegistrar.isRegistered("HorizontalAnchoredCategorySeriesProxy"));
         }
-        get g() {
-            if (this.f == null) {
+        get h() {
+            if (this.g == null) {
                 if (TypeRegistrar.isRegistered("AnnotationLayerProxy")) {
-                    this.f = TypeRegistrar.create("AnnotationLayerProxy");
-                    this.f.container = this.container;
+                    this.g = TypeRegistrar.create("AnnotationLayerProxy");
+                    this.g.container = this.container;
                 }
                 else {
                     throw new BaseError(1, "annotation layer module is not loaded, but is required.");
                 }
             }
-            return this.f;
+            return this.g;
         }
-        get r() {
+        get t() {
             return (TypeRegistrar.isRegistered("AnnotationLayerProxy"));
         }
         getDesiredToolbarActions(a) {
@@ -198,28 +200,28 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                     return $ret;
                 })()), v];
             for (let x = 0; x < w.length; x++) {
-                this.a7(a, w[x]);
+                this.a9(a, w[x]);
             }
             return w;
         }
-        a7(a, b) {
+        a9(a, b) {
             if (b.actions != null && b.actions.length > 0) {
                 for (let c = 0; c < b.actions.length; c++) {
-                    this.a7(a, b.actions[c]);
+                    this.a9(a, b.actions[c]);
                 }
             }
             switch (b.name) {
                 case "ShowValueLabels":
                     {
                         let d = b;
-                        let e = this.l(a);
+                        let e = this.m(a);
                         d.isChecked = e != null && e._visibility == 0;
                     }
                     break;
                 case "ShowLastValueLabel":
                     {
                         let f = b;
-                        let g = this.n(a);
+                        let g = this.o(a);
                         f.isChecked = g != null && g._visibility == 0;
                     }
                     break;
@@ -228,13 +230,13 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                         let h = b;
                         for (let i of fromEnum(a.series)) {
                             if (i.ey) {
-                                if (this.t && this.k.matchesType(i)) {
-                                    h.isChecked = this.k.getTrendLineType(i) == 1;
+                                if (this.v && this.l.matchesType(i)) {
+                                    h.isChecked = this.l.getTrendLineType(i) == 1;
                                 }
                             }
                             else if (i.e9) {
-                                if (this.s && this.i.matchesType(i)) {
-                                    h.isChecked = this.i.getTrendLineType(i) == 1;
+                                if (this.u && this.j.matchesType(i)) {
+                                    h.isChecked = this.j.getTrendLineType(i) == 1;
                                 }
                             }
                         }
@@ -245,13 +247,13 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                         let j = b;
                         for (let k of fromEnum(a.series)) {
                             if (k.ey) {
-                                if (this.t && this.k.matchesType(k)) {
-                                    j.isChecked = this.k.getTrendLineType(k) == 7;
+                                if (this.v && this.l.matchesType(k)) {
+                                    j.isChecked = this.l.getTrendLineType(k) == 7;
                                 }
                             }
                             else if (k.e9) {
-                                if (this.s && this.i.matchesType(k)) {
-                                    j.isChecked = this.i.getTrendLineType(k) == 7;
+                                if (this.u && this.j.matchesType(k)) {
+                                    j.isChecked = this.j.getTrendLineType(k) == 7;
                                 }
                             }
                         }
@@ -262,13 +264,13 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                         let l = b;
                         for (let m of fromEnum(a.series)) {
                             if (m.ey) {
-                                if (this.t && this.k.matchesType(m)) {
-                                    l.isChecked = this.k.getTrendLineType(m) == 6;
+                                if (this.v && this.l.matchesType(m)) {
+                                    l.isChecked = this.l.getTrendLineType(m) == 6;
                                 }
                             }
                             else if (m.e9) {
-                                if (this.s && this.i.matchesType(m)) {
-                                    l.isChecked = this.i.getTrendLineType(m) == 6;
+                                if (this.u && this.j.matchesType(m)) {
+                                    l.isChecked = this.j.getTrendLineType(m) == 6;
                                 }
                             }
                         }
@@ -281,12 +283,12 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                         let p = a.series.count;
                         for (let q of fromEnum(a.series)) {
                             if (q.ey) {
-                                if (this.t && this.k.matchesType(q) && this.k.getTrendLineType(q) == 0) {
+                                if (this.v && this.l.matchesType(q) && this.l.getTrendLineType(q) == 0) {
                                     o = o + 1;
                                 }
                             }
                             else if (q.e9) {
-                                if (this.s && this.i.matchesType(q) && this.i.getTrendLineType(q) == 0) {
+                                if (this.u && this.j.matchesType(q) && this.j.getTrendLineType(q) == 0) {
                                     o = o + 1;
                                 }
                             }
@@ -300,36 +302,42 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 case "MinValue":
                     {
                         let r = b;
-                        let s = this.o(a, 4);
+                        let s = this.p(a, 4);
                         r.isChecked = s != null && s._visibility == 0;
                     }
                     break;
                 case "MaxValue":
                     {
                         let t = b;
-                        let u = this.o(a, 5);
+                        let u = this.p(a, 5);
                         t.isChecked = u != null && u._visibility == 0;
                     }
                     break;
                 case "Average":
                     {
                         let v = b;
-                        let w = this.o(a, 6);
+                        let w = this.p(a, 6);
                         v.isChecked = w != null && w._visibility == 0;
                     }
                     break;
                 case "ShowCrosshairs":
                     {
                         let x = b;
-                        let y = this.m(a);
+                        let y = this.n(a);
                         x.isChecked = y != null && y._visibility == 0;
                     }
                     break;
-                case "SeriesAvg":
+                case "ShowGridlines":
                     {
                         let z = b;
-                        let aa = this.o(a, 3);
-                        z.isChecked = aa != null && aa._visibility == 0;
+                        z.isChecked = this.s(a);
+                    }
+                    break;
+                case "SeriesAvg":
+                    {
+                        let aa = b;
+                        let ab = this.p(a, 3);
+                        aa.isChecked = ab != null && ab._visibility == 0;
                     }
                     break;
             }
@@ -465,92 +473,104 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
             e.iconCollectionName = "ChartToolbarIcons";
             return [b, c, d, e];
         }
-        l(a) {
+        m(a) {
             for (let b of fromEnum(a.series)) {
-                if (this.g.isCalloutLayer(b) && this.g.getIsAutoCalloutBehaviorEnabled(b)) {
+                if (this.h.isCalloutLayer(b) && this.h.getIsAutoCalloutBehaviorEnabled(b)) {
                     return b;
                 }
             }
             return null;
         }
-        n(a) {
+        o(a) {
             for (let b of fromEnum(a.series)) {
-                if (this.g.isFinalValueLayer(b)) {
+                if (this.h.isFinalValueLayer(b)) {
                     return b;
                 }
             }
             return null;
         }
-        o(a, b) {
+        p(a, b) {
             for (let c of fromEnum(a.series)) {
-                if (this.g.isValueLayer(c) && this.g.getValueMode(c) == b) {
+                if (this.h.isValueLayer(c) && this.h.getValueMode(c) == b) {
                     return c;
                 }
             }
             return null;
         }
-        m(a) {
+        n(a) {
             for (let b of fromEnum(a.series)) {
-                if (this.g.isCrosshairLayer(b)) {
+                if (this.h.isCrosshairLayer(b)) {
                     return b;
                 }
             }
             return null;
         }
+        s(a) {
+            let b = typeCast(XamDataChart.$, a);
+            if (b != null) {
+                for (let c = 0; c < b.axes.count; c++) {
+                    let d = b.axes._inner[c];
+                    if (d.jw != null && !BrushUtilCore.a(d.jw) && d.et != 0) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
         onToolCommandExecuting(a, b) {
             switch (b.commandId) {
                 case "ZoomReset":
-                    this.bo(a, b);
+                    this.bq(a, b);
                     break;
                 case "ZoomIn":
-                    this.bm(a, b);
+                    this.bo(a, b);
                     break;
                 case "ZoomOut":
-                    this.bn(a, b);
+                    this.bp(a, b);
                     break;
                 case "ShowCrosshairs":
-                    this.ba(a, b);
+                    this.bc(a, b);
                     break;
                 case "ShowGridlines":
-                    this.bc(a, b);
+                    this.be(a, b);
                     break;
                 case "MaxValue":
-                    this.bg(a, b);
+                    this.bi(a, b);
                     break;
                 case "MinValue":
-                    this.bh(a, b);
+                    this.bj(a, b);
                     break;
                 case "Average":
-                    this.a8(a, b);
+                    this.ba(a, b);
                     break;
                 case "Exponential":
-                    this.bb(a, b);
+                    this.bd(a, b);
                     break;
                 case "Linear":
-                    this.be(a, b);
+                    this.bg(a, b);
                     break;
                 case "Logarithmic":
-                    this.bf(a, b);
+                    this.bh(a, b);
                     break;
                 case "NoTrends":
-                    this.bi(a, b);
+                    this.bk(a, b);
                     break;
                 case "SeriesAvg":
-                    this.bj(a, b);
+                    this.bl(a, b);
                     break;
                 case "ShowValueLabels":
-                    this.bl(a, b);
+                    this.bn(a, b);
                     break;
                 case "ShowLastValueLabel":
-                    this.bk(a, b);
+                    this.bm(a, b);
                     break;
                 case "CopyAsImage":
-                    this.a9(a, b);
+                    this.bb(a, b);
                     return 2;
             }
             return 0;
         }
-        u(a, b) {
+        w(a, b) {
             if (a.commandId == b) {
                 let e = a.argumentsList;
                 for (let d = 0; d < e.length; d++) {
@@ -562,14 +582,14 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        ba(a, b) {
-            let c = this.m(a);
-            if (this.v(a, c)) {
+        bc(a, b) {
+            let c = this.n(a);
+            if (this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "ShowCrosshairs", 0, () => {
-                let d = this.g.createCrosshairLayer();
-                this.g.setCrosshairOnAxesEnabled(d, true);
+            this.br(a, b, "ShowCrosshairs", 0, () => {
+                let d = this.h.createCrosshairLayer();
+                this.h.setCrosshairOnAxesEnabled(d, true);
                 let e = new AutomaticSeriesRequest();
                 e.a = 0;
                 e.e = true;
@@ -577,118 +597,131 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return e;
             });
         }
-        bc(a, b) {
-            let c = this.u(b, "ShowGridlines");
+        f(a, b) {
+            let c = new AxisStrokeSettings();
+            c.b = a.jz == null || BrushUtilCore.a(a.jz) ? b : a.jz;
+            c.a = isNaN_(a.et) || a.et == 0 ? DeviceUtils.g(1) : a.et;
+            this.r.item(a, c);
+            return c;
+        }
+        be(a, b) {
+            let c = this.w(b, "ShowGridlines");
             if (!c) {
-                for (let d = 0; d < this.q.o.count; d++) {
-                    let e = this.q.o._inner[d];
-                    if (e.jw != null) {
-                        e.jz = BrushUtil.h(0, 0, 0, 0);
+                let d = typeCast(XamDataChart.$, a);
+                if (d != null) {
+                    for (let e = 0; e < d.axes.count; e++) {
+                        let f = d.axes._inner[e];
+                        if (!this.r.d(f)) {
+                            this.f(f, d.aaq);
+                        }
+                        f.et = 0;
                     }
                 }
             }
             else {
-                let f = typeCast(XamDataChart.$, a);
-                if (f != null) {
-                    for (let g = 0; g < f.axes.count; g++) {
-                        let h = f.axes._inner[g];
-                        if (this.q.d(h)) {
-                            h.jz = this.q.item(h);
-                        }
-                        else {
-                            if (h.cb) {
-                                if (h.jz == null) {
-                                    h.jz = f.aaq;
-                                    this.q.s(h, f.aaq);
-                                }
-                                else {
-                                    this.q.s(h, h.jz);
-                                }
+                let g = typeCast(XamDataChart.$, a);
+                if (g != null) {
+                    for (let h = 0; h < g.axes.count; h++) {
+                        let i = g.axes._inner[h];
+                        let j = true;
+                        if (this.r.d(i)) {
+                            if (this.r.item(i).b != i.jz || i.et != 0) {
+                                j = true;
+                            }
+                            else {
+                                i.jz = this.r.item(i).b;
+                                i.et = this.r.item(i).a;
+                                j = false;
                             }
                         }
+                        if (j) {
+                            let k = this.f(i, g.aaq);
+                            i.jz = k.b;
+                            i.et = k.a;
+                        }
                     }
                 }
             }
         }
-        bb(a, b) {
-            if (!this.t) {
+        bd(a, b) {
+            if (!this.v) {
                 return;
             }
-            let c = this.u(b, "Exponential");
+            let c = this.w(b, "Exponential");
             if (c) {
                 for (let d of fromEnum(a.series)) {
                     if (d.ey) {
-                        if (this.t && this.k.matchesType(d)) {
-                            this.k.setTrendLineType(d, 7);
+                        if (this.v && this.l.matchesType(d)) {
+                            this.l.setTrendLineType(d, 7);
                         }
                     }
                     else if (d.e9) {
-                        if (this.s && this.i.matchesType(d)) {
-                            this.i.setTrendLineType(d, 7);
+                        if (this.u && this.j.matchesType(d)) {
+                            this.j.setTrendLineType(d, 7);
                         }
                     }
                 }
             }
         }
-        be(a, b) {
-            if (!this.t) {
+        bg(a, b) {
+            if (!this.v) {
                 return;
             }
-            let c = this.u(b, "Linear");
+            let c = this.w(b, "Linear");
             if (c) {
                 for (let d of fromEnum(a.series)) {
                     if (d.ey) {
-                        if (this.t && this.k.matchesType(d)) {
-                            this.k.setTrendLineType(d, 1);
+                        if (this.v && this.l.matchesType(d)) {
+                            this.l.setTrendLineType(d, 1);
                         }
                     }
                     else if (d.e9) {
-                        if (this.s && this.i.matchesType(d)) {
-                            this.i.setTrendLineType(d, 1);
+                        if (this.u && this.j.matchesType(d)) {
+                            this.j.setTrendLineType(d, 1);
                         }
                     }
                 }
             }
         }
-        bf(a, b) {
-            let c = this.u(b, "Logarithmic");
+        bh(a, b) {
+            let c = this.w(b, "Logarithmic");
             if (c) {
                 for (let d of fromEnum(a.series)) {
                     if (d.ey) {
-                        if (this.t && this.k.matchesType(d)) {
-                            this.k.setTrendLineType(d, 6);
+                        if (this.v && this.l.matchesType(d)) {
+                            this.l.setTrendLineType(d, 6);
                         }
                     }
                     else if (d.e9) {
-                        if (this.s && this.i.matchesType(d)) {
-                            this.i.setTrendLineType(d, 6);
+                        if (this.u && this.j.matchesType(d)) {
+                            this.j.setTrendLineType(d, 6);
                         }
                     }
                 }
             }
         }
-        bi(a, b) {
-            let c = this.u(b, "NoTrends");
+        bk(a, b) {
+            let c = this.w(b, "NoTrends");
             if (c) {
                 for (let d of fromEnum(a.series)) {
                     if (d.ey) {
-                        if (this.t && this.k.matchesType(d)) {
-                            this.k.setTrendLineType(d, 0);
+                        if (this.v && this.l.matchesType(d)) {
+                            this.l.setTrendLineType(d, 0);
                         }
                     }
                     else if (d.e9) {
-                        if (this.s && this.i.matchesType(d)) {
-                            this.i.setTrendLineType(d, 0);
+                        if (this.u && this.j.matchesType(d)) {
+                            this.j.setTrendLineType(d, 0);
                         }
                     }
                 }
             }
         }
-        bp(a, b, c, d, e) {
-            let f = this.u(b, c);
+        br(a, b, c, d, e) {
+            let f = this.w(b, c);
             let g = a.ao(a);
             if (f && !g.e(d)) {
-                if (this.r && e != null) {
+                if (this.t && e != null) {
                     g.b.add(e());
                 }
             }
@@ -696,19 +729,19 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 g.l(d);
             }
         }
-        bg(a, b) {
-            let c = this.o(a, 5);
-            if (c != null && this.g.getValueMode(c) == 5 && this.v(a, c)) {
+        bi(a, b) {
+            let c = this.p(a, 5);
+            if (c != null && this.h.getValueMode(c) == 5 && this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "MaxValue", 1, () => {
-                let d = this.g.createValueLayer();
-                this.g.setValueMode(d, 5);
-                this.g.setValueAxisAnnotationEnabled(d, true);
-                this.g.setBrush(d, BrushUtil.h(255, 99, 208, 0));
-                this.g.setUseLegend(d, true);
-                this.g.setTitle(d, "Maximum");
-                this.g.setLegendItemBadgeShape(d, 2);
+            this.br(a, b, "MaxValue", 1, () => {
+                let d = this.h.createValueLayer();
+                this.h.setValueMode(d, 5);
+                this.h.setValueAxisAnnotationEnabled(d, true);
+                this.h.setBrush(d, BrushUtil.h(255, 99, 208, 0));
+                this.h.setUseLegend(d, true);
+                this.h.setTitle(d, "Maximum");
+                this.h.setLegendItemBadgeShape(d, 2);
                 let e = new AutomaticSeriesRequest();
                 e.a = 1;
                 e.e = true;
@@ -716,19 +749,19 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return e;
             });
         }
-        bh(a, b) {
-            let c = this.o(a, 4);
-            if (c != null && this.v(a, c)) {
+        bj(a, b) {
+            let c = this.p(a, 4);
+            if (c != null && this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "MinValue", 2, () => {
-                let d = this.g.createValueLayer();
-                this.g.setValueMode(d, 4);
-                this.g.setValueAxisAnnotationEnabled(d, true);
-                this.g.setBrush(d, BrushUtil.h(255, 246, 93, 80));
-                this.g.setUseLegend(d, true);
-                this.g.setTitle(d, "Minimum");
-                this.g.setLegendItemBadgeShape(d, 2);
+            this.br(a, b, "MinValue", 2, () => {
+                let d = this.h.createValueLayer();
+                this.h.setValueMode(d, 4);
+                this.h.setValueAxisAnnotationEnabled(d, true);
+                this.h.setBrush(d, BrushUtil.h(255, 246, 93, 80));
+                this.h.setUseLegend(d, true);
+                this.h.setTitle(d, "Minimum");
+                this.h.setLegendItemBadgeShape(d, 2);
                 let e = new AutomaticSeriesRequest();
                 e.a = 2;
                 e.e = true;
@@ -736,19 +769,19 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return e;
             });
         }
-        a8(a, b) {
-            let c = this.o(a, 6);
-            if (c != null && this.v(a, c)) {
+        ba(a, b) {
+            let c = this.p(a, 6);
+            if (c != null && this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "Average", 3, () => {
-                let d = this.g.createValueLayer();
-                this.g.setValueMode(d, 6);
-                this.g.setValueAxisAnnotationEnabled(d, true);
-                this.g.setBrush(d, BrushUtil.h(255, 248, 173, 118));
-                this.g.setUseLegend(d, true);
-                this.g.setTitle(d, "Average");
-                this.g.setLegendItemBadgeShape(d, 2);
+            this.br(a, b, "Average", 3, () => {
+                let d = this.h.createValueLayer();
+                this.h.setValueMode(d, 6);
+                this.h.setValueAxisAnnotationEnabled(d, true);
+                this.h.setBrush(d, BrushUtil.h(255, 248, 173, 118));
+                this.h.setUseLegend(d, true);
+                this.h.setTitle(d, "Average");
+                this.h.setLegendItemBadgeShape(d, 2);
                 let e = new AutomaticSeriesRequest();
                 e.a = 3;
                 e.e = true;
@@ -756,14 +789,14 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return e;
             });
         }
-        bj(a, b) {
+        bl(a, b) {
             let c = a.ao(a);
-            let d = this.o(a, 3);
+            let d = this.p(a, 3);
             if (d != null) {
                 c.l(4);
                 return;
             }
-            if (!this.r) {
+            if (!this.t) {
                 return;
             }
             let e = a.series.count;
@@ -772,17 +805,17 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 if (g.es) {
                     continue;
                 }
-                let h = this.g.createValueLayer();
-                this.g.setValueMode(h, 3);
-                this.g.setValueAxisAnnotationEnabled(h, true);
-                this.g.setUseLegend(h, a.f2);
+                let h = this.h.createValueLayer();
+                this.h.setValueMode(h, 3);
+                this.h.setValueAxisAnnotationEnabled(h, true);
+                this.h.setUseLegend(h, a.f2);
                 if (g.title != null && typeof g.title === 'string') {
                     let i = g.title;
-                    this.g.setTitle(h, i + " Avg");
+                    this.h.setTitle(h, i + " Avg");
                 }
-                this.g.setLegendItemBadgeShape(h, 2);
-                this.g.setTargetSeries(h, g);
-                this.g.setBrush(h, g.u9);
+                this.h.setLegendItemBadgeShape(h, 2);
+                this.h.setTargetSeries(h, g);
+                this.h.setBrush(h, g.u9);
                 let j = new AutomaticSeriesRequest();
                 j.a = 4;
                 j.e = true;
@@ -790,7 +823,7 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 c.b.add(j);
             }
         }
-        v(a, b) {
+        x(a, b) {
             if (b != null) {
                 let c = false;
                 let d = a.ao(a);
@@ -817,24 +850,24 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        bl(a, b) {
-            let c = this.l(a);
-            if (this.v(a, c)) {
+        bn(a, b) {
+            let c = this.m(a);
+            if (this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "ShowValueLabels", 5, () => {
+            this.br(a, b, "ShowValueLabels", 5, () => {
                 for (let d of fromEnum(a.series)) {
                     if (d.ey) {
-                        if (this.t && this.k.matchesType(d)) {
-                            let e = this.k.getMarkerType(d);
+                        if (this.v && this.l.matchesType(d)) {
+                            let e = this.l.getMarkerType(d);
                             if (e == 1) {
-                                this.k.setMarkerType(d, 13);
+                                this.l.setMarkerType(d, 13);
                             }
                         }
                     }
                 }
-                let f = this.g.createCalloutLayer();
-                this.g.setIsAutoCalloutBehaviorEnabled(f, true);
+                let f = this.h.createCalloutLayer();
+                this.h.setIsAutoCalloutBehaviorEnabled(f, true);
                 let g = new AutomaticSeriesRequest();
                 g.a = 5;
                 g.e = true;
@@ -842,12 +875,12 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return g;
             });
         }
-        bk(a, b) {
-            let c = this.n(a);
-            if (this.v(a, c)) {
+        bm(a, b) {
+            let c = this.o(a);
+            if (this.x(a, c)) {
                 return;
             }
-            this.bp(a, b, "ShowLastValueLabel", 6, () => {
+            this.br(a, b, "ShowLastValueLabel", 6, () => {
                 for (let d of fromEnum(a.series)) {
                     let e = d.ai();
                     if (e != null) {
@@ -859,7 +892,7 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                         }
                     }
                 }
-                let h = this.g.createFinalValueLayer();
+                let h = this.h.createFinalValueLayer();
                 let i = new AutomaticSeriesRequest();
                 i.a = 6;
                 i.e = true;
@@ -867,35 +900,35 @@ export let DataChartToolbarProvider = /*@__PURE__*/ (() => {
                 return i;
             });
         }
-        a9(a, b) {
-            this.p = b;
+        bb(a, b) {
+            this.q = b;
             let c = new CaptureImageSettings();
             c.b = true;
             c.a = 0;
-            a.imageCaptured = delegateCombine(a.imageCaptured, runOn(this, this.bd));
+            a.imageCaptured = delegateCombine(a.imageCaptured, runOn(this, this.bf));
             a.nb(c);
             a.al.q();
         }
-        bd(a, b) {
-            this.p.argumentsList = [((() => {
+        bf(a, b) {
+            this.q.argumentsList = [((() => {
                     let $ret = new ToolCommandArgument();
                     $ret.argumentName = "Image";
                     $ret.value = b.base64Data;
                     return $ret;
                 })())];
             let c = a;
-            c.imageCaptured = delegateRemove(c.imageCaptured, runOn(this, this.bd));
+            c.imageCaptured = delegateRemove(c.imageCaptured, runOn(this, this.bf));
             if (c.commandCompleted != null) {
-                c.commandCompleted(this.p);
+                c.commandCompleted(this.q);
             }
         }
-        bm(a, b) {
+        bo(a, b) {
             a.rz(0.05);
         }
-        bn(a, b) {
+        bp(a, b) {
             a.r0(0.05);
         }
-        bo(a, b) {
+        bq(a, b) {
             a.q8();
         }
     }