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

package/esm2015/lib/PolarSplineSeries_combined.js

@@ -24,50 +24,50 @@ export let PolarSplineSeries = /*@__PURE__*/ (() => {
         bk() {
             return new PolarSplineSeries();
         }
-        get_f0() {
+        get_f1() {
             return true;
         }
         ct() {
             return new PolarSplineSeriesView(this);
         }
-        q1(a) {
-            super.q1(a);
-            this.acw = a;
+        q3(a) {
+            super.q3(a);
+            this.acz = a;
         }
         constructor() {
             super();
             this.ab = PolarSplineSeries.$;
         }
-        ra(a, b, c, d) {
-            super.ra(a, b, c, d);
+        rc(a, b, c, d) {
+            super.rc(a, b, c, d);
             switch (b) {
                 case PolarSplineSeries.$$p[0]:
-                    this.rs(false);
+                    this.ru(false);
                     break;
             }
         }
-        acu(a) {
+        acx(a) {
             let b = a;
-            b.de();
+            b.dn();
         }
-        acv(a, b) {
-            this.acu(b);
+        acy(a, b) {
+            this.acx(b);
             let c = b;
-            c.df(a.n, this.acx);
-            this.y7.az(this, this.zz(), runOn(this, this.yp));
+            c.dp(a.n, this.ac0);
+            this.za.az(this, this.z2(), runOn(this, this.ys));
             let d = false;
-            let e = this.y7.b;
+            let e = this.za.b;
             if (e != null) {
                 d = true;
             }
             if (d) {
-                this.abe(-1, this.zl.count, b.r);
+                this.abh(-1, this.zo.count, b.t);
             }
-            this.y7.ad(b.dh, true, false, true, false);
+            this.za.ad(b.dr, true, false, true, false);
         }
     }
     PolarSplineSeries.$t = /*@__PURE__*/ markType(PolarSplineSeries, 'PolarSplineSeries', PolarLineSeriesBase.$);
-    PolarSplineSeries.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, PolarSplineSeries, 'raisePropertyChanged', ['Stiffness:acx:acz', [1, 0.5]]);
+    PolarSplineSeries.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, PolarSplineSeries, 'raisePropertyChanged', ['Stiffness:ac0:ac2', [1, 0.5]]);
     return PolarSplineSeries;
 })();
 /**
@@ -77,73 +77,73 @@ export let PolarSplineSeriesView = /*@__PURE__*/ (() => {
     class PolarSplineSeriesView extends PolarLineSeriesBaseView {
         constructor(a) {
             super(a);
-            this.dd = null;
-            this.dh = ((() => {
+            this.dm = null;
+            this.dr = ((() => {
                 let $ret = new Path();
                 $ret.an = new PathGeometry();
                 return $ret;
             })());
-            this.dg = ((() => {
+            this.dq = ((() => {
                 let $ret = new Path();
                 $ret.an = new PathGeometry();
                 return $ret;
             })());
-            this.dd = a;
+            this.dm = a;
         }
-        ax() {
-            super.ax();
-            if (!this.r) {
-                this.b8.xc = Defaults.e;
+        a4() {
+            super.a4();
+            if (!this.t) {
+                this.ch.xf = Defaults.e;
             }
             let a = new PathGeometry();
             a.c.add(((() => {
                 let $ret = new PathFigure();
                 return $ret;
             })()));
-            this.dh.an = a;
+            this.dr.an = a;
         }
-        de() {
-            Extensions.e(this.dh.an);
-            Extensions.e(this.dg.an);
-            this.av();
+        dn() {
+            Extensions.e(this.dr.an);
+            Extensions.e(this.dq.an);
+            this.a2();
         }
-        df(a, b) {
-            this.dh.an.c = Numeric.h(a.count, (c) => a._inner[c].x, (c) => a._inner[c].y, b);
-            this.av();
+        dp(a, b) {
+            this.dr.an.c = Numeric.h(a.count, (c) => a._inner[c].x, (c) => a._inner[c].y, b);
+            this.a2();
         }
-        bh() {
-            super.bh();
+        bp() {
+            super.bp();
         }
-        bi() {
-            super.bi();
-            let a = this.bv();
-            this.dg.an = this.dh.an;
-            this.dg._stroke = a;
-            this.dg.ad = this.f.ie + 3;
+        bq() {
+            super.bq();
+            let a = this.b3();
+            this.dq.an = this.dr.an;
+            this.dq._stroke = a;
+            this.dq.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.t(this.dg);
+                    a.t(this.dq);
                 }
                 else {
-                    a.t(this.dh);
+                    a.t(this.dr);
                 }
             }
         }
-        aq(a) {
-            super.aq(a);
-            this.f.bc.exportPathData(a, this.dh, "polarShape", ["Main"]);
+        ax(a) {
+            super.ax(a);
+            this.f.bc.exportPathData(a, this.dr, "polarShape", ["Main"]);
         }
-        ai() {
+        an() {
             let a = new Color();
             a.colorString = "rgba(95,95,95,0.5)";
-            this.f.v3 = a;
-            this.f.jm = 3;
-            this.f.jn = 1;
-            this.f.jo = 4;
-            this.f.hc = false;
+            this.f.v6 = a;
+            this.f.jn = 3;
+            this.f.jo = 1;
+            this.f.jp = 4;
+            this.f.hd = false;
         }
     }
     PolarSplineSeriesView.$t = /*@__PURE__*/ markType(PolarSplineSeriesView, 'PolarSplineSeriesView', PolarLineSeriesBaseView.$);

package/esm2015/lib/PositiveVolumeIndexIndicator.js

@@ -15,17 +15,17 @@ export let PositiveVolumeIndexIndicator = /*@__PURE__*/ (() => {
         bk() {
             return new PositiveVolumeIndexIndicator();
         }
-        get_abx() {
+        get_ab0() {
             return new PositiveVolumeIndexIndicatorStrategy();
         }
-        get abx() {
-            return this.get_abx();
+        get ab0() {
+            return this.get_ab0();
         }
-        get_aca() {
+        get_acd() {
             return PositiveVolumeIndexIndicator.$;
         }
-        get aca() {
-            return this.get_aca();
+        get acd() {
+            return this.get_acd();
         }
     }
     PositiveVolumeIndexIndicator.$t = /*@__PURE__*/ markType(PositiveVolumeIndexIndicator, 'PositiveVolumeIndexIndicator', StrategyBasedIndicator.$);

package/esm2015/lib/PriceChannelOverlay_combined.js

@@ -31,42 +31,42 @@ export let PriceChannelOverlay = /*@__PURE__*/ (() => {
         }
         constructor() {
             super();
-            this.aa9 = new List$1(Number_$type, 0);
-            this.aa8 = new List$1(Number_$type, 0);
+            this.abc = new List$1(Number_$type, 0);
+            this.abb = new List$1(Number_$type, 0);
             this.ab = PriceChannelOverlay.$;
-            this.xc = new CategoryFrame(3);
-            this.xe = new CategoryFrame(3);
-            this.xa = new CategoryFrame(3);
+            this.xf = new CategoryFrame(3);
+            this.xh = new CategoryFrame(3);
+            this.xd = new CategoryFrame(3);
         }
-        ra(a, b, c, d) {
+        rc(a, b, c, d) {
             switch (b) {
                 case "HighColumn":
                 case "LowColumn":
-                    this.aa2 = false;
+                    this.aa5 = false;
                     break;
             }
-            super.ra(a, b, c, d);
+            super.rc(a, b, c, d);
             switch (b) {
                 case PriceChannelOverlay.$$p[0]:
-                    this.aa2 = false;
-                    this.rs(false);
+                    this.aa5 = false;
+                    this.ru(false);
                     break;
             }
         }
-        he(a, b, c) {
-            let d = super.he(a, b, c);
-            if (this.x2 == null || this.x3 == null) {
+        hf(a, b, c) {
+            let d = super.hf(a, b, c);
+            if (this.x5 == null || this.x6 == null) {
                 d = false;
             }
             return d;
         }
-        aa3() {
-            this.aa9.clear();
-            this.aa8.clear();
-            let a = truncate(MathUtil.d(this.aba, 0, this.dp.count));
-            let b = Math.min(this.x2.count, this.x3.count);
-            let c = this.ys(this.x2);
-            let d = this.ys(this.x3);
+        aa6() {
+            this.abc.clear();
+            this.abb.clear();
+            let a = truncate(MathUtil.d(this.abd, 0, this.dp.count));
+            let b = Math.min(this.x5.count, this.x6.count);
+            let c = this.yv(this.x5);
+            let d = this.yv(this.x6);
             for (let e = 0; e < b; e++) {
                 let f = Math.min(a, e);
                 let g = -1.7976931348623157E+308;
@@ -83,62 +83,62 @@ export let PriceChannelOverlay = /*@__PURE__*/ (() => {
                     h = d.item(0);
                     g = c.item(0);
                 }
-                this.aa9.add(g);
-                this.aa8.add(h);
+                this.abc.add(g);
+                this.abb.add(h);
             }
             return true;
         }
-        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 = new ScalerParams(0, c, d, this.w8.ch, e);
-            let g = new ScalerParams(0, c, d, this.xr.ch, e);
-            g.b = this.iy();
-            let h = this.w8;
-            let i = this.xr;
+            let f = new ScalerParams(0, c, d, this.xb.ch, e);
+            let g = new ScalerParams(0, c, d, this.xu.ch, e);
+            g.b = this.iz();
+            let h = this.xb;
+            let i = this.xu;
             a.h.clear();
             a.p.clear();
             a.s.clear();
             let j = 0;
-            let k = typeCast(ISortingAxis_$type, this.w8);
+            let k = typeCast(ISortingAxis_$type, this.xb);
             if (k != null && k.i$b.count != this.dp.count) {
                 return;
             }
-            j = this.yz(c, d, e);
-            if (!this.aa2) {
-                this.aa2 = this.aa3();
+            j = this.y2(c, d, e);
+            if (!this.aa5) {
+                this.aa5 = this.aa6();
             }
-            g.b = this.iy();
-            let l = this.w8.eo(2, f) - this.w8.eo(1, f);
-            for (let m = b.b4.c; m <= b.b4.d; ++m) {
+            g.b = this.iz();
+            let l = this.xb.eo(2, f) - this.xb.eo(1, f);
+            for (let m = b.cd.c; m <= b.cd.d; ++m) {
                 let n;
                 if (k == null) {
-                    n = b.b4.getBucket(m);
+                    n = b.cd.getBucket(m);
                 }
                 else {
                     let o = k.i$b._inner[m];
                     let p = k.i$d(o);
-                    let q = this.aa9._inner[m];
-                    let r = this.aa8._inner[m];
+                    let q = this.abc._inner[m];
+                    let r = this.abb._inner[m];
                     let s = q;
                     let t = r;
                     let u = p;
-                    while (m < b.b4.d) {
+                    while (m < b.cd.d) {
                         o = k.i$b._inner[m + 1];
                         u = k.i$d(o);
                         if (u - p > l) {
                             break;
                         }
                         m++;
-                        s = Math.max(q, this.aa9._inner[m]);
-                        t = Math.min(r, this.aa8._inner[m]);
+                        s = Math.max(q, this.abc._inner[m]);
+                        t = Math.min(r, this.abb._inner[m]);
                     }
                     if (!isInfinity(t) && !isInfinity(s)) {
                         let v = NaN;
                         if (!isNaN_(p)) {
-                            v = this.w8.el(p, f);
+                            v = this.xb.el(p, f);
                         }
                         n = [v, t, s];
                     }
@@ -147,8 +147,8 @@ export let PriceChannelOverlay = /*@__PURE__*/ (() => {
                     }
                 }
                 let w = Math.max(1, l);
-                if (!isNaN_(n[0]) && m * w >= this.aa4) {
-                    if (this.w8 != null && typeCast(ISortingAxis_$type, this.w8) !== null) {
+                if (!isNaN_(n[0]) && m * w >= this.aa7) {
+                    if (this.xb != null && typeCast(ISortingAxis_$type, this.xb) !== null) {
                         n[0] = n[0] + j;
                     }
                     else {
@@ -160,84 +160,84 @@ export let PriceChannelOverlay = /*@__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();
             }
         }
-        aag(a, b) {
-            super.aag(a, b);
+        aaj(a, b) {
+            super.aaj(a, b);
             let c = typeCast(PriceChannelOverlayView.$, b);
             if (c == null) {
                 return;
             }
             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[e - 1 - j][2];
-                c.cc(e, f, g, h, i);
-                b.b9(a);
+                c.cl(e, f, g, h, i);
+                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 j = false;
-            let k = this.xh.b;
+            let k = this.xk.b;
             let l = a.h;
             let m = this.dp.count;
             if (k != null) {
                 j = true;
             }
             if (j) {
-                let n = new ScalerParams(0, b.b2, b.b1, this.w8.ch, d);
-                this.aad(l, -1, m, this.w8, n, b.r, -1);
+                let n = new ScalerParams(0, b.ca, b.b9, this.xb.ch, d);
+                this.aag(l, -1, m, this.xb, n, b.t, -1);
             }
-            let o = c.ci;
-            let p = c.cj;
-            let q = c.ce;
-            this.xh.ad(o, true, false, true, true);
-            this.xh.ad(p, true, false, true, true);
-            this.xh.ad(q, false, true, false, false);
-            q._opacity = this.xh.j * this.h9;
+            let o = c.cr;
+            let p = c.cs;
+            let q = c.cn;
+            this.xk.ad(o, true, false, true, true);
+            this.xk.ad(p, true, false, true, true);
+            this.xk.ad(q, false, true, false, false);
+            q._opacity = this.xk.j * this.ia;
         }
         ct() {
             return new PriceChannelOverlayView(this);
         }
-        q1(a) {
-            super.q1(a);
-            this.aa7 = typeCast(PriceChannelOverlayView.$, a);
+        q3(a) {
+            super.q3(a);
+            this.aba = typeCast(PriceChannelOverlayView.$, a);
         }
-        i5(a, b, c) {
+        i6(a, b, c) {
             if (this.dc == null) {
                 return NaN;
             }
             let d = this.getEffectiveViewport1(this.cw);
-            let e = new ScalerParams(0, this.dc.v5, this.cw.b1, this.w8.ch, d);
-            let f = this.yz(this.dc.v5, this.cw.b1, d);
-            return this.i7(new RangeValueList(this.aa9, this.aa8), a, this.w8, e, f, runOn(this, this.yy), b, c);
+            let e = new ScalerParams(0, this.dc.wh, this.cw.b9, this.xb.ch, d);
+            let f = this.y2(this.dc.wh, this.cw.b9, d);
+            return this.i8(new RangeValueList(this.abc, this.abb), a, this.xb, e, f, runOn(this, this.y1), b, c);
         }
-        j8(a, b) {
-            if (this.aa9 == null || this.aa8 == null) {
-                return super.j8(a, b);
+        j9(a, b) {
+            if (this.abc == null || this.abb == null) {
+                return super.j9(a, b);
             }
-            return this.j9(a, b, this.w8, runOn(this, this.yy), new RangeValueList(this.aa9, this.aa8));
+            return this.ka(a, b, this.xb, runOn(this, this.y1), new RangeValueList(this.abc, this.abb));
         }
-        ka(a, b) {
-            if (this.aa9 == null || this.aa8 == null) {
-                return super.ka(a, b);
+        kb(a, b) {
+            if (this.abc == null || this.abb == null) {
+                return super.kb(a, b);
             }
-            return this.kb(a, b, this.w8, runOn(this, this.yy), new RangeValueList(this.aa9, this.aa8));
+            return this.kc(a, b, this.xb, runOn(this, this.y1), new RangeValueList(this.abc, this.abb));
         }
-        iy() {
-            return Series.i0(this.aa8, null);
+        iz() {
+            return Series.i1(this.abb, null);
         }
     }
     PriceChannelOverlay.$t = /*@__PURE__*/ markType(PriceChannelOverlay, 'PriceChannelOverlay', FinancialOverlay.$);
-    PriceChannelOverlay.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, PriceChannelOverlay, 'raisePropertyChanged', ['Period:aba:abc', [1, 14]]);
+    PriceChannelOverlay.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, PriceChannelOverlay, 'raisePropertyChanged', ['Period:abd:abf', [1, 14]]);
     return PriceChannelOverlay;
 })();
 /**
@@ -252,15 +252,15 @@ export let PriceChannelBucketCalculator = /*@__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 = -1.7976931348623157E+308;
                 let e = 1.7976931348623157E+308;
                 let f = 0;
                 for (let g = b; g <= c; ++g) {
-                    if (!isNaN_(this.f.ca.aa9._inner[g]) && !isNaN_(this.f.ca.aa8._inner[g])) {
-                        d = Math.max(d, this.f.ca.aa9._inner[g]);
-                        e = Math.min(e, this.f.ca.aa8._inner[g]);
+                    if (!isNaN_(this.f.cj.abc._inner[g]) && !isNaN_(this.f.cj.abb._inner[g])) {
+                        d = Math.max(d, this.f.cj.abc._inner[g]);
+                        e = Math.min(e, this.f.cj.abb._inner[g]);
                         ++f;
                     }
                 }
@@ -279,84 +279,84 @@ export let PriceChannelBucketCalculator = /*@__PURE__*/ (() => {
  */
 export let PriceChannelOverlayView = /*@__PURE__*/ (() => {
     class PriceChannelOverlayView extends FinancialSeriesView {
-        get ce() {
-            return this.cf;
+        get cn() {
+            return this.co;
         }
-        get ci() {
-            return this.ck;
+        get cr() {
+            return this.ct;
         }
-        get cj() {
-            return this.cl;
+        get cs() {
+            return this.cu;
         }
         constructor(a) {
             super(a);
-            this.cf = new Polygon();
-            this.ck = new Polyline();
-            this.cl = new Polyline();
-            this.ca = null;
-            this.cd = new Polygon();
-            this.cg = new Polyline();
-            this.ch = new Polyline();
-            this.ca = a;
+            this.co = new Polygon();
+            this.ct = new Polyline();
+            this.cu = new Polyline();
+            this.cj = null;
+            this.cm = new Polygon();
+            this.cp = new Polyline();
+            this.cq = new Polyline();
+            this.cj = a;
         }
-        ax() {
-            super.ax();
-            if (!this.r) {
+        a4() {
+            super.a4();
+            if (!this.t) {
             }
         }
-        b5() {
+        ce() {
             return new PriceChannelBucketCalculator(this);
         }
-        cb() {
-            this.cf.an.clear();
-            this.ck.an.clear();
-            this.cl.an.clear();
-            this.av();
+        ck() {
+            this.co.an.clear();
+            this.ct.an.clear();
+            this.cu.an.clear();
+            this.a2();
         }
-        cc(a, b, c, d, e) {
-            for (let f of fromEnum(Flattener.d(a, b, d, this.f.id))) {
-                this.cf.an.add({ $type: Point_$type, x: b(f), y: d(f) });
-                this.ck.an.add({ $type: Point_$type, x: b(f), y: d(f) });
+        cl(a, b, c, d, e) {
+            for (let f of fromEnum(Flattener.d(a, b, d, this.f.ie))) {
+                this.co.an.add({ $type: Point_$type, x: b(f), y: d(f) });
+                this.ct.an.add({ $type: Point_$type, x: b(f), y: d(f) });
             }
-            for (let g of fromEnum(Flattener.d(a, c, e, this.f.id))) {
-                this.cf.an.add({ $type: Point_$type, x: c(g), y: e(g) });
-                this.cl.an.add({ $type: Point_$type, x: c(g), y: e(g) });
+            for (let g of fromEnum(Flattener.d(a, c, e, this.f.ie))) {
+                this.co.an.add({ $type: Point_$type, x: c(g), y: e(g) });
+                this.cu.an.add({ $type: Point_$type, x: c(g), y: e(g) });
             }
-            this.av();
+            this.a2();
         }
-        bi() {
-            super.bi();
-            this.cd.an = this.cf.an;
-            this.cg.an = this.ck.an;
-            this.ch.an = this.cl.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;
+        bq() {
+            super.bq();
+            this.cm.an = this.co.an;
+            this.cp.an = this.ct.an;
+            this.cq.an = this.cu.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;
         }
-        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.u(this.cm);
+                    a.v(this.cp);
+                    a.v(this.cq);
                 }
                 else {
-                    a.u(this.cf);
-                    a.v(this.ck);
-                    a.v(this.cl);
+                    a.u(this.co);
+                    a.v(this.ct);
+                    a.v(this.cu);
                 }
             }
         }
-        aq(a) {
-            super.aq(a);
-            this.f.bc.exportPolygonData(a, this.cf, "fill", ["Fill"]);
-            this.f.bc.exportPolylineData(a, this.ck, "bottom", ["Lower", "Main"]);
-            this.f.bc.exportPolylineData(a, this.cl, "top", ["Upper"]);
+        ax(a) {
+            super.ax(a);
+            this.f.bc.exportPolygonData(a, this.co, "fill", ["Fill"]);
+            this.f.bc.exportPolylineData(a, this.ct, "bottom", ["Lower", "Main"]);
+            this.f.bc.exportPolylineData(a, this.cu, "top", ["Upper"]);
         }
     }
     PriceChannelOverlayView.$t = /*@__PURE__*/ markType(PriceChannelOverlayView, 'PriceChannelOverlayView', FinancialSeriesView.$);