igniteui-webcomponents-charts 5.4.0 → 5.5.0-beta.0

package/esm2015/lib/BollingerBandWidthIndicator.js

@@ -15,39 +15,39 @@ export let BollingerBandWidthIndicator = /*@__PURE__*/ (() => {
         bk() {
             return new BollingerBandWidthIndicator();
         }
-        get_abx() {
+        get_ab0() {
             return new BollingerBandWidthIndicatorStrategy();
         }
-        get abx() {
-            return this.get_abx();
+        get ab0() {
+            return this.get_ab0();
         }
-        get_aca() {
+        get_acd() {
             return BollingerBandWidthIndicator.$;
         }
-        get aca() {
-            return this.get_aca();
+        get acd() {
+            return this.get_acd();
         }
-        get acj() {
-            return typeGetValue(this.c(BollingerBandWidthIndicator.acm));
+        get acm() {
+            return typeGetValue(this.c(BollingerBandWidthIndicator.acp));
         }
-        set acj(a) {
-            this.h(BollingerBandWidthIndicator.acm, a);
+        set acm(a) {
+            this.h(BollingerBandWidthIndicator.acp, a);
         }
-        ab3() {
-            return this.acj;
+        ab6() {
+            return this.acm;
         }
-        get aci() {
-            return this.c(BollingerBandWidthIndicator.acl);
+        get acl() {
+            return this.c(BollingerBandWidthIndicator.aco);
         }
-        set aci(a) {
-            this.h(BollingerBandWidthIndicator.acl, a);
+        set acl(a) {
+            this.h(BollingerBandWidthIndicator.aco, a);
         }
-        ab1() {
-            return this.aci;
+        ab4() {
+            return this.acl;
         }
     }
     BollingerBandWidthIndicator.$t = /*@__PURE__*/ markType(BollingerBandWidthIndicator, 'BollingerBandWidthIndicator', StrategyBasedIndicator.$);
-    BollingerBandWidthIndicator.acm = /*@__PURE__*/ StrategyBasedIndicator.acf(20, BollingerBandWidthIndicator.$);
-    BollingerBandWidthIndicator.acl = /*@__PURE__*/ StrategyBasedIndicator.ace(2, BollingerBandWidthIndicator.$);
+    BollingerBandWidthIndicator.acp = /*@__PURE__*/ StrategyBasedIndicator.aci(20, BollingerBandWidthIndicator.$);
+    BollingerBandWidthIndicator.aco = /*@__PURE__*/ StrategyBasedIndicator.ach(2, BollingerBandWidthIndicator.$);
     return BollingerBandWidthIndicator;
 })();

package/esm2015/lib/BollingerBandsOverlay_combined.js

@@ -32,132 +32,132 @@ export let BollingerBandsOverlay = /*@__PURE__*/ (() => {
         }
         constructor() {
             super();
-            this.aba = 0;
-            this.abb = 0;
-            this.aa8 = new List$1(Number_$type, 0);
-            this.aa9 = new List$1(Number_$type, 0);
+            this.abd = 0;
+            this.abe = 0;
+            this.abb = new List$1(Number_$type, 0);
+            this.abc = new List$1(Number_$type, 0);
             this.ab = BollingerBandsOverlay.$;
-            this.xc = new CategoryFrame(4);
-            this.xe = new CategoryFrame(4);
-            this.xa = new CategoryFrame(4);
+            this.xf = new CategoryFrame(4);
+            this.xh = new CategoryFrame(4);
+            this.xd = new CategoryFrame(4);
         }
-        ra(a, b, c, d) {
-            if (this.yr().contains(b)) {
-                this.aa2 = false;
+        rc(a, b, c, d) {
+            if (this.yu().contains(b)) {
+                this.aa5 = false;
             }
-            super.ra(a, b, c, d);
+            super.rc(a, b, c, d);
             switch (b) {
                 case BollingerBandsOverlay.$$p[1]:
-                    this.aa2 = false;
-                    this.rs(false);
+                    this.aa5 = false;
+                    this.ru(false);
                     break;
                 case BollingerBandsOverlay.$$p[0]:
-                    this.rs(false);
+                    this.ru(false);
                     break;
             }
         }
-        aa3() {
-            this.aa8.clear();
-            this.aa9.clear();
-            let a = getEnumerator(TrendCalculators.e(new SafeEnumerable(this.yq), this.abd));
-            let b = getEnumerator(TrendCalculators.f(new SafeEnumerable(this.yq), this.abd));
-            this.abb = 1.7976931348623157E+308;
-            this.aba = -1.7976931348623157E+308;
+        aa6() {
+            this.abb.clear();
+            this.abc.clear();
+            let a = getEnumerator(TrendCalculators.e(new SafeEnumerable(this.yt), this.abg));
+            let b = getEnumerator(TrendCalculators.f(new SafeEnumerable(this.yt), this.abg));
+            this.abe = 1.7976931348623157E+308;
+            this.abd = -1.7976931348623157E+308;
             let c = true;
             let d = true;
-            let e = this.abc;
+            let e = this.abf;
             while (c || d) {
                 if (a.moveNext()) {
-                    this.aa8.add(a.current);
+                    this.abb.add(a.current);
                 }
                 else {
                     c = false;
                 }
                 if (b.moveNext()) {
-                    this.aa9.add(b.current);
+                    this.abc.add(b.current);
                 }
                 else {
                     d = false;
                 }
                 if (c && d) {
-                    this.abb = Math.min(this.abb, a.current - b.current * e);
-                    this.aba = Math.max(this.aba, a.current + b.current * e);
+                    this.abe = Math.min(this.abe, a.current - b.current * e);
+                    this.abd = Math.max(this.abd, a.current + b.current * e);
                 }
             }
             return true;
         }
         ay(a) {
-            if (this.aa8 == null || this.aa9 == null || a == null || this.dp == null || a != this.xr) {
+            if (this.abb == null || this.abc == null || a == null || this.dp == null || a != this.xu) {
                 return null;
             }
-            let b = new AxisRange(this.abb, this.aba);
+            let b = new AxisRange(this.abe, this.abd);
             return b;
         }
-        aae(a, b) {
-            super.aae(a, b);
-            let c = b.b2;
-            let d = b.b1;
+        aah(a, b) {
+            super.aah(a, b);
+            let c = b.ca;
+            let d = b.b9;
             let e = this.getEffectiveViewport1(b);
-            let f = this.w8;
-            let g = this.xr;
+            let f = this.xb;
+            let g = this.xu;
             let h = new ScalerParams(0, c, d, f.ch, e);
             let i = new ScalerParams(0, c, d, g.ch, e);
             a.h.clear();
             a.p.clear();
             a.s.clear();
-            let j = typeCast(ISortingAxis_$type, this.w8);
+            let j = typeCast(ISortingAxis_$type, this.xb);
             if (j != null && j.i$b.count != this.dp.count) {
                 return;
             }
             let k = 0;
-            k = this.yz(c, d, e);
-            if (!this.aa2) {
-                this.aa2 = this.aa3();
-                if (this.xr != null) {
-                    this.xr.c2(true);
+            k = this.y2(c, d, e);
+            if (!this.aa5) {
+                this.aa5 = this.aa6();
+                if (this.xu != null) {
+                    this.xu.c2(true);
                 }
             }
-            i.b = this.iy();
-            let l = this.w8.eo(2, h) - this.w8.eo(1, h);
-            for (let m = b.b4.c; m <= b.b4.d; ++m) {
+            i.b = this.iz();
+            let l = this.xb.eo(2, h) - this.xb.eo(1, h);
+            for (let m = b.cd.c; m <= b.cd.d; ++m) {
                 let n;
                 if (j == null) {
-                    n = b.b4.getBucket(m);
+                    n = b.cd.getBucket(m);
                 }
                 else {
                     let o = j.i$b._inner[m];
                     let p = j.i$d(o);
-                    let q = this.aa8._inner[m];
-                    let r = this.aa9._inner[m];
+                    let q = this.abb._inner[m];
+                    let r = this.abc._inner[m];
                     let s = q;
                     let t = r;
                     let u = p;
                     let v = 1;
-                    while (m < b.b4.d) {
+                    while (m < b.cd.d) {
                         o = j.i$b._inner[m + 1];
                         u = j.i$d(o);
                         if (u - p > l) {
                             break;
                         }
                         m++;
-                        s += this.aa8._inner[m];
-                        t += this.aa9._inner[m];
+                        s += this.abb._inner[m];
+                        t += this.abc._inner[m];
                         v++;
                     }
                     s /= v;
                     t /= v;
-                    let w = s - t * this.abc;
+                    let w = s - t * this.abf;
                     let x = s;
-                    let y = s + t * this.abc;
+                    let y = s + t * this.abf;
                     let z = NaN;
                     if (!isNaN_(p)) {
-                        z = this.w8.el(p, h);
+                        z = this.xb.el(p, h);
                     }
                     n = [z, w, x, y];
                 }
                 let aa = Math.max(1, l);
-                if (!isNaN_(n[0]) && m * aa >= this.aa4) {
-                    if (this.w8 != null && typeCast(ISortingAxis_$type, this.w8) !== null) {
+                if (!isNaN_(n[0]) && m * aa >= this.aa7) {
+                    if (this.xb != null && typeCast(ISortingAxis_$type, this.xb) !== null) {
                         n[0] = n[0] + k;
                     }
                     else {
@@ -170,97 +170,97 @@ export let BollingerBandsOverlay = /*@__PURE__*/ (() => {
                 }
             }
         }
-        o5(a, b) {
-            super.o5(a, b);
+        o7(a, b) {
+            super.o7(a, b);
             let c = b;
             if (c != null) {
-                c.cb();
+                c.ck();
             }
         }
-        i5(a, b, c) {
-            if (this.aa8 == null) {
-                return super.i5(a, b, c);
+        i6(a, b, c) {
+            if (this.abb == null) {
+                return super.i6(a, b, c);
             }
             let d = this.getEffectiveViewport1(this.cw);
-            let e = this.yz(this.cw.b2, this.cw.b1, d);
-            let f = new ScalerParams(0, this.cw.b2, this.cw.b1, this.w8.ch, d);
-            f.c = this.dc.wn;
-            return this.i7(this.aa8, a, this.w8, f, e, runOn(this, this.yy), b, c);
+            let e = this.y2(this.cw.ca, this.cw.b9, d);
+            let f = new ScalerParams(0, this.cw.ca, this.cw.b9, this.xb.ch, d);
+            f.c = this.dc.wz;
+            return this.i8(this.abb, a, this.xb, f, e, runOn(this, this.y1), b, c);
         }
-        ka(a, b) {
-            if (this.aa8 == null) {
-                return super.ka(a, b);
+        kb(a, b) {
+            if (this.abb == null) {
+                return super.kb(a, b);
             }
-            return this.kb(a, b, this.w8, runOn(this, this.yy), this.aa8);
+            return this.kc(a, b, this.xb, runOn(this, this.y1), this.abb);
         }
-        j8(a, b) {
-            if (this.aa8 == null) {
-                return super.j8(a, b);
+        j9(a, b) {
+            if (this.abb == null) {
+                return super.j9(a, b);
             }
-            return this.j9(a, b, this.w8, runOn(this, this.yy), this.aa8);
+            return this.ka(a, b, this.xb, runOn(this, this.y1), this.abb);
         }
-        he(a, b, c) {
-            let d = super.he(a, b, c);
-            if (!this.yh(this.yr())) {
+        hf(a, b, c) {
+            let d = super.hf(a, b, c);
+            if (!this.yk(this.yu())) {
                 d = false;
             }
             return d;
         }
-        aag(a, b) {
-            super.aag(a, b);
+        aaj(a, b) {
+            super.aaj(a, b);
             let c = typeCast(BollingerBandsOverlayView.$, b);
             let d = this.getEffectiveViewport1(b);
-            if (b.b7(a)) {
-                c.cb();
+            if (b.cg(a)) {
+                c.ck();
                 let e = a.h.count;
                 let f = (g) => a.h._inner[g][0];
                 let g = (h) => a.h._inner[e - 1 - h][0];
                 let h = (i) => a.h._inner[i][1];
                 let i = (j) => a.h._inner[j][2];
                 let j = (k) => a.h._inner[e - 1 - k][3];
-                c.cc(e, f, g, h, i, j);
-                b.b9(a);
+                c.cl(e, f, g, h, i, j);
+                b.ci(a);
             }
-            this.xh.a2(this, this.yg(), runOn(this, this.w0), this.y5(b), this.y7(b));
+            this.xk.a2(this, this.yj(), runOn(this, this.w3), this.y8(b), this.za(b));
             let k = false;
-            let l = this.xh.b;
+            let l = this.xk.b;
             let m = a.h;
             let n = this.dp.count;
             if (l != null) {
                 k = true;
             }
             if (k) {
-                let o = new ScalerParams(0, b.b2, b.b1, this.w8.ch, d);
-                this.aad(m, -1, n, this.w8, o, b.r, -1);
+                let o = new ScalerParams(0, b.ca, b.b9, this.xb.ch, d);
+                this.aag(m, -1, n, this.xb, o, b.t, -1);
             }
-            let p = c.cj;
-            let q = c.ck;
-            let r = c.cl;
-            let s = c.ce;
-            this.xh.ad(q, true, false, true, true);
-            this.xh.an = null;
-            this.xh.am = null;
-            this.xh.ad(p, true, false, false, true);
-            this.xh.ad(r, true, false, false, true);
-            this.xh.ad(s, false, true, false, false);
-            s._opacity = this.xh.j * this.h9;
+            let p = c.cs;
+            let q = c.ct;
+            let r = c.cu;
+            let s = c.cn;
+            this.xk.ad(q, true, false, true, true);
+            this.xk.an = null;
+            this.xk.am = null;
+            this.xk.ad(p, true, false, false, true);
+            this.xk.ad(r, true, false, false, true);
+            this.xk.ad(s, false, true, false, false);
+            s._opacity = this.xk.j * this.ia;
         }
         ct() {
             return new BollingerBandsOverlayView(this);
         }
-        q1(a) {
-            super.q1(a);
-            this.aa7 = typeCast(BollingerBandsOverlayView.$, a);
+        q3(a) {
+            super.q3(a);
+            this.aba = typeCast(BollingerBandsOverlayView.$, a);
         }
-        y8() {
+        zb() {
             return 3;
         }
-        iy() {
-            return Series.i0(this.aa8, null);
+        iz() {
+            return Series.i1(this.abb, null);
         }
     }
     BollingerBandsOverlay.$t = /*@__PURE__*/ markType(BollingerBandsOverlay, 'BollingerBandsOverlay', FinancialOverlay.$);
-    BollingerBandsOverlay.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, BollingerBandsOverlay, 'raisePropertyChanged', ['Multiplier:abc:abg', [1, 2], 'Period:abd:abh', [1, 14]]);
+    BollingerBandsOverlay.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, BollingerBandsOverlay, 'raisePropertyChanged', ['Multiplier:abf:abj', [1, 2], 'Period:abg:abk', [1, 14]]);
     return BollingerBandsOverlay;
 })();
 /**
@@ -275,16 +275,16 @@ export let BollingerBandsBucketCalculator = /*@__PURE__*/ (() => {
         }
         getBucket(a) {
             let b = a * this.b;
-            let c = Math.min(b + this.b - 1, this.a.b6.dp.count - 1);
+            let c = Math.min(b + this.b - 1, this.a.cf.dp.count - 1);
             if (b <= c) {
-                let d = this.f.ca.abc;
+                let d = this.f.cj.abf;
                 let e = 0;
                 let f = 0;
                 let g = 0;
                 for (let h = b; h <= c; ++h) {
-                    if (!isNaN_(this.f.ca.aa8._inner[h]) && !isNaN_(this.f.ca.aa9._inner[h])) {
-                        e += this.f.ca.aa8._inner[h];
-                        f += this.f.ca.aa9._inner[h];
+                    if (!isNaN_(this.f.cj.abb._inner[h]) && !isNaN_(this.f.cj.abc._inner[h])) {
+                        e += this.f.cj.abb._inner[h];
+                        f += this.f.cj.abc._inner[h];
                         ++g;
                     }
                 }
@@ -307,97 +307,97 @@ export let BollingerBandsOverlayView = /*@__PURE__*/ (() => {
     class BollingerBandsOverlayView extends FinancialSeriesView {
         constructor(a) {
             super(a);
-            this.ca = null;
-            this.cf = new Polygon();
-            this.cm = new Polyline();
-            this.cn = new Polyline();
-            this.co = new Polyline();
-            this.cd = new Polygon();
-            this.cg = new Polyline();
-            this.ch = new Polyline();
-            this.ci = new Polyline();
-            this.ca = a;
+            this.cj = null;
+            this.co = new Polygon();
+            this.cv = new Polyline();
+            this.cw = new Polyline();
+            this.cx = new Polyline();
+            this.cm = new Polygon();
+            this.cp = new Polyline();
+            this.cq = new Polyline();
+            this.cr = new Polyline();
+            this.cj = a;
         }
-        ax() {
-            super.ax();
-            if (!this.r) {
+        a4() {
+            super.a4();
+            if (!this.t) {
             }
         }
-        b5() {
+        ce() {
             return new BollingerBandsBucketCalculator(this);
         }
-        cc(a, b, c, d, e, f) {
-            for (let g of fromEnum(Flattener.d(a, b, d, this.f.id))) {
-                this.cf.an.add({ $type: Point_$type, x: b(g), y: d(g) });
-                this.cm.an.add({ $type: Point_$type, x: b(g), y: d(g) });
+        cl(a, b, c, d, e, f) {
+            for (let g of fromEnum(Flattener.d(a, b, d, this.f.ie))) {
+                this.co.an.add({ $type: Point_$type, x: b(g), y: d(g) });
+                this.cv.an.add({ $type: Point_$type, x: b(g), y: d(g) });
             }
-            for (let h of fromEnum(Flattener.d(a, b, e, this.f.id))) {
-                this.cn.an.add({ $type: Point_$type, x: b(h), y: e(h) });
+            for (let h of fromEnum(Flattener.d(a, b, e, this.f.ie))) {
+                this.cw.an.add({ $type: Point_$type, x: b(h), y: e(h) });
             }
-            for (let i of fromEnum(Flattener.d(a, c, f, this.f.id))) {
-                this.cf.an.add({ $type: Point_$type, x: c(i), y: f(i) });
+            for (let i of fromEnum(Flattener.d(a, c, f, this.f.ie))) {
                 this.co.an.add({ $type: Point_$type, x: c(i), y: f(i) });
+                this.cx.an.add({ $type: Point_$type, x: c(i), y: f(i) });
             }
-            this.av();
+            this.a2();
         }
-        cb() {
-            this.cf.an.clear();
-            this.cm.an.clear();
-            this.cn.an.clear();
+        ck() {
             this.co.an.clear();
-            this.av();
+            this.cv.an.clear();
+            this.cw.an.clear();
+            this.cx.an.clear();
+            this.a2();
         }
-        get ce() {
-            return this.cf;
+        get cn() {
+            return this.co;
         }
-        get cj() {
-            return this.cm;
+        get cs() {
+            return this.cv;
         }
-        get ck() {
-            return this.cn;
+        get ct() {
+            return this.cw;
         }
-        get cl() {
-            return this.co;
+        get cu() {
+            return this.cx;
         }
-        bi() {
-            super.bi();
-            this.cd.an = this.cf.an;
-            this.cg.an = this.cm.an;
-            this.ch.an = this.cn.an;
-            this.ci.an = this.co.an;
-            let a = this.bv();
-            this.cd._fill = a;
-            this.cd._opacity = 1;
-            this.cg._stroke = a;
-            this.cg.ad = this.f.ie + 3;
-            this.ch._stroke = a;
-            this.ch.ad = this.f.ie + 3;
-            this.ci._stroke = a;
-            this.ci.ad = this.f.ie + 3;
+        bq() {
+            super.bq();
+            this.cm.an = this.co.an;
+            this.cp.an = this.cv.an;
+            this.cq.an = this.cw.an;
+            this.cr.an = this.cx.an;
+            let a = this.b3();
+            this.cm._fill = a;
+            this.cm._opacity = 1;
+            this.cp._stroke = a;
+            this.cp.ad = this.f.ig + 3;
+            this.cq._stroke = a;
+            this.cq.ad = this.f.ig + 3;
+            this.cr._stroke = a;
+            this.cr.ad = this.f.ig + 3;
         }
-        bc(a, b) {
-            super.bc(a, b);
+        bj(a, b) {
+            super.bj(a, b);
             if (a.d) {
                 if (b) {
-                    a.u(this.cd);
-                    a.v(this.cg);
-                    a.v(this.ch);
-                    a.v(this.ci);
+                    a.u(this.cm);
+                    a.v(this.cp);
+                    a.v(this.cq);
+                    a.v(this.cr);
                 }
                 else {
-                    a.u(this.cf);
-                    a.v(this.cm);
-                    a.v(this.cn);
-                    a.v(this.co);
+                    a.u(this.co);
+                    a.v(this.cv);
+                    a.v(this.cw);
+                    a.v(this.cx);
                 }
             }
         }
-        aq(a) {
-            super.aq(a);
-            this.f.bc.exportPolygonData(a, this.cf, "FillShape", ["Fill"]);
-            this.f.bc.exportPolylineData(a, this.cm, "BottomLine", ["Lower", "Main"]);
-            this.f.bc.exportPolylineData(a, this.cn, "CentralLine", ["Central"]);
-            this.f.bc.exportPolylineData(a, this.co, "TopLine", ["Upper"]);
+        ax(a) {
+            super.ax(a);
+            this.f.bc.exportPolygonData(a, this.co, "FillShape", ["Fill"]);
+            this.f.bc.exportPolylineData(a, this.cv, "BottomLine", ["Lower", "Main"]);
+            this.f.bc.exportPolylineData(a, this.cw, "CentralLine", ["Central"]);
+            this.f.bc.exportPolylineData(a, this.cx, "TopLine", ["Upper"]);
         }
     }
     BollingerBandsOverlayView.$t = /*@__PURE__*/ markType(BollingerBandsOverlayView, 'BollingerBandsOverlayView', FinancialSeriesView.$);

package/esm2015/lib/BrushScale.js

@@ -34,9 +34,9 @@ export let BrushScale = /*@__PURE__*/ (() => {
         }
         r(a, b) {
             for (let c of fromEnum(this.o)) {
-                c.rs(false);
-                c.qd();
-                c.ql();
+                c.ru(false);
+                c.qf();
+                c.qn();
             }
         }
         s() {
@@ -107,10 +107,10 @@ export let BrushScale = /*@__PURE__*/ (() => {
         }
         notifySeries() {
             for (let a of fromEnum(this.o)) {
-                a.qg();
-                a.rs(false);
-                a.qd();
-                a.ql();
+                a.qi();
+                a.ru(false);
+                a.qf();
+                a.qn();
             }
         }
         z(a, b) {