igniteui-webcomponents-charts 4.3.1 → 4.3.3-beta.0

package/esm2015/lib/OrdinalTimeXAxis.js

@@ -26,32 +26,32 @@ import { timeSpanFromMilliseconds, timeSpanTotalMilliseconds } from "igniteui-we
  */
 export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
     class OrdinalTimeXAxis extends CategoryXAxis {
-        ek(a, b, c) {
-            return this.ei(a, new ScalerParams(0, b, c, this.cg, this.j7()));
+        el(a, b, c) {
+            return this.ej(a, new ScalerParams(0, b, c, this.ch, this.j8()));
         }
-        ej(a, b, c) {
-            return this.ei(a, b);
+        ek(a, b, c) {
+            return this.ej(a, b);
         }
-        ei(a, b) {
+        ej(a, b) {
             if (!b.c.isEmpty) {
-                let c = this.n1(a, NumericScaler.ac, b.c);
+                let c = this.n2(a, NumericScaler.ac, b.c);
                 c = (c - b.d.left) / b.d.width;
                 c = b.d.left + b.d.width * (c - b.e.left) / b.e.width;
                 return c;
             }
-            return this.n1(a, b.e, b.d);
+            return this.n2(a, b.e, b.d);
         }
-        n1(a, b, c) {
-            let d = this.mu;
-            let e = this.mv;
-            let f = this.mu - this.mv;
+        n2(a, b, c) {
+            let d = this.mv;
+            let e = this.mw;
+            let f = this.mv - this.mw;
             let g = f >= 1 ? (a - e) / (d - e) : f == 0 ? 0.5 : NaN;
-            if (this.ch) {
+            if (this.ci) {
                 g = 1 - g;
             }
             return c.left + c.width * (g - b.left) / b.width;
         }
-        hl(a, b, c, d, e) {
+        hm(a, b, c, d, e) {
             let f;
             let g = e.e;
             let h = e.d;
@@ -66,10 +66,10 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
             let q = h.width;
             let r = 0;
             let s = 1;
-            let t = this.mu;
-            let u = this.mv;
-            let v = this.mu - this.mv;
-            let w = this.mf(a);
+            let t = this.mv;
+            let u = this.mw;
+            let v = this.mv - this.mw;
+            let w = this.mg(a);
             let x = w != null;
             for (let y = 0; y < b.count; y++) {
                 let z = b.item(y);
@@ -96,120 +96,126 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
                 }
             }
         }
-        hm(a, b, c, d) {
+        hn(a, b, c, d) {
             for (let e = b; e < c; e++) {
-                a.item(e, this.ei(a.item(e), d));
+                a.item(e, this.ej(a.item(e), d));
             }
         }
-        en(a, b, c) {
-            return this.el(a, new ScalerParams(0, b, this.kc, this.cg, this.j7()));
+        eo(a, b, c) {
+            return this.em(a, new ScalerParams(0, b, this.kd, this.ch, this.j8()));
         }
         getUnscaledValue3(a, b, c, d) {
-            return this.el(a, new ScalerParams(0, b, this.kc, this.cg, this.j7()));
+            return this.em(a, new ScalerParams(0, b, this.kd, this.ch, this.j8()));
         }
-        el(a, b) {
+        em(a, b) {
             if (!b.c.isEmpty) {
                 let c = b.e.left + b.e.width * (a - b.d.left) / b.d.width;
                 c = (c * b.d.width) + b.d.left;
-                c = this.n2(c, NumericScaler.ac, b.c);
+                c = this.n3(c, NumericScaler.ac, b.c);
                 return c;
             }
-            return this.n2(a, b.e, b.d);
+            return this.n3(a, b.e, b.d);
         }
-        n2(a, b, c) {
+        n3(a, b, c) {
             let d = b.left + (a - c.left) * b.width / c.width;
-            if (this.ch) {
+            if (this.ci) {
                 d = 1 - d;
             }
-            return this.mv + d * (this.mu - this.mv);
+            return this.mw + d * (this.mv - this.mw);
         }
-        em(a, b, c) {
-            return this.el(a, b);
+        en(a, b, c) {
+            return this.em(a, b);
         }
-        hn(a, b, c, d) {
+        ho(a, b, c, d) {
             for (let e = b; e < c; e++) {
-                a.item(e, this.el(a.item(e), d));
+                a.item(e, this.em(a.item(e), d));
             }
         }
         constructor() {
             super();
-            this.no = dateMaxValue();
-            this.nn = dateMinValue();
-            this.nu = dateMaxValue();
-            this.nt = dateMinValue();
-            this.nq = dateMaxValue();
-            this.np = dateMinValue();
-            this.n4 = null;
-            this.n3 = null;
-            this.nj = 0;
-            this.nl = null;
-            this.nh = null;
-            this.od = 0;
-            this.ns = dateMinValue();
+            this.np = dateMaxValue();
+            this.no = dateMinValue();
+            this.nv = dateMaxValue();
+            this.nu = dateMinValue();
             this.nr = dateMaxValue();
+            this.nq = dateMinValue();
+            this.n5 = null;
+            this.n4 = null;
+            this.nk = 0;
+            this.nm = null;
+            this.ni = null;
+            this.oe = 0;
+            this.nt = dateMinValue();
+            this.ns = dateMaxValue();
             this.visibleRangeChanged = null;
             FastItemDateTimeColumn.o();
-            this.nh = new TimeAxisLabelFormatCollection();
-            let a = this.ni;
-            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.of));
-            this.mv = 0;
+            this.ni = new TimeAxisLabelFormatCollection();
+            let a = this.nj;
+            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.og));
+            this.mw = 0;
         }
-        hv(a, b, c, d) {
-            super.hv(a, b, c, d);
+        hw(a, b, c, d) {
+            super.hw(a, b, c, d);
             switch (b) {
                 case "FastItemsSource":
                     let e = typeCast(IFastItemsSource_$type, c);
                     if (e != null) {
-                        e.deregisterColumn(this.nm);
-                        this.nm = null;
+                        e.deregisterColumn(this.nn);
+                        this.nn = null;
                     }
-                    if (this.kq != null) {
-                        this.nm = TimeAxisBase.mi(this.dateTimeMemberPath, this);
+                    if (this.kr != null) {
+                        this.nn = TimeAxisBase.mj(this.dateTimeMemberPath, this);
                     }
                     break;
                 case "DateTimeMemberPath":
-                    if (this.kq != null) {
-                        this.kq.deregisterColumn(this.nm);
-                        this.nm = TimeAxisBase.mi(this.dateTimeMemberPath, this);
+                    if (this.kr != null) {
+                        this.kr.deregisterColumn(this.nn);
+                        this.nn = TimeAxisBase.mj(this.dateTimeMemberPath, this);
                     }
                     break;
                 case "DateTimeColumn":
-                    this.c0();
-                    this.od = this.oc();
+                    this.c1();
+                    this.oe = this.od();
                     break;
                 case "MinimumValue":
                 case "MaximumValue":
-                    this.c0();
-                    this.h6();
+                    this.c1();
+                    this.h7();
                     break;
                 case "LabellingMode":
-                    this.h6();
+                    this.h7();
                     break;
             }
         }
         get actualMinimumValue() {
-            return this.no;
+            return this.np;
         }
         set actualMinimumValue(a) {
-            this.no = a;
+            this.np = a;
         }
         get actualMaximumValue() {
-            return this.nn;
+            return this.no;
         }
         set actualMaximumValue(a) {
-            this.nn = a;
+            this.no = a;
         }
         get visibleMinimum() {
-            return this.nu;
+            return this.nv;
         }
         set visibleMinimum(a) {
-            this.nu = a;
+            this.nv = a;
         }
         get visibleMaximum() {
-            return this.nt;
+            return this.nu;
         }
         set visibleMaximum(a) {
-            this.nt = a;
+            this.nu = a;
+        }
+        get nz() {
+            return this.nr;
+        }
+        set nz(a) {
+            this.nr = a;
         }
         get ny() {
             return this.nq;
@@ -217,66 +223,60 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
         set ny(a) {
             this.nq = a;
         }
-        get nx() {
-            return this.np;
-        }
-        set nx(a) {
-            this.np = a;
-        }
-        og() {
-            if (this.nm == null || this.nm.count == 0 || this.nm.count < this.mv - 1) {
+        oh() {
+            if (this.nn == null || this.nn.count == 0 || this.nn.count < this.mw - 1) {
                 this.actualMinimumValue = dateMinValue();
                 this.actualMaximumValue = dateMaxValue();
                 return;
             }
-            let a = Math.max(0, Math.min(this.mv, this.nm.count - 1));
-            let b = Math.max(0, Math.min(this.mu, this.nm.count - 1));
-            let c = +(this.actualMinimumValue) != +(this.nm.item(a)) || +(this.actualMaximumValue) != +(this.nm.item(b));
+            let a = Math.max(0, Math.min(this.mw, this.nn.count - 1));
+            let b = Math.max(0, Math.min(this.mv, this.nn.count - 1));
+            let c = +(this.actualMinimumValue) != +(this.nn.item(a)) || +(this.actualMaximumValue) != +(this.nn.item(b));
             if (c) {
                 let d = this.actualMinimumValue;
                 let e = this.actualMaximumValue;
-                this.actualMinimumValue = this.nm.item(a);
-                this.actualMaximumValue = this.nm.item(b);
-                this.oh();
+                this.actualMinimumValue = this.nn.item(a);
+                this.actualMaximumValue = this.nn.item(b);
+                this.oi();
             }
         }
-        oh() {
-            if (this.nm == null || this.nm.count == 0 || this.bh == null) {
+        oi() {
+            if (this.nn == null || this.nn.count == 0 || this.bi == null) {
                 let a = +(this.visibleMinimum) != +(this.actualMinimumValue) || +(this.visibleMaximum) != +(this.actualMaximumValue);
                 this.visibleMinimum = this.actualMinimumValue;
                 this.visibleMaximum = this.actualMaximumValue;
-                this.ny = this.visibleMinimum;
-                this.nx = this.visibleMaximum;
+                this.nz = this.visibleMinimum;
+                this.ny = this.visibleMaximum;
                 if (a && this.visibleRangeChanged != null) {
                     this.visibleRangeChanged(this, EventArgs.empty);
                 }
                 return;
             }
-            let b = this.j6();
-            let c = new ScalerParams(1, this.bh.tq, this.bh.tp, this.cg);
-            c.c = this.j7();
-            let d = this.el(b.left, c);
-            let e = this.el(b.right, c);
+            let b = this.j7();
+            let c = new ScalerParams(1, this.bi.tz, this.bi.ty, this.ch);
+            c.c = this.j8();
+            let d = this.em(b.left, c);
+            let e = this.em(b.right, c);
             let f = truncate(Math.floor(d));
             let g = truncate(Math.ceil(e));
-            let h = f >= 0 && f < this.nm.count ? this.nm.item(f) : this.actualMinimumValue;
-            let i = g >= 0 && g < this.nm.count ? this.nm.item(g) : this.actualMaximumValue;
+            let h = f >= 0 && f < this.nn.count ? this.nn.item(f) : this.actualMinimumValue;
+            let i = g >= 0 && g < this.nn.count ? this.nn.item(g) : this.actualMaximumValue;
             let j = h;
             let k = i;
             if (d > f) {
                 let l = f + 1;
-                let m = l >= 0 && l < this.nm.count ? this.nm.item(l) : i;
+                let m = l >= 0 && l < this.nn.count ? this.nn.item(l) : i;
                 let n = dateAdd(+h, +(timeSpanFromMilliseconds(timeSpanTotalMilliseconds((+m - +h)) * (d - f))));
                 j = n;
             }
             if (e < g) {
                 let o = g - 1;
-                let p = o >= 0 && o < this.nm.count ? this.nm.item(o) : h;
+                let p = o >= 0 && o < this.nn.count ? this.nn.item(o) : h;
                 let q = dateSubtract(+i, +(timeSpanFromMilliseconds(timeSpanTotalMilliseconds((+i - +p)) * (g - e))));
                 k = q;
             }
-            this.ny = j;
-            this.nx = k;
+            this.nz = j;
+            this.ny = k;
             let r = +(this.visibleMinimum) != +h || +(this.visibleMaximum) != +i;
             this.visibleMinimum = h;
             this.visibleMaximum = i;
@@ -284,101 +284,101 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
                 this.visibleRangeChanged(this, EventArgs.empty);
             }
         }
-        h8(a) {
-            let b = TimeXAxis.ol(this.actualMinimumValue, false, this.actualMinimumValue, this.nk, this.ob, this.ni, this.fj);
-            if (b != this.n4 && this.c3) {
-                this.ic();
+        h9(a) {
+            let b = TimeXAxis.om(this.actualMinimumValue, false, this.actualMinimumValue, this.nl, this.oc, this.nj, this.fk);
+            if (b != this.n5 && this.c4) {
+                this.id();
             }
-            this.n4 = b;
-            super.h8(a);
+            this.n5 = b;
+            super.h9(a);
         }
         get dateTimeMemberPath() {
-            return this.n3;
+            return this.n4;
         }
         set dateTimeMemberPath(a) {
             let b = this.dateTimeMemberPath;
             if (a != b) {
-                this.n3 = a;
-                this.h1("DateTimeMemberPath", b, this.dateTimeMemberPath);
+                this.n4 = a;
+                this.h2("DateTimeMemberPath", b, this.dateTimeMemberPath);
             }
         }
-        get nk() {
-            return this.nj;
+        get nl() {
+            return this.nk;
         }
-        set nk(a) {
-            let b = this.nk;
+        set nl(a) {
+            let b = this.nl;
             if (a != b) {
-                this.nj = a;
-                this.h1("LabellingMode", enumGetBox(TimeAxisLabellingMode_$type, b), enumGetBox(TimeAxisLabellingMode_$type, this.nk));
+                this.nk = a;
+                this.h2("LabellingMode", enumGetBox(TimeAxisLabellingMode_$type, b), enumGetBox(TimeAxisLabellingMode_$type, this.nl));
             }
         }
-        get_cj() {
+        get_ck() {
             return true;
         }
-        get nm() {
-            return this.nl;
+        get nn() {
+            return this.nm;
         }
-        set nm(a) {
-            if (this.nl != a) {
-                let b = this.nl;
-                this.nl = a;
-                this.h1("DateTimeColumn", b, this.nl);
+        set nn(a) {
+            if (this.nm != a) {
+                let b = this.nm;
+                this.nm = a;
+                this.h2("DateTimeColumn", b, this.nm);
             }
         }
-        ip(a, b) {
-            super.ip(a, b);
-            this.oh();
+        iq(a, b) {
+            super.iq(a, b);
+            this.oi();
         }
         getWindowRectForSelection(a, b) {
-            if (this.nm == null) {
+            if (this.nn == null) {
                 return Rect.empty;
             }
             let c = a > b;
             let d = c ? b : a;
             let e = c ? a : b;
             let f = -1;
-            while (++f < this.nm.count && this.nm.item(f) < d) {
+            while (++f < this.nn.count && this.nn.item(f) < d) {
             }
-            let g = this.nm.count;
-            while (--g >= 0 && this.nm.item(g) > e) {
+            let g = this.nn.count;
+            while (--g >= 0 && this.nn.item(g) > e) {
             }
-            let h = new ScalerParams(0, new Rect(0, 0, 0, 1, 1), new Rect(0, 0, 0, 1, 1), this.cg, this.bh.te);
-            let i = this.ei(f, h);
-            let j = this.ei(g + 1, h);
+            let h = new ScalerParams(0, new Rect(0, 0, 0, 1, 1), new Rect(0, 0, 0, 1, 1), this.ch, this.bi.tn);
+            let i = this.ej(f, h);
+            let j = this.ej(g + 1, h);
             return new Rect(0, i, NaN, Math.max(0, j - i), NaN);
         }
-        get ni() {
-            return this.nh;
+        get nj() {
+            return this.ni;
         }
-        of(a, b) {
-            this.h7(false);
+        og(a, b) {
+            this.h8(false);
         }
-        hx(a) {
-            super.hx(a);
+        hy(a) {
+            super.hy(a);
             this.dateTimeMemberPath = a;
         }
-        fy(a) {
-            if (this.at != null) {
-                return this.at(a);
+        fz(a) {
+            if (this.au != null) {
+                return this.au(a);
             }
-            if (this.ah != null) {
-                return this.ah.i(a);
+            if (this.ai != null) {
+                return this.ai.i(a);
             }
             if (!(typeCast(Date_$type, a) !== null)) {
-                return super.fy(a);
+                return super.fz(a);
             }
             let b = dateMinValue();
             let c = false;
-            if (this.mw != null) {
-                if (typeCast(Date_$type, this.mw) !== null) {
-                    b = this.mw;
+            if (this.mx != null) {
+                if (typeCast(Date_$type, this.mx) !== null) {
+                    b = this.mx;
                     c = true;
                 }
             }
-            let d = TimeXAxis.og(a, c, b, this.nk, this.ob, this.ni, this.fj);
-            return d == null ? super.fy(a) : d;
+            let d = TimeXAxis.oh(a, c, b, this.nl, this.oc, this.nj, this.fk);
+            return d == null ? super.fz(a) : d;
         }
-        gc(a) {
+        gd(a) {
             let b = 0;
             if (this.categoryMode == 0) {
                 b = truncate(Math.round(a));
@@ -386,11 +386,11 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
             else {
                 b = truncate(Math.floor(a));
             }
-            if (b < 0 || b > this.lf - 1) {
-                return super.gc(a);
+            if (b < 0 || b > this.lg - 1) {
+                return super.gd(a);
             }
-            let c = this.nm.item(b);
-            let d = this.fy(c);
+            let c = this.nn.item(b);
+            let d = this.fz(c);
             if (d == null) {
                 return null;
             }
@@ -401,129 +401,132 @@ export let OrdinalTimeXAxis = /*@__PURE__*/ (() => {
             if (b < 0) {
                 b = 0;
             }
-            if (b > this.lf - 1) {
-                b = this.lf - 1;
+            if (b > this.lg - 1) {
+                b = this.lg - 1;
             }
-            if (this.nm == null) {
+            if (this.nn == null) {
                 return dateMinValue();
             }
-            let c = this.nm.item(b);
+            let c = this.nn.item(b);
             return c;
         }
-        get oe() {
+        get of() {
             return +(this.visibleMaximum) - +(this.visibleMinimum);
         }
-        get ob() {
-            return +(this.nx) - +(this.ny);
+        get oc() {
+            return +(this.ny) - +(this.nz);
         }
-        mh() {
-            return this.nm;
+        mi() {
+            return this.nn;
         }
-        io(a, b) {
-            super.io(a, b);
-            this.oh();
+        ip(a, b) {
+            super.ip(a, b);
+            this.oi();
         }
-        mo(a, b) {
+        mp(a, b) {
             let c = this.categoryMode == 0 ? 0 : 0.5;
-            return super.mo(a + c, b);
+            return super.mp(a + c, b);
         }
-        mn(a, b, c, d) {
+        mo(a, b, c, d) {
             return b;
         }
-        oc() {
-            if (this.nm == null || this.nm.count < 2) {
+        od() {
+            if (this.nn == null || this.nn.count < 2) {
                 return (0);
             }
-            return TimeXAxis.or((a) => this.nm.item(a), this.nm.count);
+            return TimeXAxis.os((a) => this.nn.item(a), this.nn.count);
         }
         itemLabelFormat() {
-            return TimeXAxis.on(this.od);
+            return TimeXAxis.oo(this.oe);
         }
         get minimumValue() {
-            return this.ns;
+            return this.nt;
         }
         set minimumValue(a) {
             let b = this.minimumValue;
             if (+a != +b) {
-                this.ns = a;
-                this.hv(this, "MinimumValue", b, this.minimumValue);
+                this.nt = a;
+                this.hw(this, "MinimumValue", b, this.minimumValue);
             }
         }
         get maximumValue() {
-            return this.nr;
+            return this.ns;
         }
         set maximumValue(a) {
             let b = this.maximumValue;
             if (+a != +b) {
-                this.nr = a;
-                this.hv(this, "MaximumValue", b, this.maximumValue);
+                this.ns = a;
+                this.hw(this, "MaximumValue", b, this.maximumValue);
             }
         }
-        c2() {
+        c3() {
             if (+(this.minimumValue) == +(dateMaxValue()) || +(this.maximumValue) == +(dateMinValue())) {
-                return super.c2();
+                return super.c3();
             }
-            if (this.cp && this.c3) {
-                this.bb = this.ba();
+            if (this.cq && this.c4) {
+                this.bc = this.bb();
             }
-            if (this.kq == null || this.nm == null) {
+            if (this.kr == null || this.nn == null) {
                 return false;
             }
-            let a = this.mv;
+            let a = this.mw;
             if (+(this.minimumValue) != +(dateMinValue())) {
                 let b = -1;
-                while (b++ <= this.nm.count) {
-                    if (this.nm.item(b) >= this.minimumValue) {
+                while (b++ <= this.nn.count) {
+                    if (this.nn.item(b) >= this.minimumValue) {
                         break;
                     }
                 }
                 a = b;
             }
-            let c = this.categoryMode == 0 ? this.kq.count - 1 : this.kq.count;
+            let c = this.categoryMode == 0 ? this.kr.count - 1 : this.kr.count;
             if (+(this.maximumValue) != +(dateMaxValue())) {
-                let d = this.kq.count;
+                let d = this.kr.count;
                 while (d-- > 0) {
-                    if (this.nm.item(d) <= this.maximumValue) {
+                    if (this.nn.item(d) <= this.maximumValue) {
                         break;
                     }
                 }
                 c = d;
             }
-            if (a != this.mv || c != this.mu) {
-                let e = new AxisRangeChangedEventArgs(0, this.mv, a, this.mu, c);
-                this.mv = a;
-                this.mu = c;
-                this.h2(e);
-                this.og();
-                this.ls();
+            if (a != this.mw || c != this.mv) {
+                let e = new AxisRangeChangedEventArgs(0, this.mw, a, this.mv, c);
+                this.mw = a;
+                this.mv = c;
+                this.h3(e);
+                this.oh();
+                this.lt();
                 return true;
             }
             return false;
         }
-        l1(a) {
-            super.l1(a);
-            this.c1(true);
+        l2(a) {
+            super.l2(a);
+            this.c2(true);
         }
         get isVertical() {
-            return this.co;
-        }
-        j$c(a, b) {
-            return this.el.apply(this, arguments);
+            return this.cp;
         }
-        j$b(a, b) {
-            return this.ei.apply(this, arguments);
+        j$d(a, b) {
+            return this.em.apply(this, arguments);
         }
-        j$d(a, b, c, d, e) {
-            this.hl.apply(this, arguments);
+        j$c(a, b) {
+            return this.ej.apply(this, arguments);
         }
-        j$e(a, b, c, d) {
+        j$e(a, b, c, d, e) {
             this.hm.apply(this, arguments);
         }
         j$f(a, b, c, d) {
             this.hn.apply(this, arguments);
         }
-        get j$a() {
-            return this.cg;
+        j$g(a, b, c, d) {
+            this.ho.apply(this, arguments);
+        }
+        get j$b() {
+            return this.ch;
+        }
+        j$a() {
+            return this.ag.apply(this, arguments);
         }
     }
     OrdinalTimeXAxis.$t = /*@__PURE__*/ markType(OrdinalTimeXAxis, 'OrdinalTimeXAxis', CategoryXAxis.$, [ITimeRangeSelectorAxis_$type, IOrdinalAxis_$type]);