igniteui-angular-core 14.1.1 → 14.1.2

package/esm2015/lib/IDataSeriesAdapterRule_combined.js

@@ -18,7 +18,14 @@ import { stringIsNullOrEmpty, stringReplace, stringEmpty } from "./string";
 import { dateMinValue } from "./date";
 import { IDataSourceDataProviderUpdateNotifier_$type } from "./IDataSourceDataProviderUpdateNotifier";
 import { ObservableCollection$1 } from "./ObservableCollection$1";
+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 { FlatDataProvider } from "./FlatDataProvider";
 /**
  * @hidden
  */
@@ -64,7 +71,7 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this._analyzer = a;
         }
         getSubProvider(a, b) {
-            let c = this.g.l(a);
+            let c = this.g.n(a, false);
             this.pushDataSource(c);
             this.pushPath(b);
             return c;
@@ -74,10 +81,10 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this.popPath();
         }
         w(a, b) {
-            return this.g.v(a, b);
+            return this.g.aj(a, b);
         }
         recurseRules(a, b, c) {
-            this.g.al(this, a, b, c);
+            this.g.a0(this, a, b, c);
         }
         get includedProperties() {
             return this.b;
@@ -767,16 +774,16 @@ export let DataSeriesAdapterUpdateNotifier = /*@__PURE__*/ (() => {
             this.b = b;
         }
         notifyClearItems() {
-            this.a.ae(this.b);
+            this.a.at(this.b);
         }
         notifyInsertItem(a, b) {
-            this.a.af(this.b, a, b);
+            this.a.au(this.b, a, b);
         }
         notifyRemoveItem(a, b) {
-            this.a.ag(this.b, a, b);
+            this.a.av(this.b, a, b);
         }
         notifySetItem(a, b, c) {
-            this.a.ah(this.b, a, b, c);
+            this.a.aw(this.b, a, b, c);
         }
     }
     DataSeriesAdapterUpdateNotifier.$t = markType(DataSeriesAdapterUpdateNotifier, 'DataSeriesAdapterUpdateNotifier', Base.$, [IDataSourceDataProviderUpdateNotifier_$type]);
@@ -832,51 +839,77 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
     class DataSeriesAdapterImplementation extends Base {
         constructor() {
             super();
-            this.q = null;
-            this.r = null;
-            this.n = new Dictionary$2(Base.$, IDataSourceLocalDataProvider_$type, 0);
-            this.o = null;
+            this.x = false;
+            this.w = false;
+            this.ac = null;
+            this.ae = null;
+            this.ab = new Dictionary$2(Base.$, DataSeriesAdapterCachedProvider.$, 0);
+            this.ad = 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._rules = null;
             this._dataSeries = null;
-            this.m = false;
+            this.y = 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.rules = new DataSeriesAdapterRuleCollection();
             this.dataSeries = new DataSeriesCollection();
-            this.ai(this.rules);
+            this.ax(this.rules);
             let a = this.rules;
-            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.ap));
+            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;
+                this.refresh();
+            }
         }
-        v(a, b) {
+        aj(a, b) {
             let c = stringEmpty();
-            if (this.q != null) {
-                c = this.q(a);
+            if (this.ac != null) {
+                c = this.ac(a);
             }
             if (stringIsNullOrEmpty(c)) {
                 return b;
             }
             return c;
         }
-        ai(a) {
+        ax(a) {
         }
-        ap(a, b) {
+        a5(a, b) {
             this.refresh();
         }
         get g() {
-            return this.r;
+            return this.ae;
         }
         get itemsSource() {
-            return this.o;
+            return this.ad;
         }
         set itemsSource(a) {
-            let b = this.o;
-            this.o = a;
-            if (b != this.o) {
-                this.ad("ItemsSource", b, this.o);
+            let b = this.ad;
+            this.ad = a;
+            if (b != this.ad) {
+                this.as("ItemsSource", b, this.ad);
             }
         }
         get supportedSeriesTypes() {
@@ -886,7 +919,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.c;
             this.c = a;
             if (b != this.c) {
-                this.ad("SupportedSeriesTypes", b, this.c);
+                this.as("SupportedSeriesTypes", b, this.c);
             }
         }
         get includedProperties() {
@@ -896,7 +929,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.b;
             this.b = a;
             if (b != this.b) {
-                this.ad("IncludedProperties", b, this.b);
+                this.as("IncludedProperties", b, this.b);
             }
         }
         get excludedProperties() {
@@ -906,9 +939,24 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let b = this.a;
             this.a = a;
             if (b != this.a) {
-                this.ad("ExcludedProperties", b, this.a);
+                this.as("ExcludedProperties", b, this.a);
             }
         }
+        get sortDescriptions() {
+            return this.q;
+        }
+        get postSortDescriptions() {
+            return this.p;
+        }
+        get groupDescriptions() {
+            return this.o;
+        }
+        get filterExpressions() {
+            return this.l;
+        }
+        get summaryDescriptions() {
+            return this.u;
+        }
         get rules() {
             return this._rules;
         }
@@ -921,13 +969,13 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
         set dataSeries(a) {
             this._dataSeries = a;
         }
-        ad(a, b, c) {
-            this.aj(a, b, c);
+        as(a, b, c) {
+            this.ay(a, b, c);
             if (this.propertyChanged != null) {
                 this.propertyChanged(this, new PropertyChangedEventArgs(a));
             }
         }
-        aj(a, b, c) {
+        ay(a, b, c) {
             switch (a) {
                 case "ItemsSource":
                     this.refresh();
@@ -944,30 +992,54 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             }
         }
         refresh() {
-            this.m = true;
-            this.y();
+            this.y = true;
+            this.a4();
             let a = new DataSeriesAdapterRunContext(this);
-            let b = this.l(this.itemsSource);
-            this.x(b, null, false);
+            let b = this.n(this.itemsSource, true);
+            this.am(this.itemsSource, b, null, false);
             a.pushDataSource(b);
-            this.ar(a);
-            this.at(a);
-            this.m = false;
-        }
-        y() {
-            for (let a of fromEnum(this.n.keys)) {
-                let b = this.n.item(a);
-                b.updateNotifier = null;
-                b.schemaChanged = delegateRemove(b.schemaChanged, runOn(this, this.ak));
+            this.a7(a);
+            this.a9(a);
+            this.an();
+            this.y = false;
+        }
+        a4() {
+            for (let a of fromEnum(this.ab.keys)) {
+                let b = this.ab.item(a);
+                b.c = false;
+            }
+        }
+        an() {
+            let a = new List$1(Base.$, 0);
+            for (let b of fromEnum(this.ab.keys)) {
+                let c = this.ab.item(b);
+                if (!c.c) {
+                    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));
+                }
+            }
+            for (let f = 0; f < a.count; f++) {
+                let g = a._inner[f];
+                this.ab.removeItem(g);
             }
-            this.n.clear();
         }
-        at(a) {
-            this.ao(a);
-            this.an(a);
-            this.as(a);
+        a9(a) {
+            this.a3(a);
+            this.a2(a);
+            this.a8(a);
         }
-        ao(a) {
+        a3(a) {
             let b = true;
             if (this.removingUnsupported != null) {
                 let c = ((() => {
@@ -994,7 +1066,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 }
             }
         }
-        as(a) {
+        a8(a) {
             let b = 0;
             for (; b < Math.min(this.dataSeries.count, a.getDataSeriesCount()); b++) {
                 if (!this.dataSeries._inner[b].equals(a.getDataSeriesAt(b))) {
@@ -1010,7 +1082,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 b--;
             }
         }
-        an(a) {
+        a2(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);
@@ -1070,78 +1142,155 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 }
             }
         }
-        ar(a) {
+        a7(a) {
             for (let b = 0; b < this.rules.count; b++) {
-                this.aq(a, this.rules._inner[b]);
+                this.a6(a, this.rules._inner[b]);
             }
         }
-        aq(a, b) {
+        a6(a, b) {
             b.evaluate(a);
         }
-        l(a) {
-            if (a != null && this.n.containsKey(a)) {
-                return this.n.item(a);
+        get z() {
+            return this.sortDescriptions.k.count > 0 || this.groupDescriptions.k.count > 0 || this.filterExpressions.k.count > 0 || this.summaryDescriptions.k.count > 0;
+        }
+        aa() {
+            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;
+                }
+                else {
+                    d = 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);
+                }
+                else {
+                    return e.b;
+                }
+            }
+            if (typeCast(IDataSourceLocalDataProvider_$type, a) !== null) {
+                return a;
+            }
+            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;
+                }
+                return j;
             }
             return this.g.getDataProvider(a);
         }
-        al(a, b, c, d) {
-            let e = this.l(b);
-            this.x(e, a.getCurrentDataSource(), d);
+        a0(a, b, c, d) {
+            let e = this.n(b, false);
+            this.am(b, e, a.getCurrentDataSource(), d);
             a.pushDataSource(e);
             a.pushPath(c);
-            this.ar(a);
+            this.a7(a);
             a.popPath();
             a.popDataSource();
         }
-        x(a, b, c) {
-            if (a.dataSource != null) {
-                this.n.addItem(a.dataSource, a);
-            }
-            a.schemaChanged = delegateCombine(a.schemaChanged, runOn(this, this.ak));
-            if (b != null) {
-                let d = new DataSeriesAdapterUpdateNotifier(this, a);
-                b.updateNotifier = d;
-            }
-            if (c) {
-                let e = new DataSeriesAdapterUpdateNotifier(this, a);
-                a.updateNotifier = e;
+        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;
+                }
+                else if (typeCast(FlatDataProvider.$, b) !== null) {
+                    e.a = 2;
+                }
+                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;
+                }
+                if (d) {
+                    let g = new DataSeriesAdapterUpdateNotifier(this, b);
+                    b.updateNotifier = g;
+                }
             }
         }
-        ak(a, b) {
-            if (!this.m) {
+        az(a, b) {
+            if (!this.y) {
                 this.refresh();
             }
         }
-        ae(a) {
+        at(a) {
             this.refresh();
         }
-        af(a, b, c) {
+        au(a, b, c) {
             this.refresh();
         }
-        ag(a, b, c) {
+        av(a, b, c) {
             this.refresh();
         }
-        ah(a, b, c, d) {
+        aw(a, b, c, d) {
             this.refresh();
         }
         notifyClearItems(a) {
-            if (this.n.containsKey(a)) {
-                this.n.item(a).notifyClearItems();
+            if (this.ab.containsKey(a)) {
+                this.ab.item(a).b.notifyClearItems();
             }
         }
         notifyInsertItem(a, b, c) {
-            if (this.n.containsKey(a)) {
-                this.n.item(a).notifyInsertItem(b, c);
+            if (this.ab.containsKey(a)) {
+                this.ab.item(a).b.notifyInsertItem(b, c);
             }
         }
         notifyRemoveItem(a, b, c) {
-            if (this.n.containsKey(a)) {
-                this.n.item(a).notifyRemoveItem(b, c);
+            if (this.ab.containsKey(a)) {
+                this.ab.item(a).b.notifyRemoveItem(b, c);
             }
         }
         notifySetItem(a, b, c, d) {
-            if (this.n.containsKey(a)) {
-                this.n.item(a).notifySetItem(b, c, d);
+            if (this.ab.containsKey(a)) {
+                this.ab.item(a).b.notifySetItem(b, c, d);
             }
         }
     }

package/esm2015/lib/IDataSourceDataProvider_combined.js

@@ -64,6 +64,12 @@ export let FilterExpressionCollection = /*@__PURE__*/ (() => {
             this.a = a;
             this.f.syncTarget = this.a.f;
         }
+        get shouldDetachOnTargetChange() {
+            return this.f.shouldDetachOnTargetChange;
+        }
+        set shouldDetachOnTargetChange(a) {
+            this.f.shouldDetachOnTargetChange = a;
+        }
         add(a) {
             return this.f.add(a);
         }
@@ -97,13 +103,13 @@ export let FilterExpressionCollection = /*@__PURE__*/ (() => {
         set onChanged(a) {
             this.f.f = a;
         }
-        m(a) {
+        n(a) {
             this.f.addListener(a);
         }
-        p(a) {
+        q(a) {
             this.f.removeListener(a);
         }
-        get j() {
+        get k() {
             return this.f.all;
         }
     }
@@ -582,6 +588,7 @@ export let SummaryDescription = /*@__PURE__*/ (() => {
             this.h = false;
             this.k = null;
             this.f = 0;
+            this._alias = null;
             this.b = null;
             this.provideCalculator = null;
             a = (a == void 0) ? 0 : a;
@@ -633,6 +640,12 @@ export let SummaryDescription = /*@__PURE__*/ (() => {
                     break;
             }
         }
+        get alias() {
+            return this._alias;
+        }
+        set alias(a) {
+            this._alias = a;
+        }
         get calculator() {
             return this.b;
         }
@@ -649,7 +662,7 @@ export let SummaryDescription = /*@__PURE__*/ (() => {
         getHashCode() {
             return Base.getHashCodeStatic(this.propertyName) * 17 + this.operand;
         }
-        m() {
+        n() {
             this.h = true;
         }
         e() {
@@ -824,7 +837,7 @@ export let BaseDataSource = /*@__PURE__*/ (() => {
             this.r.n(runOn(this, this.bx));
             this.t.n(runOn(this, this.cu));
             this.i = new FilterExpressionCollection();
-            this.i.m(runOn(this, this.bv));
+            this.i.n(runOn(this, this.bv));
             this.u = new TransactionService(runOn(this, this.bz), runOn(this, this.clone1), new TransactionKeyEqualityComparer());
             let a = this.u;
             a.stateChanged = delegateCombine(a.stateChanged, runOn(this, this.cp));
@@ -2182,8 +2195,8 @@ export let BaseDataSource = /*@__PURE__*/ (() => {
                 for (let d = 0; d < this.sortDescriptions.k.count; d++) {
                     b.sortDescriptions.add(this.sortDescriptions.k.item(d));
                 }
-                for (let e = 0; e < this.filterExpressions.j.count; e++) {
-                    b.filterExpressions.add(this.filterExpressions.j.item(e));
+                for (let e = 0; e < this.filterExpressions.k.count; e++) {
+                    b.filterExpressions.add(this.filterExpressions.k.item(e));
                 }
                 for (let f = 0; f < this.summaryDescriptions.k.count; f++) {
                     b.summaryDescriptions.add(this.summaryDescriptions.k.item(f));

package/esm2015/lib/INativeUIAbsolutePanelBridge.js

@@ -0,0 +1,12 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+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 { INativeUIContainerBridge_$type } from "./INativeUIContainerBridge";
+import { Type } from "./type";
+/**
+ * @hidden
+ */
+export let INativeUIAbsolutePanelBridge_$type = new Type(null, 'INativeUIAbsolutePanelBridge', null, [INativeUIContainerBridge_$type]);