igniteui-angular-core 17.1.0 → 17.2.0

package/esm2015/lib/IDataSeriesAdapterRule_combined.js

@@ -10,6 +10,7 @@ import { Stack$1 } from "./Stack$1";
 import { IDataSourceLocalDataProvider_$type } from "./IDataSourceLocalDataProvider";
 import { HashSet$1 } from "./HashSet$1";
 import { DataSeriesType_$type } from "./DataSeriesType";
+import { DataSeriesAdapterProviderInfo } from "./DataSeriesAdapterProviderInfo";
 import { DataSeries } from "./DataSeries";
 import { List$1 } from "./List$1";
 import { Matcher } from "./Matcher";
@@ -22,9 +23,8 @@ import { SortDescriptionCollection } from "./SortDescriptionCollection";
 import { FilterExpressionCollection } from "./FilterExpressionCollection";
 import { SummaryDescriptionCollection } from "./SummaryDescriptionCollection";
 import { Dictionary$2 } from "./Dictionary$2";
-import { DataSeriesAdapterCachedProvider } from "./DataSeriesAdapterCachedProvider";
-import { AggregatedDataProvider } from "./AggregatedDataProvider";
 import { IDataSource_$type } from "./IDataSource";
+import { AggregatedDataProvider } from "./AggregatedDataProvider";
 import { FlatDataProvider } from "./FlatDataProvider";
 /**
  * @hidden
@@ -40,27 +40,29 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this.g = null;
             this._analyzer = null;
             this.h = null;
-            this.m = null;
-            this.o = null;
             this.n = null;
+            this.o = null;
+            this.q = null;
+            this.p = null;
             this.b = null;
             this.a = null;
-            this.l = null;
+            this.m = null;
             this.g = a;
             this.analyzer = new DataSeriesDataProviderAnalyzer(this);
             this.analyzer.includedProperties = this.g.includedProperties;
             this.analyzer.excludedProperties = this.g.excludedProperties;
             this.h = new DataSeriesCollection();
-            this.m = new Stack$1(IDataSourceLocalDataProvider_$type);
-            this.o = new Stack$1(String_$type);
-            this.n = new Stack$1(String_$type);
+            this.n = new Stack$1(IDataSourceLocalDataProvider_$type);
+            this.o = new Stack$1(IDataSourceLocalDataProvider_$type);
+            this.q = new Stack$1(String_$type);
+            this.p = new Stack$1(String_$type);
             this.b = this.g.includedProperties;
             this.a = this.g.excludedProperties;
-            this.l = null;
+            this.m = null;
             if (this.g.supportedSeriesTypes != null) {
-                this.l = new HashSet$1(DataSeriesType_$type, 0);
+                this.m = new HashSet$1(DataSeriesType_$type, 0);
                 for (let b = 0; b < this.g.supportedSeriesTypes.length; b++) {
-                    this.l.add_1(this.g.supportedSeriesTypes[b]);
+                    this.m.add_1(this.g.supportedSeriesTypes[b]);
                 }
             }
         }
@@ -71,20 +73,27 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this._analyzer = a;
         }
         getSubProvider(a, b) {
-            let c = this.g.n(a, false);
-            this.pushDataSource(c);
+            let c = this.g.h(a, false);
+            this.pushDataSource(c.c);
+            if (c.b != null) {
+                this.pushHighlightingDataSource(c.b);
+            }
+            else {
+                this.pushHighlightingDataSource(null);
+            }
             this.pushPath(b);
-            return c;
+            return c.c;
         }
         popSubProvider() {
             this.popDataSource();
+            this.popHighlightingDataSource();
             this.popPath();
         }
-        w(a, b) {
-            return this.g.aj(a, b);
+        z(a, b) {
+            return this.g.ap(a, b);
         }
         recurseRules(a, b, c) {
-            this.g.a0(this, a, b, c);
+            this.g.ba(this, a, b, c);
         }
         get includedProperties() {
             return this.b;
@@ -93,30 +102,39 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             return this.a;
         }
         getCurrentDataSource() {
-            return this.m.d();
+            return this.n.d();
+        }
+        getCurrentHighlightingDataSource() {
+            return this.o.d();
         }
         pushDataSource(a) {
-            this.m.h(a);
+            this.n.h(a);
+        }
+        pushHighlightingDataSource(a) {
+            this.o.h(a);
         }
         hasValidType(a) {
-            if (this.l == null) {
+            if (this.m == null) {
                 return true;
             }
-            if (this.l.contains(a.suggestedSeries)) {
+            if (this.m.contains(a.suggestedSeries)) {
                 return true;
             }
             return false;
         }
         popDataSource() {
-            return this.m.e();
+            return this.n.e();
+        }
+        popHighlightingDataSource() {
+            return this.o.e();
         }
         getCurrentPathSegment() {
-            return this.o.d();
+            return this.q.d();
         }
         getCurrentPath() {
             let a = "";
             let b = true;
-            for (let c of fromEnum(this.o)) {
+            for (let c of fromEnum(this.q)) {
                 if (b) {
                     b = false;
                 }
@@ -128,24 +146,24 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             return a;
         }
         getParentTitle() {
-            if (this.n.f == 0) {
+            if (this.p.f == 0) {
                 return null;
             }
-            return this.n.d();
+            return this.p.d();
         }
         pushPath(a) {
-            this.o.h(a);
+            this.q.h(a);
         }
         popPath() {
-            return this.o.e();
+            return this.q.e();
         }
         pushParentTitle(a) {
-            this.n.h(a);
+            this.p.h(a);
         }
         popParentTitle() {
-            return this.n.e();
+            return this.p.e();
         }
-        ab(a, b) {
+        ae(a, b) {
             if (a.priority == -1) {
                 a.priority = b.priority;
             }
@@ -155,16 +173,22 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             if (a.data == null) {
                 a.data = this.getCurrentDataSource().dataSource;
             }
+            if (a.highlightedData == null) {
+                let c = this.getCurrentHighlightingDataSource();
+                if (c != null) {
+                    a.highlightedData = c.dataSource;
+                }
+            }
         }
         addDataSeries(a, b) {
-            this.ab(a, b);
+            this.ae(a, b);
             this.h.add(a);
         }
         removeDataSeries(a) {
             this.h.remove(a);
         }
         insertDataSeries(a, b, c) {
-            this.ab(b, c);
+            this.ae(b, c);
             this.h.insert(a, b);
         }
         clearDataSeries() {
@@ -774,16 +798,16 @@ export let DataSeriesAdapterUpdateNotifier = /*@__PURE__*/ (() => {
             this.b = b;
         }
         notifyClearItems() {
-            this.a.at(this.b);
+            this.a.a3(this.b);
         }
         notifyInsertItem(a, b) {
-            this.a.au(this.b, a, b);
+            this.a.a4(this.b, a, b);
         }
         notifyRemoveItem(a, b) {
-            this.a.av(this.b, a, b);
+            this.a.a5(this.b, a, b);
         }
         notifySetItem(a, b, c) {
-            this.a.aw(this.b, a, b, c);
+            this.a.a6(this.b, a, b, c);
         }
     }
     DataSeriesAdapterUpdateNotifier.$t = markType(DataSeriesAdapterUpdateNotifier, 'DataSeriesAdapterUpdateNotifier', Base.$, [IDataSourceDataProviderUpdateNotifier_$type]);
@@ -839,77 +863,84 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
     class DataSeriesAdapterImplementation extends Base {
         constructor() {
             super();
-            this.x = false;
-            this.w = false;
-            this.ac = null;
-            this.ae = null;
-            this.ab = new Dictionary$2(Base.$, DataSeriesAdapterCachedProvider.$, 0);
-            this.ad = null;
+            this.ab = false;
+            this.z = false;
+            this.aa = false;
+            this.ai = null;
+            this.ak = null;
+            this.ah = new Dictionary$2(Base.$, DataSeriesAdapterProviderInfo.$, 0);
+            this.ag = new Dictionary$2(Base.$, DataSeriesAdapterProviderInfo.$, 0);
+            this.aj = null;
             this.propertyChanged = null;
             this.c = null;
             this.b = null;
             this.a = null;
-            this.q = null;
-            this.p = null;
-            this.o = null;
-            this.l = null;
-            this.u = null;
+            this.t = null;
+            this.s = null;
+            this.r = null;
+            this.m = null;
+            this.n = null;
+            this.x = null;
             this._rules = null;
             this._dataSeries = null;
-            this.y = false;
+            this.ac = false;
             this.removingUnsupported = null;
             this.removingDuplicates = null;
-            this.q = new SortDescriptionCollection();
-            this.o = new SortDescriptionCollection();
-            this.u = new SummaryDescriptionCollection();
-            this.l = new FilterExpressionCollection();
-            this.p = new SortDescriptionCollection();
-            this.q.n(runOn(this, this.al));
-            this.o.n(runOn(this, this.al));
-            this.u.n(runOn(this, this.al));
-            this.l.n(runOn(this, this.al));
-            this.p.n(runOn(this, this.al));
+            this.t = new SortDescriptionCollection();
+            this.r = new SortDescriptionCollection();
+            this.x = new SummaryDescriptionCollection();
+            this.m = new FilterExpressionCollection();
+            this.n = new FilterExpressionCollection();
+            this.s = new SortDescriptionCollection();
+            this.t.n(runOn(this, this.as));
+            this.r.n(runOn(this, this.as));
+            this.x.n(runOn(this, this.as));
+            this.m.n(runOn(this, this.as));
+            this.n.n(runOn(this, this.as));
+            this.s.n(runOn(this, this.as));
             this.rules = new DataSeriesAdapterRuleCollection();
             this.dataSeries = new DataSeriesCollection();
-            this.ax(this.rules);
+            this.a7(this.rules);
             let a = this.rules;
-            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.a5));
-        }
-        al(a, b) {
-            let c = this.z;
-            let d = this.aa();
-            if (c != this.w || d != this.x) {
-                this.w = c;
-                this.x = d;
+            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.bf));
+        }
+        as(a, b) {
+            let c = this.ad;
+            let d = this.af();
+            let e = this.ae();
+            if (c != this.z || d != this.ab || e != this.aa) {
+                this.z = c;
+                this.ab = d;
+                this.aa = e;
                 this.refresh();
             }
         }
-        aj(a, b) {
+        ap(a, b) {
             let c = stringEmpty();
-            if (this.ac != null) {
-                c = this.ac(a);
+            if (this.ai != null) {
+                c = this.ai(a);
             }
             if (stringIsNullOrEmpty(c)) {
                 return b;
             }
             return c;
         }
-        ax(a) {
+        a7(a) {
         }
-        a5(a, b) {
+        bf(a, b) {
             this.refresh();
         }
         get g() {
-            return this.ae;
+            return this.ak;
         }
         get itemsSource() {
-            return this.ad;
+            return this.aj;
         }
         set itemsSource(a) {
-            let b = this.ad;
-            this.ad = a;
-            if (b != this.ad) {
-                this.as("ItemsSource", b, this.ad);
+            let b = this.aj;
+            this.aj = a;
+            if (b != this.aj) {
+                this.a2("ItemsSource", b, this.aj);
             }
         }
         get supportedSeriesTypes() {
@@ -919,7 +950,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.c;
             this.c = a;
             if (b != this.c) {
-                this.as("SupportedSeriesTypes", b, this.c);
+                this.a2("SupportedSeriesTypes", b, this.c);
             }
         }
         get includedProperties() {
@@ -929,7 +960,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.b;
             this.b = a;
             if (b != this.b) {
-                this.as("IncludedProperties", b, this.b);
+                this.a2("IncludedProperties", b, this.b);
             }
         }
         get excludedProperties() {
@@ -939,23 +970,26 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.a;
             this.a = a;
             if (b != this.a) {
-                this.as("ExcludedProperties", b, this.a);
+                this.a2("ExcludedProperties", b, this.a);
             }
         }
         get sortDescriptions() {
-            return this.q;
+            return this.t;
         }
         get postSortDescriptions() {
-            return this.p;
+            return this.s;
         }
         get groupDescriptions() {
-            return this.o;
+            return this.r;
         }
         get filterExpressions() {
-            return this.l;
+            return this.m;
+        }
+        get highlightFilterExpressions() {
+            return this.n;
         }
         get summaryDescriptions() {
-            return this.u;
+            return this.x;
         }
         get rules() {
             return this._rules;
@@ -969,13 +1003,13 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
         set dataSeries(a) {
             this._dataSeries = a;
         }
-        as(a, b, c) {
-            this.ay(a, b, c);
+        a2(a, b, c) {
+            this.a8(a, b, c);
             if (this.propertyChanged != null) {
                 this.propertyChanged(this, new PropertyChangedEventArgs(a));
             }
         }
-        ay(a, b, c) {
+        a8(a, b, c) {
             switch (a) {
                 case "ItemsSource":
                     this.refresh();
@@ -992,54 +1026,49 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             }
         }
         refresh() {
-            this.y = true;
-            this.a4();
+            this.ac = true;
+            this.be();
             let a = new DataSeriesAdapterRunContext(this);
-            let b = this.n(this.itemsSource, true);
-            this.am(this.itemsSource, b, null, false);
-            a.pushDataSource(b);
-            this.a7(a);
-            this.a9(a);
-            this.an();
-            this.y = false;
+            let b = this.h(this.itemsSource, true);
+            this.at(this.itemsSource, b, null, false);
+            a.pushDataSource(b.c);
+            if (b.b != null) {
+                a.pushHighlightingDataSource(b.b);
+            }
+            else {
+                a.pushHighlightingDataSource(null);
+            }
+            this.bh(a);
+            this.bj(a);
+            this.au();
+            this.ac = false;
         }
-        a4() {
-            for (let a of fromEnum(this.ab.keys)) {
-                let b = this.ab.item(a);
-                b.c = false;
+        be() {
+            for (let a of fromEnum(this.ah.keys)) {
+                let b = this.ah.item(a);
+                b.d = false;
             }
         }
-        an() {
+        au() {
             let a = new List$1(Base.$, 0);
-            for (let b of fromEnum(this.ab.keys)) {
-                let c = this.ab.item(b);
-                if (!c.c) {
+            for (let b of fromEnum(this.ah.keys)) {
+                let c = this.ah.item(b);
+                if (!c.d) {
                     a.add1(b);
-                    let d = c.b;
-                    if (typeCast(AggregatedDataProvider.$, d) !== null) {
-                        let e = d;
-                        if (e.f != null) {
-                            this.sortDescriptions.syncTarget = null;
-                            this.groupDescriptions.syncTarget = null;
-                            this.filterExpressions.syncTarget = null;
-                            this.summaryDescriptions.syncTarget = null;
-                        }
-                    }
-                    d.updateNotifier = null;
-                    d.schemaChanged = delegateRemove(d.schemaChanged, runOn(this, this.az));
+                    this.av(c);
                 }
             }
-            for (let f = 0; f < a.count; f++) {
-                let g = a._inner[f];
-                this.ab.removeItem(g);
+            for (let d = 0; d < a.count; d++) {
+                let e = a._inner[d];
+                this.ah.removeItem(e);
             }
         }
-        a9(a) {
-            this.a3(a);
-            this.a2(a);
-            this.a8(a);
+        bj(a) {
+            this.bd(a);
+            this.bc(a);
+            this.bi(a);
         }
-        a3(a) {
+        bd(a) {
             let b = true;
             if (this.removingUnsupported != null) {
                 let c = ((() => {
@@ -1066,7 +1095,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 }
             }
         }
-        a8(a) {
+        bi(a) {
             let b = 0;
             for (; b < Math.min(this.dataSeries.count, a.getDataSeriesCount()); b++) {
                 if (!this.dataSeries._inner[b].equals(a.getDataSeriesAt(b))) {
@@ -1082,7 +1111,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 b--;
             }
         }
-        a2(a) {
+        bc(a) {
             let b = new Dictionary$2(String_$type, List$1.$.specialize(DataSeries.$), 0);
             for (let c = 0; c < a.getDataSeriesCount(); c++) {
                 let d = a.getDataSeriesAt(c);
@@ -1142,155 +1171,273 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 }
             }
         }
-        a7(a) {
+        bh(a) {
             for (let b = 0; b < this.rules.count; b++) {
-                this.a6(a, this.rules._inner[b]);
+                this.bg(a, this.rules._inner[b]);
             }
         }
-        a6(a, b) {
+        bg(a, b) {
             b.evaluate(a);
         }
-        get z() {
-            return this.sortDescriptions.k.count > 0 || this.groupDescriptions.k.count > 0 || this.filterExpressions.k.count > 0 || this.summaryDescriptions.k.count > 0;
+        get ad() {
+            return this.sortDescriptions.k.count > 0 || this.groupDescriptions.k.count > 0 || this.filterExpressions.k.count > 0 || this.highlightFilterExpressions.k.count > 0 || this.summaryDescriptions.k.count > 0;
         }
-        aa() {
+        af() {
             return this.groupDescriptions.k.count > 0 && this.postSortDescriptions.k.count > 0;
         }
-        n(a, b) {
-            let c = this.aa();
-            let d = 0;
-            if (typeCast(IDataSource_$type, a) !== null || (b && this.z)) {
-                if (c) {
-                    d = 2;
+        ae() {
+            return this.highlightFilterExpressions.k.count > 0;
+        }
+        h(a, b) {
+            let c = new DataSeriesAdapterProviderInfo();
+            let d = this.af();
+            let e = this.ae();
+            let f = 0;
+            if (typeCast(IDataSource_$type, a) !== null || (b && this.ad)) {
+                if (d || e) {
+                    f = 2;
                 }
                 else {
-                    d = 1;
+                    f = 1;
                 }
             }
-            if (a != null && this.ab.containsKey(a)) {
-                let e = this.ab.item(a);
-                e.c = true;
-                if (e.a != d) {
-                    let f = e.b;
-                    if (typeCast(AggregatedDataProvider.$, f) !== null) {
-                        let g = f;
-                        if (g.f != null) {
-                            this.sortDescriptions.syncTarget = null;
-                            this.groupDescriptions.syncTarget = null;
-                            this.filterExpressions.syncTarget = null;
-                            this.summaryDescriptions.syncTarget = null;
-                        }
-                    }
-                    if (typeCast(FlatDataProvider.$, f) !== null) {
-                    }
-                    f.updateNotifier = null;
-                    f.schemaChanged = delegateRemove(f.schemaChanged, runOn(this, this.az));
-                    this.ab.removeItem(a);
+            if (a != null && this.ah.containsKey(a)) {
+                let g = this.ah.item(a);
+                g.d = true;
+                if (g.a != f) {
+                    this.aw(this.ah, a, g);
                 }
                 else {
-                    return e.b;
+                    return g;
                 }
             }
             if (typeCast(IDataSourceLocalDataProvider_$type, a) !== null) {
-                return a;
+                c.c = a;
+                return c;
             }
             if (typeCast(IDataSource_$type, a) !== null) {
                 let h = new AggregatedDataProvider();
                 h.f = a;
-                this.sortDescriptions.syncTarget = h.f.sortDescriptions;
-                this.groupDescriptions.syncTarget = h.f.groupDescriptions;
-                this.filterExpressions.syncTarget = h.f.filterExpressions;
-                this.summaryDescriptions.syncTarget = h.f.summaryDescriptions;
-                return h;
-            }
-            if (b && this.z) {
-                let i = this.g.getLocalDataSource(a);
-                let j = new AggregatedDataProvider();
-                j.f = i;
-                this.sortDescriptions.syncTarget = j.f.sortDescriptions;
-                this.groupDescriptions.syncTarget = j.f.groupDescriptions;
-                this.filterExpressions.syncTarget = j.f.filterExpressions;
-                this.summaryDescriptions.syncTarget = j.f.summaryDescriptions;
-                if (d == 2) {
-                    let k = this.g.getLocalDataSource(null);
-                    k.dataProvider = j;
-                    let l = new FlatDataProvider();
-                    l.e = k;
-                    this.postSortDescriptions.syncTarget = l.e.sortDescriptions;
-                    return l;
+                this.sortDescriptions.o(h.f.sortDescriptions);
+                this.groupDescriptions.o(h.f.groupDescriptions);
+                this.filterExpressions.o(h.f.filterExpressions);
+                this.summaryDescriptions.o(h.f.summaryDescriptions);
+                c.e.add(() => {
+                    this.sortDescriptions.s(h.f.sortDescriptions);
+                    this.groupDescriptions.s(h.f.groupDescriptions);
+                    this.filterExpressions.s(h.f.filterExpressions);
+                    this.summaryDescriptions.s(h.f.summaryDescriptions);
+                });
+                if (f == 2) {
+                    let i = this.q(c, h);
+                    c.c = i;
+                    if (e) {
+                        this.ax(c);
+                    }
+                    return c;
+                }
+                c.c = h;
+                return c;
+            }
+            if (b && this.ad) {
+                let j = this.g.getLocalDataSource(a);
+                j.deferAutoRefresh = true;
+                let k = new AggregatedDataProvider();
+                k.f = j;
+                this.sortDescriptions.o(k.f.sortDescriptions);
+                this.groupDescriptions.o(k.f.groupDescriptions);
+                this.filterExpressions.o(k.f.filterExpressions);
+                this.summaryDescriptions.o(k.f.summaryDescriptions);
+                c.e.add(() => {
+                    this.sortDescriptions.s(k.f.sortDescriptions);
+                    this.groupDescriptions.s(k.f.groupDescriptions);
+                    this.filterExpressions.s(k.f.filterExpressions);
+                    this.summaryDescriptions.s(k.f.summaryDescriptions);
+                });
+                j.deferAutoRefresh = false;
+                if (f == 2) {
+                    let l = this.q(c, k);
+                    c.c = l;
+                    if (e) {
+                        this.ax(c);
+                    }
+                    return c;
                 }
-                return j;
+                c.c = k;
+                return c;
+            }
+            let m = this.g.getDataProvider(a);
+            c.c = m;
+            return c;
+        }
+        ax(a) {
+            let b = new DataSeriesAdapterRunContext(this);
+            a.c.flushAutoRefresh();
+            b.pushDataSource(a.c);
+            let c = this.aq(b, a);
+            if (c == null) {
+                return;
+            }
+            if (typeCast(FlatDataProvider.$, a.c) !== null) {
+                let d = a.c;
+                let e = d.m;
+                let f = e.clone();
+                let g = f.dataProvider;
+                let h = g.f;
+                this.highlightFilterExpressions.o(h.filterExpressions);
+                this.groupDescriptions.o(h.groupDescriptions);
+                this.sortDescriptions.o(h.sortDescriptions);
+                this.summaryDescriptions.o(h.summaryDescriptions);
+                a.e.add(() => {
+                    this.highlightFilterExpressions.s(h.filterExpressions);
+                    this.groupDescriptions.s(h.groupDescriptions);
+                    this.sortDescriptions.s(h.sortDescriptions);
+                    this.summaryDescriptions.s(h.summaryDescriptions);
+                });
+                f.flushAutoRefresh();
+                let i = new FlatDataProvider();
+                i.m = e;
+                i.l = f;
+                d.i = 1;
+                d.l = f;
+                d.ah = c;
+                d.ak = c;
+                d.g = 1;
+                i.i = 1;
+                i.l = f;
+                i.ah = c;
+                i.ak = c;
+                i.g = 2;
+                d.s = true;
+                a.c = d;
+                a.b = i;
+            }
+        }
+        aq(a, b) {
+            let c = -1;
+            let d = null;
+            for (let e = 0; e < this.rules.count; e++) {
+                let f = this.rules._inner[e].priority;
+                let g = this.rules._inner[e].getPrimaryAxisLabelsString(a);
+                if (g != null && f > c) {
+                    d = g;
+                    c = f;
+                }
+            }
+            return d;
+        }
+        q(a, b) {
+            let c = this.g.getLocalDataSource(null);
+            c.dataProvider = b;
+            let d = new FlatDataProvider();
+            d.m = c;
+            this.postSortDescriptions.o(d.m.sortDescriptions);
+            a.e.add(() => this.postSortDescriptions.s(d.m.sortDescriptions));
+            return d;
+        }
+        aw(a, b, c) {
+            this.av(c);
+            a.removeItem(b);
+        }
+        av(a) {
+            if (a.e.count > 0) {
+                for (let b = 0; b < a.e.count; b++) {
+                    let c = a.e._inner[b];
+                    c();
+                }
+                a.e.clear();
+            }
+            let d = a.c;
+            d.updateNotifier = null;
+            d.schemaChanged = delegateRemove(d.schemaChanged, runOn(this, this.a9));
+            let e = a.b;
+            if (e != null) {
+                e.updateNotifier = null;
+                e.schemaChanged = delegateRemove(e.schemaChanged, runOn(this, this.a9));
             }
-            return this.g.getDataProvider(a);
         }
-        a0(a, b, c, d) {
-            let e = this.n(b, false);
-            this.am(b, e, a.getCurrentDataSource(), d);
-            a.pushDataSource(e);
+        ba(a, b, c, d) {
+            let e = this.h(b, false);
+            this.at(b, e, a.getCurrentDataSource(), d);
+            a.pushDataSource(e.c);
+            if (e.b != null) {
+                a.pushHighlightingDataSource(e.b);
+            }
+            else {
+                a.pushHighlightingDataSource(null);
+            }
             a.pushPath(c);
-            this.a7(a);
+            this.bh(a);
             a.popPath();
             a.popDataSource();
+            a.popHighlightingDataSource();
         }
-        am(a, b, c, d) {
-            if (a != null && !this.ab.containsKey(a)) {
-                let e = new DataSeriesAdapterCachedProvider();
-                e.b = b;
-                e.a = 0;
-                if (typeCast(AggregatedDataProvider.$, b) !== null) {
-                    e.a = 1;
+        at(a, b, c, d) {
+            if (a != null && !this.ah.containsKey(a)) {
+                b.a = 0;
+                if (typeCast(AggregatedDataProvider.$, b.c) !== null) {
+                    b.a = 1;
+                }
+                else if (typeCast(FlatDataProvider.$, b.c) !== null) {
+                    b.a = 2;
                 }
-                else if (typeCast(FlatDataProvider.$, b) !== null) {
-                    e.a = 2;
+                b.d = true;
+                this.ah.addItem(a, b);
+                let e = b.c;
+                e.schemaChanged = delegateCombine(e.schemaChanged, runOn(this, this.a9));
+                if (b.b != null) {
+                    let f = b.b;
+                    f.schemaChanged = delegateCombine(f.schemaChanged, runOn(this, this.a9));
                 }
-                e.c = true;
-                this.ab.addItem(a, e);
-                b.schemaChanged = delegateCombine(b.schemaChanged, runOn(this, this.az));
                 if (c != null) {
-                    let f = new DataSeriesAdapterUpdateNotifier(this, b);
-                    c.updateNotifier = f;
+                    let g = new DataSeriesAdapterUpdateNotifier(this, b.c);
+                    c.updateNotifier = g;
                 }
                 if (d) {
-                    let g = new DataSeriesAdapterUpdateNotifier(this, b);
-                    b.updateNotifier = g;
+                    let h = new DataSeriesAdapterUpdateNotifier(this, b.c);
+                    b.c.updateNotifier = h;
+                    if (b.b != null) {
+                        let i = new DataSeriesAdapterUpdateNotifier(this, b.b);
+                        b.b.updateNotifier = h;
+                    }
                 }
             }
         }
-        az(a, b) {
-            if (!this.y) {
+        a9(a, b) {
+            if (!this.ac) {
                 this.refresh();
             }
         }
-        at(a) {
+        a3(a) {
             this.refresh();
         }
-        au(a, b, c) {
+        a4(a, b, c) {
             this.refresh();
         }
-        av(a, b, c) {
+        a5(a, b, c) {
             this.refresh();
         }
-        aw(a, b, c, d) {
+        a6(a, b, c, d) {
             this.refresh();
         }
         notifyClearItems(a) {
-            if (this.ab.containsKey(a)) {
-                this.ab.item(a).b.notifyClearItems();
+            if (this.ah.containsKey(a)) {
+                this.ah.item(a).c.notifyClearItems();
             }
         }
         notifyInsertItem(a, b, c) {
-            if (this.ab.containsKey(a)) {
-                this.ab.item(a).b.notifyInsertItem(b, c);
+            if (this.ah.containsKey(a)) {
+                this.ah.item(a).c.notifyInsertItem(b, c);
             }
         }
         notifyRemoveItem(a, b, c) {
-            if (this.ab.containsKey(a)) {
-                this.ab.item(a).b.notifyRemoveItem(b, c);
+            if (this.ah.containsKey(a)) {
+                this.ah.item(a).c.notifyRemoveItem(b, c);
             }
         }
         notifySetItem(a, b, c, d) {
-            if (this.ab.containsKey(a)) {
-                this.ab.item(a).b.notifySetItem(b, c, d);
+            if (this.ah.containsKey(a)) {
+                this.ah.item(a).c.notifySetItem(b, c, d);
             }
         }
     }