igniteui-webcomponents-maps 7.1.0-alpha.1 → 7.1.0-alpha.3

package/esm2015/lib/GeographicMapSeriesHost_combined.js

@@ -14,344 +14,344 @@ import { PlatformConstants } from "igniteui-webcomponents-core";
 import { isNaN_ } from "igniteui-webcomponents-core";
 let GeographicMapSeriesHost = /*@__PURE__*/ (() => {
     class GeographicMapSeriesHost extends Series {
-        qw() {
-            super.qw();
-            if (this.xm != null) {
-                this.xm.qw();
+        qx() {
+            super.qx();
+            if (this.xn != null) {
+                this.xn.qx();
             }
         }
         constructor() {
             super();
-            this.xk = null;
-            this.xm = this.xl();
+            this.xl = null;
+            this.xn = this.xm();
         }
         get_ff() {
             return true;
         }
-        k0(a, b) {
-            let c = this.np(b);
+        k1(a, b) {
+            let c = this.nq(b);
             if (c == "LatitudeMemberPath") {
                 c = "YMemberPath";
             }
             if (c == "LongitudeMemberPath") {
                 c = "XMemberPath";
             }
-            return this.xm.k0(a, c);
+            return this.xn.k1(a, c);
         }
-        mp(a) {
-            let b = this.np(a);
+        mq(a) {
+            let b = this.nq(a);
             if (b == "LatitudeMemberPath") {
                 b = "YMemberPath";
             }
             if (b == "LongitudeMemberPath") {
                 b = "XMemberPath";
             }
-            return this.xm.mp(b);
+            return this.xn.mq(b);
         }
-        get_ks() {
-            return this.la(this.xm);
+        get_kt() {
+            return this.lb(this.xn);
         }
-        set_ks(a) {
-            this.pd(this.xm, a);
+        set_kt(a) {
+            this.pe(this.xn, a);
         }
         ed(a, b, c, d, e) {
-            return this.xm.ed(a, b, c, d, e);
+            return this.xn.ed(a, b, c, d, e);
         }
         ai() {
-            return this.xm.ai();
+            return this.xn.ai();
         }
         bp() {
-            return this.xm;
+            return this.xn;
         }
-        get xm() {
-            return this.xk;
+        get xn() {
+            return this.xl;
         }
-        set xm(a) {
-            let b = this.xk;
-            let c = this.xm != a;
+        set xn(a) {
+            let b = this.xl;
+            let c = this.xn != a;
             if (c) {
-                this.xk = a;
-                this.xr(b, this.xk);
+                this.xl = a;
+                this.xs(b, this.xl);
             }
         }
         get_hasMarkers() {
-            return this.xm.hasMarkers;
+            return this.xn.hasMarkers;
         }
-        xr(a, b) {
-            if (this.xk != null) {
-                let hostedSeries_ = this.xk;
+        xs(a, b) {
+            if (this.xl != null) {
+                let hostedSeries_ = this.xl;
                 hostedSeries_.externalObject = TypeRegistrar.createFromInternal(hostedSeries_, PlatformConstants.Prefix, PlatformConstants.Postfix);
                 hostedSeries_.externalObject._implementation = hostedSeries_;
             }
-            this.pt(this.xm);
-            this.xn.ci();
+            this.pu(this.xn);
+            this.xo.ci();
             if (a != null) {
                 let c = (a);
-                this.sk(c, null);
+                this.sl(c, null);
             }
             if (b != null) {
                 let d = (b);
-                this.sk(d, this);
+                this.sl(d, this);
             }
         }
         dh(a, b, c) {
-            return this.dj(this.xm, a, b, c);
+            return this.dj(this.xn, a, b, c);
         }
         di(a, b, c) {
-            return this.dk(this.xm, a, b, c);
+            return this.dk(this.xn, a, b, c);
         }
-        kx(a) {
-            return this.k6(this.xm, a);
+        ky(a) {
+            return this.k7(this.xn, a);
         }
-        kk(a, b) {
-            return this.xm.kk(a, b);
+        kl(a, b) {
+            return this.xn.kl(a, b);
         }
-        ki(a, b) {
-            return this.xm.ki(a, b);
+        kj(a, b) {
+            return this.xn.kj(a, b);
         }
-        je(a, b, c) {
-            return this.xm.je(a, b, c);
+        jf(a, b, c) {
+            return this.xn.jf(a, b, c);
         }
-        wx(a, b, c) {
-            return this.xm.wx(a, b, c);
+        wy(a, b, c) {
+            return this.xn.wy(a, b, c);
         }
-        w9(a) {
-            return this.xm.w9(a);
+        xa(a) {
+            return this.xn.xa(a);
         }
         ao(a) {
-            return this.xm.ao(a);
+            return this.xn.ao(a);
         }
-        xa(a) {
-            return this.xm.xa(a);
+        xb(a) {
+            return this.xn.xb(a);
         }
         ap(a) {
-            return this.xm.ap(a);
-        }
-        xb(a) {
-            return this.xm.xb(a);
+            return this.xn.ap(a);
         }
         xc(a) {
-            return this.xm.xc(a);
+            return this.xn.xc(a);
         }
-        ja(a, b, c) {
-            return this.xm.ja(a, b, c);
+        xd(a) {
+            return this.xn.xd(a);
         }
-        wt(a, b, c) {
-            return this.xm.wt(a, b, c);
+        jb(a, b, c) {
+            return this.xn.jb(a, b, c);
         }
-        jc(a, b, c) {
-            return this.je(a, b, c);
+        wu(a, b, c) {
+            return this.xn.wu(a, b, c);
         }
-        wv(a, b, c) {
-            return this.xm.wv(a, b, c);
+        jd(a, b, c) {
+            return this.jf(a, b, c);
         }
-        wy(a, b, c) {
-            return this.xm.wy(a, b, c);
+        ww(a, b, c) {
+            return this.xn.ww(a, b, c);
         }
-        jf(a, b, c) {
-            return this.xm.jf(a, b, c);
+        wz(a, b, c) {
+            return this.xn.wz(a, b, c);
         }
-        wu(a, b, c) {
-            return this.xm.wu(a, b, c);
+        jg(a, b, c) {
+            return this.xn.jg(a, b, c);
         }
-        jb(a, b, c) {
-            return this.xm.jb(a, b, c);
+        wv(a, b, c) {
+            return this.xn.wv(a, b, c);
         }
-        ww(a, b, c) {
-            return this.xm.ww(a, b, c);
+        jc(a, b, c) {
+            return this.xn.jc(a, b, c);
         }
-        jd(a, b, c) {
-            return this.xm.jd(a, b, c);
+        wx(a, b, c) {
+            return this.xn.wx(a, b, c);
         }
-        ke(a) {
-            return this.xm.ke(a);
+        je(a, b, c) {
+            return this.xn.je(a, b, c);
         }
-        i4() {
-            return this.xm.i4();
+        kf(a) {
+            return this.xn.kf(a);
         }
-        i0(a) {
-            return this.xm.i0(a);
+        i5() {
+            return this.xn.i5();
         }
-        ky(a) {
-            return this.xm.ky(a);
+        i1(a) {
+            return this.xn.i1(a);
+        }
+        kz(a) {
+            return this.xn.kz(a);
         }
         ct() {
             return new HostSeriesView(this);
         }
-        ri(a) {
-            super.ri(a);
-            this.xn = typeCast(HostSeriesView.$, a);
+        rj(a) {
+            super.rj(a);
+            this.xo = typeCast(HostSeriesView.$, a);
         }
-        get xo() {
-            return this.c(GeographicMapSeriesHost.xt);
+        get xp() {
+            return this.c(GeographicMapSeriesHost.xu);
         }
-        set xo(a) {
-            this.h(GeographicMapSeriesHost.xt, a);
+        set xp(a) {
+            this.h(GeographicMapSeriesHost.xu, a);
         }
-        rr(a, b, c, d) {
-            super.rr(a, b, c, d);
+        rs(a, b, c, d) {
+            super.rs(a, b, c, d);
             switch (b) {
                 case "SeriesViewer":
-                    this.xm.dc = this.dc;
+                    this.xn.dc = this.dc;
                     if (c != null) {
-                        c.ta(this.xm);
+                        c.tb(this.xn);
                     }
                     if (d != null) {
-                        this.dc.oo(this.xm);
+                        this.dc.op(this.xn);
                     }
-                    this.xm.ru(this.xe);
-                    this.xm.index = this.index;
-                    this.qf(this.xm);
-                    this.kq = this.xm.kq;
+                    this.xn.rv(this.xf);
+                    this.xn.index = this.index;
+                    this.qg(this.xn);
+                    this.kr = this.xn.kr;
                     let e = typeCast(SeriesViewer.$, c);
                     if (e != null) {
-                        e.actualWindowRectChanged = delegateRemove(e.actualWindowRectChanged, runOn(this, this.xs));
+                        e.actualWindowRectChanged = delegateRemove(e.actualWindowRectChanged, runOn(this, this.xt));
                     }
                     if (this.dc != null) {
                         let f = this.dc;
-                        f.actualWindowRectChanged = delegateCombine(f.actualWindowRectChanged, runOn(this, this.xs));
+                        f.actualWindowRectChanged = delegateCombine(f.actualWindowRectChanged, runOn(this, this.xt));
                     }
-                    this.xq();
+                    this.xr();
                     break;
                 case "SyncLink":
-                    this.xm.c4 = this.c4;
+                    this.xn.c4 = this.c4;
                     break;
                 case "VisibleFromScale":
-                    this.xq();
+                    this.xr();
                     break;
                 case "Index":
-                    this.xm.index = this.index;
+                    this.xn.index = this.index;
                     break;
                 case "ItemsSource":
-                    this.xn.cj();
+                    this.xo.cj();
                     break;
                 case "Resolution":
-                    this.xn.cq();
+                    this.xo.cq();
                     break;
                 case "TransitionDuration":
-                    this.xn.ct();
+                    this.xo.ct();
                     break;
                 case "Opacity":
-                    this.xn.cn();
+                    this.xo.cn();
                     break;
                 case "Visibility":
-                    let hs_ = this.xm;
+                    let hs_ = this.xn;
                     let v_ = this._visibility;
                     hs_.visibility = v_;
                     break;
                 case "MouseOverEnabled":
-                    this.xm.gf = this.gf;
+                    this.xn.gf = this.gf;
                     break;
                 case "ExpectFunctions":
-                    this.xm.expectFunctions = this.expectFunctions;
+                    this.xn.expectFunctions = this.expectFunctions;
                     break;
                 case "Thickness":
-                    this.xn.cs();
+                    this.xo.cs();
                     break;
                 case "Brush":
-                    this.xn.ch();
+                    this.xo.ch();
                     break;
                 case "Outline":
-                    this.xn.cp();
+                    this.xo.cp();
                     break;
                 case "ActualBrush":
-                    this.xn.ce();
+                    this.xo.ce();
                     break;
                 case "ActualOutline":
-                    this.xn.cf();
+                    this.xo.cf();
                     break;
                 case "MarkerFillOpacity":
-                    if (!isNaN_(this.jp)) {
-                        this.xn.cm();
+                    if (!isNaN_(this.jq)) {
+                        this.xo.cm();
                     }
                     break;
                 case "AreaFillOpacity":
-                    if (!isNaN_(this.is)) {
-                        this.xn.cg();
+                    if (!isNaN_(this.it)) {
+                        this.xo.cg();
                     }
                     break;
                 case "OutlineMode":
-                    this.xn.co();
+                    this.xo.co();
                     break;
                 case "ShowDefaultTooltip":
-                    this.xn.cr();
+                    this.xo.cr();
                     break;
                 case "Title":
-                    this.xm.title = this.title;
+                    this.xn.title = this.title;
                     break;
                 case "LegendItemBadgeMode":
-                    this.xn.ck();
+                    this.xo.ck();
                     break;
                 case "LegendItemBadgeShape":
-                    this.xn.cl();
+                    this.xo.cl();
                     break;
                 case "Legend":
-                    this.xm.legend = this.legend;
+                    this.xn.legend = this.legend;
                     this.cw.a5();
                     break;
             }
         }
-        xq() {
-            if (this.dc == null || this.xm == null) {
+        xr() {
+            if (this.dc == null || this.xn == null) {
                 return;
             }
-            if (!isNaN_(this.xo)) {
-                if (this.dc.ys.width > this.xo) {
-                    let hs_ = this.xm;
+            if (!isNaN_(this.xp)) {
+                if (this.dc.yv.width > this.xp) {
+                    let hs_ = this.xn;
                     let v_ = 1;
                     hs_.visibility = v_;
                 }
                 else {
-                    let hs2_ = this.xm;
+                    let hs2_ = this.xn;
                     let v2_ = 0;
                     hs2_.visibility = v2_;
                 }
             }
         }
-        xs(a, b) {
-            this.xq();
+        xt(a, b) {
+            this.xr();
         }
-        r9(a) {
-            super.r9(a);
-            if (this.xm != null) {
-                this.xm.r9(a);
+        sa(a) {
+            super.sa(a);
+            if (this.xn != null) {
+                this.xn.sa(a);
             }
         }
-        rm(a) {
-            super.rm(a);
-            if (this.xm != null) {
-                this.xm.q3();
+        rn(a) {
+            super.rn(a);
+            if (this.xn != null) {
+                this.xn.q4();
             }
         }
-        r8(a, b, c, d, e) {
-            if (this.xm != null) {
-                this.xm.r8(a, b, c, d, e);
+        r9(a, b, c, d, e) {
+            if (this.xn != null) {
+                this.xn.r9(a, b, c, d, e);
             }
         }
         a2(a, b) {
-            return this.xm.a2(a, b);
+            return this.xn.a2(a, b);
         }
-        sv() {
-            super.sv();
-            this.xm.sv();
+        sw() {
+            super.sw();
+            this.xn.sw();
         }
         get_coercionMethods() {
             return this._coercionMethods;
         }
         set_coercionMethods(a) {
             this._coercionMethods = a;
-            this.xm.coercionMethods = a;
+            this.xn.coercionMethods = a;
         }
-        qe(a) {
-            super.qe(a);
-            if (this.xm != null) {
-                let b = this.xm.kw();
-                this.pm(a, b);
+        qf(a) {
+            super.qf(a);
+            if (this.xn != null) {
+                let b = this.xn.kx();
+                this.pn(a, b);
             }
         }
     }
     GeographicMapSeriesHost.$t = /*@__PURE__*/ markType(GeographicMapSeriesHost, 'GeographicMapSeriesHost', Series.$);
-    GeographicMapSeriesHost.xt = /*@__PURE__*/ DependencyProperty.i("VisibleFromScale", Number_$type, GeographicMapSeriesHost.$, /*@__PURE__*/ new PropertyMetadata(2, 1, (a, b) => {
+    GeographicMapSeriesHost.xu = /*@__PURE__*/ DependencyProperty.i("VisibleFromScale", Number_$type, GeographicMapSeriesHost.$, /*@__PURE__*/ new PropertyMetadata(2, 1, (a, b) => {
         let c = a;
         c.raisePropertyChanged("VisibleFromScale", b.oldValue, b.newValue);
     }));
@@ -370,66 +370,66 @@ let HostSeriesView = /*@__PURE__*/ (() => {
         }
         ci() {
             this.cd.legendItemVisibility = 1;
-            this.cd.xm.legendItemVisibility = 0;
-            this.cd.xm.itemsSource = this.cd.itemsSource;
-            this.cd.xm.index = this.cd.index;
-            this.cd.xm.v0 = this.cd.v0;
-            this.cd.xm.wg = this.cd.v0;
-            this.cd.xm.cj = this.cd.cj;
-            this.cd.xm.js = this.cd.js;
-            this.cd.xm.kn = this.cd.kn;
-            this.cd.xm._opacity = this.cd._opacity;
-            this.cd.xm.jz = this.cd.jz;
-            this.cd.xm.is = this.cd.is;
-            this.cd.xm.jp = this.cd.jp;
-            this.cd.xm.gw = this.cd.gw;
-            this.cd.xm.legendItemBadgeShape = this.cd.legendItemBadgeShape;
-            this.cd.xm.be = this.cd.be;
+            this.cd.xn.legendItemVisibility = 0;
+            this.cd.xn.itemsSource = this.cd.itemsSource;
+            this.cd.xn.index = this.cd.index;
+            this.cd.xn.v1 = this.cd.v1;
+            this.cd.xn.wh = this.cd.v1;
+            this.cd.xn.cj = this.cd.cj;
+            this.cd.xn.jt = this.cd.jt;
+            this.cd.xn.ko = this.cd.ko;
+            this.cd.xn._opacity = this.cd._opacity;
+            this.cd.xn.j0 = this.cd.j0;
+            this.cd.xn.it = this.cd.it;
+            this.cd.xn.jq = this.cd.jq;
+            this.cd.xn.gx = this.cd.gx;
+            this.cd.xn.legendItemBadgeShape = this.cd.legendItemBadgeShape;
+            this.cd.xn.be = this.cd.be;
         }
         cj() {
-            this.cd.xm.itemsSource = this.cd.itemsSource;
+            this.cd.xn.itemsSource = this.cd.itemsSource;
         }
         cq() {
-            this.cd.xm.js = this.cd.js;
+            this.cd.xn.jt = this.cd.jt;
         }
         ct() {
-            this.cd.xm.kn = this.cd.kn;
+            this.cd.xn.ko = this.cd.ko;
         }
         cn() {
-            this.cd.xm._opacity = this.cd._opacity;
+            this.cd.xn._opacity = this.cd._opacity;
         }
         cs() {
-            this.cd.xm.jz = this.cd.jz;
+            this.cd.xn.j0 = this.cd.j0;
         }
         ch() {
-            this.cd.xm.v0 = this.cd.v0;
+            this.cd.xn.v1 = this.cd.v1;
         }
         cp() {
-            this.cd.xm.wg = this.cd.wg;
+            this.cd.xn.wh = this.cd.wh;
         }
         ce() {
-            this.cd.xm.v0 = this.cd.vu;
+            this.cd.xn.v1 = this.cd.vv;
         }
         cf() {
-            this.cd.xm.wg = this.cd.vy;
+            this.cd.xn.wh = this.cd.vz;
         }
         ck() {
-            this.cd.xm.be = this.cd.be;
+            this.cd.xn.be = this.cd.be;
         }
         cl() {
-            this.cd.xm.legendItemBadgeShape = this.cd.legendItemBadgeShape;
+            this.cd.xn.legendItemBadgeShape = this.cd.legendItemBadgeShape;
         }
         cg() {
-            this.cd.xm.is = this.cd.is;
+            this.cd.xn.it = this.cd.it;
         }
         cm() {
-            this.cd.xm.jp = this.cd.jp;
+            this.cd.xn.jq = this.cd.jq;
         }
         co() {
-            this.cd.xm.cj = this.cd.cj;
+            this.cd.xn.cj = this.cd.cj;
         }
         cr() {
-            this.cd.xm.gw = this.cd.gw;
+            this.cd.xn.gx = this.cd.gx;
         }
     }
     HostSeriesView.$t = /*@__PURE__*/ markType(HostSeriesView, 'HostSeriesView', SeriesView.$);