igniteui-angular-core 17.1.0 → 17.2.0-beta.0

package/esm2015/lib/FlatDataProvider_combined.js

@@ -4,11 +4,16 @@ https://www.infragistics.com/legal/license/igultimate-la
 https://www.infragistics.com/legal/license/igultimate-eula
 GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
 */
-import { Base, INotifyPropertyChanged_$type, PropertyChangedEventArgs, runOn, delegateCombine, typeCast, delegateRemove, markType } from "./type";
+import { Base, INotifyPropertyChanged_$type, PropertyChangedEventArgs, runOn, delegateCombine, enumGetBox, typeCast, delegateRemove, String_$type, markType } from "./type";
 import { IDataSourceLocalDataProvider_$type } from "./IDataSourceLocalDataProvider";
+import { FlatDataProviderJoinType_$type } from "./FlatDataProviderJoinType";
+import { FlatDataProviderJoinCollisionType_$type } from "./FlatDataProviderJoinCollisionType";
 import { DataSourceLocalDataProvider } from "./DataSourceLocalDataProvider";
 import { VirtualDataSource } from "./VirtualDataSource";
 import { List$1 } from "./List$1";
+import { Dictionary$2 } from "./Dictionary$2";
+import { HashSet$1 } from "./HashSet$1";
+import { DataSourceSchemaPropertyType_$type } from "./DataSourceSchemaPropertyType";
 import { IDataSourceUpdateNotifier_$type } from "./IDataSourceUpdateNotifier";
 /**
  * @hidden
@@ -17,150 +22,248 @@ export let FlatDataProvider = /*@__PURE__*/ (() => {
     class FlatDataProvider extends Base {
         constructor() {
             super();
-            this.f = new DataSourceLocalDataProvider();
-            this.d = null;
-            this.l = null;
+            this.n = new DataSourceLocalDataProvider();
             this.k = null;
-            this.h = false;
+            this.j = null;
+            this.p = false;
+            this.z = null;
+            this.aa = null;
+            this.h = 1;
+            this.e = 0;
+            this.ab = null;
+            this.w = null;
+            this.q = false;
             this.schemaChanged = null;
             this.propertyChanged = null;
-            this.g = false;
+            this.o = false;
             this.a = null;
-            this.i = true;
-            let a = this.f;
-            a.schemaChanged = delegateCombine(a.schemaChanged, runOn(this, this.r));
-            this.f.sortDescriptions.n(runOn(this, this.y));
-            this.f.groupDescriptions.n(runOn(this, this.w));
-            this.f.summaryDescriptions.n(runOn(this, this.z));
-            this.f.filterExpressions.n(runOn(this, this.v));
+            this.r = true;
+            let a = this.n;
+            a.schemaChanged = delegateCombine(a.schemaChanged, runOn(this, this.ap));
+            this.n.sortDescriptions.n(runOn(this, this.ay));
+            this.n.groupDescriptions.n(runOn(this, this.aw));
+            this.n.summaryDescriptions.n(runOn(this, this.az));
+            this.n.filterExpressions.n(runOn(this, this.av));
+        }
+        clone() {
+            let a = new FlatDataProvider();
+            a.deferAutoRefresh = this.deferAutoRefresh;
+            a.executionContext = this.executionContext;
+            a.dataSource = this.dataSource;
+            a.propertiesRequested = this.propertiesRequested;
+            a.am = this.am;
+            a.summaryScope = this.summaryScope;
+            a.ah = this.ah;
+            a.ak = this.ak;
+            a.g = this.g;
+            a.i = this.i;
+            if (this.m != null) {
+                a.m = this.m.clone();
+            }
+            if (this.l != null) {
+                a.l = this.l.clone();
+            }
+            for (let b = 0; b < this.groupDescriptions.k.count; b++) {
+                a.groupDescriptions.add(this.groupDescriptions.k.item(b));
+            }
+            for (let c = 0; c < this.sortDescriptions.k.count; c++) {
+                a.sortDescriptions.add(this.sortDescriptions.k.item(c));
+            }
+            for (let d = 0; d < this.filterExpressions.k.count; d++) {
+                a.filterExpressions.add(this.filterExpressions.k.item(d));
+            }
+            for (let e = 0; e < this.summaryDescriptions.k.count; e++) {
+                a.summaryDescriptions.add(this.summaryDescriptions.k.item(e));
+            }
+            return a;
         }
-        v(a, b) {
-            this.i = true;
+        av(a, b) {
+            this.r = true;
         }
-        z(a, b) {
-            this.i = true;
+        az(a, b) {
+            this.r = true;
         }
-        w(a, b) {
-            this.i = true;
+        aw(a, b) {
+            this.r = true;
         }
-        y(a, b) {
-            this.i = true;
+        ay(a, b) {
+            this.r = true;
         }
-        r(a, b) {
+        ap(a, b) {
             if (this.schemaChanged != null) {
                 this.schemaChanged(this, b);
             }
         }
-        get e() {
-            return this.d;
+        get m() {
+            return this.k;
+        }
+        set m(a) {
+            let b = this.k;
+            this.k = a;
+            if (b != this.k) {
+                this.ax("TargetDataSource", b, this.k);
+            }
+        }
+        get l() {
+            return this.j;
+        }
+        set l(a) {
+            let b = this.j;
+            this.j = a;
+            if (b != this.j) {
+                this.ax("RightDataSource", b, this.j);
+            }
+        }
+        get s() {
+            return this.p;
+        }
+        set s(a) {
+            let b = this.p;
+            this.p = a;
+            if (b != this.p) {
+                this.ax("BroadcastChangesToRightDataSource", b, this.p);
+            }
+        }
+        get ah() {
+            return this.z;
+        }
+        set ah(a) {
+            let b = this.z;
+            this.z = a;
+            if (b != this.z) {
+                this.ax("LeftJoinProperty", b, this.z);
+            }
+        }
+        get ak() {
+            return this.aa;
+        }
+        set ak(a) {
+            let b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.ax("RightJoinProperty", b, this.aa);
+            }
+        }
+        get i() {
+            return this.h;
+        }
+        set i(a) {
+            let b = this.h;
+            this.h = a;
+            if (b != this.h) {
+                this.ax("JoinType", enumGetBox(FlatDataProviderJoinType_$type, b), enumGetBox(FlatDataProviderJoinType_$type, this.h));
+            }
+        }
+        get g() {
+            return this.e;
         }
-        set e(a) {
-            let b = this.d;
-            this.d = a;
-            if (b != this.d) {
-                this.x("TargetDataSource", b, this.d);
+        set g(a) {
+            let b = this.e;
+            this.e = a;
+            if (b != this.e) {
+                this.ax("JoinCollisionType", enumGetBox(FlatDataProviderJoinCollisionType_$type, b), enumGetBox(FlatDataProviderJoinCollisionType_$type, this.e));
             }
         }
-        get o() {
-            return this.l;
+        get am() {
+            return this.ab;
         }
-        set o(a) {
-            let b = this.l;
-            this.l = a;
-            if (b != this.l) {
-                this.x("SchemaHints", b, this.l);
+        set am(a) {
+            let b = this.ab;
+            this.ab = a;
+            if (b != this.ab) {
+                this.ax("SchemaHints", b, this.ab);
             }
         }
         get actualSchema() {
-            return this.f.actualSchema;
+            return this.n.actualSchema;
         }
         get executionContext() {
-            return this.f.executionContext;
+            return this.n.executionContext;
         }
         set executionContext(a) {
-            this.f.executionContext = a;
+            this.n.executionContext = a;
         }
         get updateNotifier() {
-            return this.f.updateNotifier;
+            return this.n.updateNotifier;
         }
         set updateNotifier(a) {
-            this.f.updateNotifier = a;
+            this.n.updateNotifier = a;
         }
         get dataSource() {
-            return this.k;
+            return this.w;
         }
         set dataSource(a) {
-            let b = this.k;
-            this.k = a;
-            if (b != this.k) {
-                this.x("ItemsSource", b, this.k);
+            let b = this.w;
+            this.w = a;
+            if (b != this.w) {
+                this.ax("ItemsSource", b, this.w);
             }
         }
         get deferAutoRefresh() {
-            return this.h;
+            return this.q;
         }
         set deferAutoRefresh(a) {
-            let b = this.h;
-            this.h = a;
-            if (b != this.h) {
-                this.x("DeferAutoRefresh", b, this.h);
+            let b = this.q;
+            this.q = a;
+            if (b != this.q) {
+                this.ax("DeferAutoRefresh", b, this.q);
             }
         }
         get isSortingSupported() {
-            return this.f.isSortingSupported;
+            return this.n.isSortingSupported;
         }
         get isGroupingSupported() {
-            return this.f.isGroupingSupported;
+            return this.n.isGroupingSupported;
         }
         get isFilteringSupported() {
-            return this.f.isFilteringSupported;
+            return this.n.isFilteringSupported;
         }
         get sortDescriptions() {
-            return this.f.sortDescriptions;
+            return this.n.sortDescriptions;
         }
         get groupDescriptions() {
-            return this.f.groupDescriptions;
+            return this.n.groupDescriptions;
         }
         get summaryDescriptions() {
-            return this.f.summaryDescriptions;
+            return this.n.summaryDescriptions;
         }
         get summaryScope() {
-            return this.f.summaryScope;
+            return this.n.summaryScope;
         }
         set summaryScope(a) {
-            this.f.summaryScope = a;
+            this.n.summaryScope = a;
         }
         get filterExpressions() {
-            return this.f.filterExpressions;
+            return this.n.filterExpressions;
         }
         get propertiesRequested() {
-            return this.f.propertiesRequested;
+            return this.n.propertiesRequested;
         }
         set propertiesRequested(a) {
-            this.f.propertiesRequested = a;
+            this.n.propertiesRequested = a;
         }
         get notifyUsingSourceIndexes() {
             return true;
         }
         get isItemIndexLookupSupported() {
-            return this.f.isItemIndexLookupSupported;
+            return this.n.isItemIndexLookupSupported;
         }
         get isKeyIndexLookupSupported() {
-            return this.f.isKeyIndexLookupSupported;
+            return this.n.isKeyIndexLookupSupported;
         }
         get actualCount() {
-            return this.f.actualCount;
+            return this.n.actualCount;
         }
-        x(a, b, c) {
+        ax(a, b, c) {
             if (this.propertyChanged != null) {
                 this.propertyChanged(this, new PropertyChangedEventArgs(a));
             }
-            this.af(a, b, c);
+            this.a5(a, b, c);
         }
-        af(a, b, c) {
+        a5(a, b, c) {
             switch (a) {
                 case "ItemsSource":
-                    this.f.dataSource = c;
+                    this.n.dataSource = c;
                     break;
                 case "DeferAutoRefresh":
                     if (!c) {
@@ -175,128 +278,328 @@ export let FlatDataProvider = /*@__PURE__*/ (() => {
                                 d.updateNotifier = d.updateNotifier.c;
                             }
                         }
-                        d.schemaChanged = delegateRemove(d.schemaChanged, runOn(this, this.u));
+                        d.schemaChanged = delegateRemove(d.schemaChanged, runOn(this, this.au));
                     }
                     if (c != null) {
                         let e = c;
-                        this.f.executionContext = e.executionContext;
+                        this.n.executionContext = e.executionContext;
                         let f = new FlatDataProviderTargetDataSourceNotifier(this, e.updateNotifier);
                         e.updateNotifier = f;
-                        e.schemaChanged = delegateCombine(e.schemaChanged, runOn(this, this.u));
+                        e.schemaChanged = delegateCombine(e.schemaChanged, runOn(this, this.au));
+                    }
+                    this.queueAutoRefresh();
+                    break;
+                case "RightDataSource":
+                    if (b != null) {
+                        let g = b;
+                        if (g.updateNotifier != null) {
+                            if (typeCast(FlatDataProviderTargetDataSourceNotifier.$, g.updateNotifier) !== null) {
+                                g.updateNotifier = g.updateNotifier.c;
+                            }
+                        }
+                        g.schemaChanged = delegateRemove(g.schemaChanged, runOn(this, this.au));
+                    }
+                    if (c != null) {
+                        let h = c;
+                        let i = new FlatDataProviderTargetDataSourceNotifier(this, h.updateNotifier);
+                        h.updateNotifier = i;
+                        h.schemaChanged = delegateCombine(h.schemaChanged, runOn(this, this.au));
                     }
                     this.queueAutoRefresh();
                     break;
             }
         }
-        u(a, b) {
-            this.i = true;
+        au(a, b) {
+            this.r = true;
             this.queueAutoRefresh();
         }
         addItem(a) {
-            this.f.addItem(a);
+            this.n.addItem(a);
         }
         queueAutoRefresh() {
             if (this.deferAutoRefresh) {
                 return;
             }
-            if (this.g) {
+            if (this.o) {
                 return;
             }
             if (this.executionContext != null) {
-                this.g = true;
-                this.executionContext.enqueueAction(runOn(this, this.s));
+                this.o = true;
+                this.executionContext.enqueueAction(runOn(this, this.ar));
             }
         }
-        s() {
+        ar() {
             if (this.deferAutoRefresh) {
-                this.g = false;
+                this.o = false;
                 return;
             }
-            if (!this.g) {
+            if (!this.o) {
                 return;
             }
-            this.g = false;
-            this.ag();
+            this.o = false;
+            this.a6();
         }
-        ag() {
-            this.ah();
+        a6() {
+            this.a7();
         }
-        ah() {
-            if (this.d == null) {
+        a7() {
+            if (this.k == null) {
                 return;
             }
-            if (!this.i) {
+            if (!this.r) {
                 return;
             }
-            this.d.flushAutoRefresh();
-            let a = this.d.isVirtual;
+            this.r = false;
+            this.k.flushAutoRefresh();
+            let a = this.k.isVirtual;
             if (a) {
                 let b = 50;
-                if (typeCast(VirtualDataSource.$, this.d) !== null) {
-                    b = this.d.actualPageSize;
+                if (typeCast(VirtualDataSource.$, this.k) !== null) {
+                    b = this.k.actualPageSize;
                 }
-                this.d.firstVisibleIndexRequested = 0;
-                this.d.lastVisibleIndexRequested = b;
+                this.k.firstVisibleIndexRequested = 0;
+                this.k.lastVisibleIndexRequested = b;
+            }
+            let c = this.b(this.k);
+            if (this.l != null && this.ak != null && this.ah != null) {
+                let d = this.b(this.j);
+                c = this.c(c, d);
             }
-            let c = this.b(this.d);
             this.dataSource = c;
         }
+        c(a, b) {
+            let c = new List$1(Base.$, 0);
+            let d = this.u(a, this.m, false);
+            let e = this.u(b, this.l, true);
+            let f = this.g;
+            switch (this.i) {
+                case 0:
+                    this.aq(c, a, d, this.m, b, e, this.l, false, f);
+                    break;
+                case 1:
+                    this.aq(c, a, d, this.m, b, e, this.l, true, f);
+                    break;
+                case 2:
+                    f = this.f(f);
+                    this.aq(c, b, e, this.l, a, d, this.m, true, f);
+                    break;
+            }
+            return c.toArray();
+        }
+        f(a) {
+            switch (a) {
+                case 0: return 0;
+                case 1: return 2;
+                case 2: return 1;
+                case 3: return 4;
+                case 4: return 3;
+            }
+            return 0;
+        }
+        u(a, b, c) {
+            let d = this.ah;
+            if (c) {
+                d = this.ak;
+            }
+            let e = new Dictionary$2(Base.$, Base.$, 0);
+            for (let f = 0; f < a.length; f++) {
+                let g = a[f];
+                let h = b.getItemProperty(g, d);
+                e.item(h, g);
+            }
+            return e;
+        }
+        x() {
+            return {};
+        }
+        a8(a, b, c) {
+            if (b.charAt(0) == '[') {
+                b = b.substr(1, b.length - 2);
+            }
+            let d = a;
+            d[b] = c;
+        }
+        t(a, b) {
+            let c = a;
+            return c[b] != undefined;
+        }
+        aq(a, b, c, d, e, f, g, h, i) {
+            let j = new HashSet$1(String_$type, 0);
+            let k = new HashSet$1(String_$type, 0);
+            let l = new HashSet$1(String_$type, 0);
+            let m = new List$1(String_$type, 0);
+            let n = new List$1(DataSourceSchemaPropertyType_$type, 0);
+            if (d.actualSchema != null) {
+                for (let o = 0; o < d.actualSchema.propertyNames.length; o++) {
+                    let p = d.actualSchema.propertyNames[o];
+                    let q = d.actualSchema.propertyTypes[o];
+                    j.add_1(p);
+                    if (!l.contains(p)) {
+                        l.add_1(p);
+                        m.add(p);
+                        n.add(q);
+                    }
+                }
+            }
+            if (g.actualSchema != null) {
+                for (let r = 0; r < g.actualSchema.propertyNames.length; r++) {
+                    let s = g.actualSchema.propertyNames[r];
+                    let t = g.actualSchema.propertyTypes[r];
+                    k.add_1(s);
+                    if (!l.contains(s)) {
+                        l.add_1(s);
+                        m.add(s);
+                        n.add(t);
+                    }
+                }
+            }
+            let u = m.toArray();
+            let v = n.toArray();
+            for (let w = 0; w < b.length; w++) {
+                let x = b[w];
+                let y = d.getItemProperty(x, this.ah);
+                let z = f.containsKey(y);
+                if (!z && !h) {
+                    continue;
+                }
+                let aa = this.x();
+                let ab = null;
+                if (z) {
+                    ab = f.item(y);
+                }
+                this.at(aa, x, z, j, k, u, v, c, d, ab, f, g, i);
+                a.add1(aa);
+            }
+        }
+        at(a, b, c, d, e, f, g, h, i, j, k, l, m) {
+            let n = i.actualSchema;
+            let o = l.actualSchema;
+            for (let p = 0; p < f.length; p++) {
+                let q = f[p];
+                let r = g[p];
+                let s = d.contains(q) && e.contains(q);
+                if (!s) {
+                    if (d.contains(q)) {
+                        let t = i.getItemProperty(b, q);
+                        this.a8(a, q, t);
+                        continue;
+                    }
+                    else {
+                        let u = l.getItemProperty(j, q);
+                        this.a8(a, q, u);
+                        continue;
+                    }
+                }
+                let v = m;
+                if (q == this.ah) {
+                    v = 1;
+                }
+                switch (v) {
+                    case 0:
+                        let w = i.getItemProperty(b, q);
+                        this.a8(a, q, w);
+                        continue;
+                    case 1:
+                        let x = i.getItemProperty(b, q);
+                        this.a8(a, q, x);
+                        continue;
+                    case 2: if (c) {
+                        let y = l.getItemProperty(j, q);
+                        this.a8(a, q, y);
+                        continue;
+                    }
+                    else {
+                        this.a8(a, q, this.y(r));
+                        continue;
+                    }
+                    case 3:
+                        let z = i.getItemProperty(b, q);
+                        this.a8(a, q, z);
+                        continue;
+                    case 4: if (c) {
+                        let aa = l.getItemProperty(j, q);
+                        this.a8(a, q, aa);
+                        continue;
+                    }
+                    else {
+                        let ab = i.getItemProperty(b, q);
+                        this.a8(a, q, ab);
+                        continue;
+                    }
+                }
+            }
+        }
+        y(a) {
+            return null;
+        }
         flushAutoRefresh() {
-            this.s();
+            this.ar();
         }
         refresh() {
-            this.ag();
+            this.a6();
         }
         getItemAtIndex(a) {
-            return this.f.getItemAtIndex(a);
+            return this.n.getItemAtIndex(a);
         }
         getItemValue(a, b) {
-            return this.f.getItemValue(a, b);
+            return this.n.getItemValue(a, b);
         }
         indexOfItem(a) {
-            return this.f.indexOfItem(a);
+            return this.n.indexOfItem(a);
         }
         indexOfKey(a) {
-            return this.f.indexOfKey(a);
+            return this.n.indexOfKey(a);
         }
         removeItem(a) {
-            this.f.removeItem(a);
+            this.n.removeItem(a);
         }
         resolveSchemaPropertyType(a) {
-            return this.f.resolveSchemaPropertyType(a);
+            return this.n.resolveSchemaPropertyType(a);
         }
         setItemValue(a, b, c) {
-            this.f.setItemValue(a, b, c);
+            this.n.setItemValue(a, b, c);
         }
         notifyClearItems() {
-            if (this.e != null) {
-                this.e.notifyClearItems();
+            if (this.m != null) {
+                this.m.notifyClearItems();
+            }
+            if (this.l != null && this.s) {
+                this.l.notifyClearItems();
             }
         }
         notifyInsertItem(a, b) {
-            if (this.e != null) {
-                this.e.notifyInsertItem(a, b);
+            if (this.m != null) {
+                this.m.notifyInsertItem(a, b);
+            }
+            if (this.l != null && this.s) {
+                this.l.notifyInsertItem(a, b);
             }
         }
         notifyRemoveItem(a, b) {
-            if (this.e != null) {
-                this.e.notifyRemoveItem(a, b);
+            if (this.m != null) {
+                this.m.notifyRemoveItem(a, b);
+            }
+            if (this.l != null && this.s) {
+                this.l.notifyRemoveItem(a, b);
             }
         }
         notifySetItem(a, b, c) {
-            if (this.e != null) {
-                this.e.notifySetItem(a, b, c);
+            if (this.m != null) {
+                this.m.notifySetItem(a, b, c);
+            }
+            if (this.l != null && this.s) {
+                this.l.notifySetItem(a, b, c);
             }
         }
-        j(a) {
+        v(a) {
             return a.groupDescriptions.k.count;
         }
         b(a) {
-            let b = this.c(a);
+            let b = this.d(a);
             return b;
         }
-        t(a, b) {
-            let c = this.d;
+        as(a, b) {
+            let c = this.k;
             if (this.a != null) {
                 for (let d = 0; d < c.actualCount; d++) {
                     let e = c.getRowType(d);
@@ -306,9 +609,9 @@ export let FlatDataProvider = /*@__PURE__*/ (() => {
                     }
                 }
             }
-            this.f.notifyClearItems();
+            this.n.notifyClearItems();
         }
-        c(a) {
+        d(a) {
             let b = new List$1(Base.$, 0);
             for (let c = 0; c < a.actualCount; c++) {
                 let d = a.getRowType(c);
@@ -318,28 +621,28 @@ export let FlatDataProvider = /*@__PURE__*/ (() => {
             this.a = b.toArray();
             return this.a;
         }
-        aa() {
-            this.i = true;
+        a0() {
+            this.r = true;
             this.queueAutoRefresh();
         }
-        ab(a, b) {
-            this.i = true;
+        a1(a, b) {
+            this.r = true;
             this.queueAutoRefresh();
         }
-        ac(a, b) {
-            this.i = true;
+        a2(a, b) {
+            this.r = true;
             this.queueAutoRefresh();
         }
-        ad(a, b, c) {
-            this.i = true;
+        a3(a, b, c) {
+            this.r = true;
             this.queueAutoRefresh();
         }
-        ae(a, b) {
-            this.t(a, b);
-            if (this.d.lastVisibleIndexRequested < this.d.actualCount) {
-                let c = this.d.lastVisibleIndexRequested - this.d.firstVisibleIndexRequested;
-                this.d.lastVisibleIndexRequested += c;
-                this.d.firstVisibleIndexRequested += c;
+        a4(a, b) {
+            this.as(a, b);
+            if (this.k.lastVisibleIndexRequested < this.k.actualCount) {
+                let c = this.k.lastVisibleIndexRequested - this.k.firstVisibleIndexRequested;
+                this.k.lastVisibleIndexRequested += c;
+                this.k.firstVisibleIndexRequested += c;
             }
         }
     }
@@ -362,31 +665,31 @@ export let FlatDataProviderTargetDataSourceNotifier = /*@__PURE__*/ (() => {
             return this.b;
         }
         notifyClearItems() {
-            this.a.aa();
+            this.a.a0();
             if (this.b != null) {
                 this.b.notifyClearItems();
             }
         }
         notifyInsertItem(a, b) {
-            this.a.ab(a, b);
+            this.a.a1(a, b);
             if (this.b != null) {
                 this.b.notifyInsertItem(a, b);
             }
         }
         notifyRemoveItem(a, b) {
-            this.a.ac(a, b);
+            this.a.a2(a, b);
             if (this.b != null) {
                 this.b.notifyRemoveItem(a, b);
             }
         }
         notifySetItem(a, b, c) {
-            this.a.ad(a, b, c);
+            this.a.a3(a, b, c);
             if (this.b != null) {
                 this.b.notifySetItem(a, b, c);
             }
         }
         rangeActualized(a, b) {
-            this.a.ae(a, b);
+            this.a.a4(a, b);
             if (this.b != null) {
                 this.b.rangeActualized(a, b);
             }