igniteui-webcomponents-charts 6.3.1 → 7.0.0

package/esm2015/lib/ProportionalCategoryAngleAxis.js

@@ -21,68 +21,68 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
     class ProportionalCategoryAngleAxis extends CategoryAngleAxis {
         constructor() {
             super(...arguments);
-            this.s1 = new OthersCategoryContext();
-            this.tk = null;
-            this.tn = null;
-            this.s4 = null;
-            this.s8 = true;
-            this.te = NaN;
-            this.tc = new List$1(Number_$type, 0);
-            this.tb = new List$1(Number_$type, 0);
-            this.ta = new List$1(Boolean_$type, 0);
-            this.s7 = false;
-            this.td = NaN;
-            this.ti = -1;
-        }
-        get_s2() {
-            return this.s1;
-        }
-        get s2() {
-            return this.get_s2();
-        }
-        tj() {
-            if (this.tk == null) {
-                this.tk = OthersCategoryContext.b(this.s1, this.b7);
-            }
-            return this.tk;
-        }
-        tm(a) {
+            this.s3 = new OthersCategoryContext();
+            this.tm = null;
+            this.tp = null;
+            this.s6 = null;
+            this.ta = true;
+            this.tg = NaN;
+            this.te = new List$1(Number_$type, 0);
+            this.td = new List$1(Number_$type, 0);
+            this.tc = new List$1(Boolean_$type, 0);
+            this.s9 = false;
+            this.tf = NaN;
+            this.tk = -1;
+        }
+        get_s4() {
+            return this.s3;
+        }
+        get s4() {
+            return this.get_s4();
+        }
+        tl() {
+            if (this.tm == null) {
+                this.tm = OthersCategoryContext.b(this.s3, this.b7);
+            }
+            return this.tm;
+        }
+        to(a) {
             if (a) {
-                return this.tj();
+                return this.tl();
             }
             else {
-                return this.s2;
+                return this.s4;
             }
         }
-        s9(a) {
-            return a == this.s2 || a == this.tk;
+        tb(a) {
+            return a == this.s4 || a == this.tm;
         }
-        get tu() {
-            return this.tn;
+        get tw() {
+            return this.tp;
         }
-        set tu(a) {
-            let b = this.tu;
+        set tw(a) {
+            let b = this.tw;
             if (a != b) {
-                this.tn = a;
-                this.ls("ValueMemberPath", b, this.tu);
+                this.tp = a;
+                this.lu("ValueMemberPath", b, this.tw);
             }
         }
-        hu(a, b) {
-            let c = this.jn(b);
+        hw(a, b) {
+            let c = this.jp(b);
             if (this.hasOthersCategory && c == "Label") {
                 if (typeCast(OthersCategoryContext.$, a) !== null) {
-                    return this.ts();
+                    return this.tu();
                 }
                 else {
-                    let int_ = this.tl(a);
+                    let int_ = this.tn(a);
                     if (int_ != null && typeCast(OthersCategoryContext.$, int_) !== null) {
-                        return this.ts();
+                        return this.tu();
                     }
                 }
             }
-            return super.hu(a, b);
+            return super.hw(a, b);
         }
-        tl(a) {
+        tn(a) {
             if (a == null) {
                 return null;
             }
@@ -90,91 +90,91 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             return null;
         }
         get normalizationMayContainUnknowns() {
-            return this.s6 == null || this.s6.mayContainUnknowns;
+            return this.s8 == null || this.s8.mayContainUnknowns;
         }
-        get s6() {
-            return this.s4;
+        get s8() {
+            return this.s6;
         }
-        set s6(a) {
-            if (this.s4 != a) {
-                let b = this.s4;
-                this.s4 = a;
-                this.ls("ValueColumn", b, this.s4);
+        set s8(a) {
+            if (this.s6 != a) {
+                let b = this.s6;
+                this.s6 = a;
+                this.lu("ValueColumn", b, this.s6);
             }
         }
-        s5(a) {
+        s7(a) {
             if (a == null) {
-                return this.pm.registerColumn(null, null, false);
+                return this.po.registerColumn(null, null, false);
             }
             let b = null;
             let c = SeriesViewer.de(a, this.coercionMethods);
             b = c.a;
-            return this.pm.registerColumn(a, b, this.expectFunctions);
+            return this.po.registerColumn(a, b, this.expectFunctions);
         }
-        la(a, b, c, d) {
-            super.la(a, b, c, d);
+        lc(a, b, c, d) {
+            super.lc(a, b, c, d);
             switch (b) {
                 case "ValueMemberPath":
-                    if (this.pm != null) {
-                        this.pm.deregisterColumn(this.s6);
-                        this.s6 = this.s5(this.tu);
+                    if (this.po != null) {
+                        this.po.deregisterColumn(this.s8);
+                        this.s8 = this.s7(this.tw);
                     }
                     break;
                 case "ValueColumn":
-                    this.s8 = true;
-                    this.s7 = false;
-                    this.lx();
+                    this.ta = true;
+                    this.s9 = false;
+                    this.lz();
                     break;
                 case ProportionalCategoryAngleAxis.$$p[0]:
                 case ProportionalCategoryAngleAxis.$$p[1]:
                 case ProportionalCategoryAngleAxis.$$p[2]:
-                    this.s8 = true;
-                    this.s7 = false;
-                    this.lx();
-                    for (let e of fromEnum(this.eo())) {
-                        e.r8(true);
+                    this.ta = true;
+                    this.s9 = false;
+                    this.lz();
+                    for (let e of fromEnum(this.ep())) {
+                        e.r9(true);
                     }
                     break;
                 case "FastItemsSource":
-                    this.s8 = true;
-                    this.s7 = false;
+                    this.ta = true;
+                    this.s9 = false;
                     let f = typeCast(IFastItemsSource_$type, c);
                     if (f != null) {
-                        f.deregisterColumn(this.s6);
-                        this.s6 = null;
+                        f.deregisterColumn(this.s8);
+                        this.s8 = null;
                     }
                     let g = typeCast(IFastItemsSource_$type, d);
                     if (g != null) {
-                        this.s6 = this.s5(this.tu);
+                        this.s8 = this.s7(this.tw);
                     }
-                    this.lx();
+                    this.lz();
                     break;
             }
         }
-        qy(a) {
-            super.qy(a);
-            this.s8 = true;
-            this.s7 = false;
+        q0(a) {
+            super.q0(a);
+            this.ta = true;
+            this.s9 = false;
         }
         getScaledAngle(a) {
-            this.tw();
+            this.ty();
             if (isNaN_(a) || isInfinity(a)) {
                 return NaN;
             }
-            let b = this.qa;
+            let b = this.qc;
             let c = a % b;
             if (c < 0) {
                 c = b + c;
             }
             let d = truncate(Math.floor(c));
-            let e = this.tb._inner[d];
+            let e = this.td._inner[d];
             let f = c - d;
             let g = 0;
-            if (isNaN_(this.tc._inner[d])) {
+            if (isNaN_(this.te._inner[d])) {
                 g = 0 * f;
             }
             else {
-                g = this.tc._inner[d] * f;
+                g = this.te._inner[d] * f;
             }
             let h = e + g;
             if (this.dp) {
@@ -187,122 +187,122 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             if (a < 0) {
                 i -= (2 * Math.PI) * Math.abs(Math.floor(a / b));
             }
-            return i + this.ru;
+            return i + this.rw;
         }
         get_ds() {
             return true;
         }
-        r1(a, b, c, d, e) {
+        r3(a, b, c, d, e) {
             let f = 0.5;
-            if (this.qc > 1) {
-                let g = this.p6(c, d, e);
+            if (this.qe > 1) {
+                let g = this.p8(c, d, e);
                 let h = 0;
-                if (!isNaN_(this.p5)) {
-                    h = Math.min(this.p5, 1);
+                if (!isNaN_(this.p7)) {
+                    h = Math.min(this.p7, 1);
                 }
                 let i = 1 - 0.5 * g;
-                let j = i / (this.qc - (this.qc - 1) * h);
-                let k = (i - j) / (this.qc - 1);
+                let j = i / (this.qe - (this.qe - 1) * h);
+                let k = (i - j) / (this.qe - 1);
                 f = 0.25 * g + 0.5 * j + a * k;
             }
-            return this.tf(a, c, d, e) * f;
+            return this.th(a, c, d, e) * f;
         }
-        tf(a, b, c, d) {
-            if (a < 0 || a > this.qb - 1) {
+        th(a, b, c, d) {
+            if (a < 0 || a > this.qd - 1) {
                 return this.getCategorySize(b, c, d);
             }
-            this.tw();
-            let e = this.tc._inner[a];
+            this.ty();
+            let e = this.te._inner[a];
             if (isNaN_(e)) {
                 return NaN;
             }
-            let f = Math.PI * 2 * this.tc._inner[a];
+            let f = Math.PI * 2 * this.te._inner[a];
             return f;
         }
-        r2(a, b, c, d) {
-            this.tw();
-            let e = this.p6(b, c, d);
+        r4(a, b, c, d) {
+            this.ty();
+            let e = this.p8(b, c, d);
             let f = 0;
-            if (!isNaN_(this.p5)) {
-                f = Math.min(this.p5, 1);
+            if (!isNaN_(this.p7)) {
+                f = Math.min(this.p7, 1);
             }
             let g = 1 - 0.5 * e;
-            if (a < 0 || a > this.qb - 1) {
-                return this.pz(b, c, d);
+            if (a < 0 || a > this.qd - 1) {
+                return this.p1(b, c, d);
             }
-            let h = this.tc._inner[a];
+            let h = this.te._inner[a];
             if (isNaN_(h)) {
                 return NaN;
             }
             let i = Math.PI * 2 * h;
-            return i * g / (this.qc - (this.qc - 1) * f);
+            return i * g / (this.qe - (this.qe - 1) * f);
         }
-        qd() {
-            if (this.pm == null) {
+        qf() {
+            if (this.po == null) {
                 return 0;
             }
-            this.tw();
-            if (this.s7) {
-                return super.qd() + 1;
+            this.ty();
+            if (this.s9) {
+                return super.qf() + 1;
             }
-            return super.qd();
+            return super.qf();
         }
-        rp(a) {
-            return this.hasOthersCategory && a == this.qb - 1;
+        rr(a) {
+            return this.hasOthersCategory && a == this.qd - 1;
         }
-        sj() {
-            return this.ts();
+        sl() {
+            return this.tu();
         }
-        rq(a) {
-            if (a >= 0 && a < this.qb) {
-                if (isNaN_(this.tc._inner[a])) {
+        rs(a) {
+            if (a >= 0 && a < this.qd) {
+                if (isNaN_(this.te._inner[a])) {
                     return true;
                 }
             }
-            return super.rq(a);
+            return super.rs(a);
         }
-        lz(a) {
-            this.tw();
-            super.lz(a);
+        l1(a) {
+            this.ty();
+            super.l1(a);
         }
         ensureSum() {
-            this.tw();
-        }
-        tw() {
-            if (this.s8) {
-                this.s8 = false;
-                this.s7 = false;
-                this.qb = this.qd();
-                this.td = NaN;
-                this.ti = -1;
-                if (this.s6 != null && this.s6.count > 0) {
-                    this.te = NaN;
+            this.ty();
+        }
+        ty() {
+            if (this.ta) {
+                this.ta = false;
+                this.s9 = false;
+                this.qd = this.qf();
+                this.tf = NaN;
+                this.tk = -1;
+                if (this.s8 != null && this.s8.count > 0) {
+                    this.tg = NaN;
                     let a = true;
-                    for (let b = 0; b < this.s6.count; b++) {
-                        let c = this.s6.item(b);
+                    for (let b = 0; b < this.s8.count; b++) {
+                        let c = this.s8.item(b);
                         if (isNaN_(c) || isInfinity(c) || c < 0) {
                             continue;
                         }
                         if (a) {
                             a = false;
-                            this.te = 0;
+                            this.tg = 0;
                         }
-                        this.te += c;
+                        this.tg += c;
                     }
                     let d = 0;
+                    this.te.clear();
+                    this.td.clear();
                     this.tc.clear();
-                    this.tb.clear();
-                    this.ta.clear();
                     let e = new List$1(Base.$, 0);
-                    this.s2.items = null;
+                    this.s4.items = null;
                     let f = 0;
-                    for (let g = 0; g < this.s6.count; g++) {
+                    for (let g = 0; g < this.s8.count; g++) {
                         let h = 0;
-                        if (isNaN_(this.te)) {
-                            h = 1 / this.qb;
+                        if (isNaN_(this.tg)) {
+                            h = 1 / this.qd;
                         }
                         else {
-                            let i = this.s6.item(g);
+                            let i = this.s8.item(g);
                             if (isNaN_(i) || isInfinity(i) || i < 0) {
                                 h = 0;
                             }
@@ -311,90 +311,90 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
                             }
                         }
                         let j = false;
-                        if (this.s3 == 0) {
-                            if (h < this.th) {
+                        if (this.s5 == 0) {
+                            if (h < this.tj) {
                                 j = true;
                             }
                         }
                         else {
-                            if ((h / this.te) * 100 < this.th) {
+                            if ((h / this.tg) * 100 < this.tj) {
                                 j = true;
                             }
                         }
                         if (j) {
-                            e.add1(this.pm.item(g));
-                            this.tb.add(d);
-                            this.tc.add(NaN);
-                            this.ta.add(true);
+                            e.add1(this.po.item(g));
+                            this.td.add(d);
+                            this.te.add(NaN);
+                            this.tc.add(true);
                             f += h;
                         }
                         else {
-                            this.tb.add(d);
-                            this.tc.add(h / this.te);
-                            this.ta.add(false);
-                            d += (h / this.te);
+                            this.td.add(d);
+                            this.te.add(h / this.tg);
+                            this.tc.add(false);
+                            d += (h / this.tg);
                         }
                     }
                     if (f > 0) {
-                        this.s7 = true;
-                        this.tb.add(d);
-                        this.tc.add(f / this.te);
-                        this.ta.add(false);
-                        this.td = f;
-                        this.ti = this.tb.count - 1;
-                        this.s2.items = e.toArray();
+                        this.s9 = true;
+                        this.td.add(d);
+                        this.te.add(f / this.tg);
+                        this.tc.add(false);
+                        this.tf = f;
+                        this.tk = this.td.count - 1;
+                        this.s4.items = e.toArray();
                     }
                 }
                 else {
-                    if (this.qb > 0) {
-                        this.tc.clear();
-                        this.tb.clear();
+                    if (this.qd > 0) {
+                        this.te.clear();
+                        this.td.clear();
                         let k = 0;
-                        for (let l = 0; l < this.qb; l++) {
-                            this.tb.add(k);
-                            this.tc.add(1 / this.qb);
-                            k += (1 / this.qb);
+                        for (let l = 0; l < this.qd; l++) {
+                            this.td.add(k);
+                            this.te.add(1 / this.qd);
+                            k += (1 / this.qd);
                         }
                     }
                 }
-                this.qb = this.qd();
+                this.qd = this.qf();
             }
         }
         get othersValue() {
-            return this.td;
+            return this.tf;
         }
         get othersIndex() {
-            return this.ti;
+            return this.tk;
         }
         get hasOthersCategory() {
-            return this.s7;
+            return this.s9;
         }
-        k1(a, b, c, d) {
+        k3(a, b, c, d) {
             for (let e = b; e < c; e++) {
-                a.item(e, this.f6(a.item(e), d));
+                a.item(e, this.f7(a.item(e), d));
             }
         }
         getUnscaledAngle(a) {
-            this.tw();
+            this.ty();
             if (isNaN_(a) || isInfinity(a)) {
                 return NaN;
             }
-            if (this.tb == null || this.tb.count == 0 || this.tc == null || this.tc.count == 0) {
+            if (this.td == null || this.td.count == 0 || this.te == null || this.te.count == 0) {
                 return NaN;
             }
             a = CoreGeometryUtil.s(a);
-            while (a < this.ru) {
+            while (a < this.rw) {
                 a += 2 * Math.PI;
             }
-            while (a > (this.ru + (2 * Math.PI))) {
+            while (a > (this.rw + (2 * Math.PI))) {
                 a -= 2 * Math.PI;
             }
-            let b = (a - this.ru) / (2 * Math.PI);
+            let b = (a - this.rw) / (2 * Math.PI);
             if (this.dn) {
                 b = 1 - b;
             }
             let c = -1;
-            c = ArrayExtension.binarySearch$11(Number_$type, this.tb, (d) => b < d ? -1 : (b > d ? 1 : 0));
+            c = ArrayExtension.binarySearch$11(Number_$type, this.td, (d) => b < d ? -1 : (b > d ? 1 : 0));
             if (c < 0) {
                 c = ~c;
                 c--;
@@ -402,11 +402,11 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             if (c < 0) {
                 c = 0;
             }
-            if (c > this.tb.count - 1) {
-                c = this.tb.count - 1;
+            if (c > this.td.count - 1) {
+                c = this.td.count - 1;
             }
-            let d = this.tb._inner[c];
-            let e = this.tc._inner[c];
+            let d = this.td._inner[c];
+            let e = this.te._inner[c];
             if (isNaN_(e)) {
                 b = c;
             }
@@ -416,12 +416,12 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             return b;
         }
         isOthersValue(a) {
-            if (a < 0 || a > this.ta.count - 1) {
+            if (a < 0 || a > this.tc.count - 1) {
                 return false;
             }
-            return this.ta._inner[a];
+            return this.tc._inner[a];
         }
-        i8(a) {
+        ja(a) {
             let b = a;
             if (this.categoryMode == 0) {
                 b = truncate(Math.round(a));
@@ -429,46 +429,46 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             else {
                 b = truncate(Math.floor(a));
             }
-            if (this.hasOthersCategory && b >= this.qb - 1) {
-                b = this.qb - 1;
-                return this.ts();
+            if (this.hasOthersCategory && b >= this.qd - 1) {
+                b = this.qd - 1;
+                return this.tu();
             }
-            return super.i8(a);
+            return super.ja(a);
         }
-        ts() {
-            if (this.to != null) {
-                return this.to;
+        tu() {
+            if (this.tq != null) {
+                return this.tq;
             }
             return "Others";
         }
         getNormalizingValueAtIndex(a, b) {
-            if (a < 0 || this.s6 == null || a > this.s6.count - 1) {
+            if (a < 0 || this.s8 == null || a > this.s8.count - 1) {
                 return b;
             }
-            return this.s6.item(a);
+            return this.s8.item(a);
         }
-        tg(a) {
-            this.tw();
-            let b = this.tc._inner[a] * 100;
+        ti(a) {
+            this.ty();
+            let b = this.te._inner[a] * 100;
             return b;
         }
         get isVertical() {
-            return this.dy;
+            return this.dz;
         }
         j$d(a, b) {
-            return this.f9.apply(this, arguments);
+            return this.ga.apply(this, arguments);
         }
         j$c(a, b) {
-            return this.f6.apply(this, arguments);
+            return this.f7.apply(this, arguments);
         }
         j$e(a, b, c, d, e) {
-            this.k0.apply(this, arguments);
+            this.k2.apply(this, arguments);
         }
         j$f(a, b, c, d) {
-            this.k1.apply(this, arguments);
+            this.k3.apply(this, arguments);
         }
         j$g(a, b, c, d) {
-            this.k2.apply(this, arguments);
+            this.k4.apply(this, arguments);
         }
         get j$b() {
             return this.dn;
@@ -477,11 +477,11 @@ let ProportionalCategoryAngleAxis = /*@__PURE__*/ (() => {
             return this.ag.apply(this, arguments);
         }
         get itemsCount() {
-            return this.qb;
+            return this.qd;
         }
     }
     ProportionalCategoryAngleAxis.$t = /*@__PURE__*/ markType(ProportionalCategoryAngleAxis, 'ProportionalCategoryAngleAxis', CategoryAngleAxis.$, [ICoalescingModerator_$type]);
-    ProportionalCategoryAngleAxis.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, ProportionalCategoryAngleAxis, 'ls', ['OthersCategoryText:to:tx', [2, null], 'OthersCategoryThreshold:th:ty', [1, 3], 'OthersCategoryType:s3:tz', [OthersCategoryType_$type, /*@__PURE__*/ enumGetBox(OthersCategoryType_$type, 1)]]);
+    ProportionalCategoryAngleAxis.$$p = /*@__PURE__*/ markDep(DependencyProperty, PropertyMetadata, ProportionalCategoryAngleAxis, 'lu', ['OthersCategoryText:tq:tz', [2, null], 'OthersCategoryThreshold:tj:t0', [1, 3], 'OthersCategoryType:s5:t1', [OthersCategoryType_$type, /*@__PURE__*/ enumGetBox(OthersCategoryType_$type, 1)]]);
     return ProportionalCategoryAngleAxis;
 })();
 export { ProportionalCategoryAngleAxis };