igniteui-angular-core 19.0.1 → 19.1.0-beta.1

package/esm2015/lib/IDataSeriesAdapterRule_combined.js

@@ -10,9 +10,10 @@ import { Stack$1 } from "./Stack$1";
 import { IDataSourceLocalDataProvider_$type } from "./IDataSourceLocalDataProvider";
 import { HashSet$1 } from "./HashSet$1";
 import { DataSeriesType_$type } from "./DataSeriesType";
+import { List$1 } from "./List$1";
+import { DataSeriesPropertyType_$type } from "./DataSeriesPropertyType";
 import { DataSeriesAdapterProviderInfo } from "./DataSeriesAdapterProviderInfo";
 import { DataSeries } from "./DataSeries";
-import { List$1 } from "./List$1";
 import { Matcher } from "./Matcher";
 import { DataSeriesIntent_$type } from "./DataSeriesIntent";
 import { stringIsNullOrEmpty, stringReplace, stringEmpty } from "./string";
@@ -24,7 +25,6 @@ import { SortDescriptionCollection } from "./SortDescriptionCollection";
 import { FilterExpressionCollection } from "./FilterExpressionCollection";
 import { SummaryDescriptionCollection } from "./SummaryDescriptionCollection";
 import { Dictionary$2 } from "./Dictionary$2";
-import { Tuple$2 } from "./Tuple$2";
 import { IDataSource_$type } from "./IDataSource";
 import { AggregatedDataProvider } from "./AggregatedDataProvider";
 import { FlatDataProvider } from "./FlatDataProvider";
@@ -39,34 +39,41 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
     class DataSeriesAdapterRunContext extends Base {
         constructor(a) {
             super();
-            this.g = null;
+            this.k = null;
             this._analyzer = null;
-            this.h = null;
-            this.p = null;
-            this.q = null;
-            this.s = null;
-            this.r = null;
+            this.l = null;
+            this.w = null;
+            this.x = null;
+            this.z = null;
+            this.y = null;
             this.b = null;
             this.a = null;
-            this.o = null;
-            this.l = false;
-            this.g = a;
+            this.s = null;
+            this.p = false;
+            this.t = null;
+            this.u = null;
+            this.v = null;
+            this.i = 0;
+            this.k = a;
             this.analyzer = new DataSeriesDataProviderAnalyzer(this);
-            this.analyzer.includedProperties = this.g.includedProperties;
-            this.analyzer.excludedProperties = this.g.excludedProperties;
-            this.h = new DataSeriesCollection();
-            this.p = new Stack$1(IDataSourceLocalDataProvider_$type);
-            this.q = new Stack$1(IDataSourceLocalDataProvider_$type);
-            this.s = new Stack$1(String_$type);
-            this.r = new Stack$1(String_$type);
-            this.b = this.g.includedProperties;
-            this.a = this.g.excludedProperties;
-            this.o = null;
-            this.l = this.g.adjustPrioritiesBasedOnFitness;
-            if (this.g.supportedSeriesTypes != null) {
-                this.o = new HashSet$1(DataSeriesType_$type, 0);
-                for (let b = 0; b < this.g.supportedSeriesTypes.length; b++) {
-                    this.o.add_1(this.g.supportedSeriesTypes[b]);
+            this.analyzer.includedProperties = this.k.includedProperties;
+            this.analyzer.excludedProperties = this.k.excludedProperties;
+            this.l = new DataSeriesCollection();
+            this.w = new Stack$1(IDataSourceLocalDataProvider_$type);
+            this.x = new Stack$1(IDataSourceLocalDataProvider_$type);
+            this.z = new Stack$1(String_$type);
+            this.y = new Stack$1(String_$type);
+            this.b = this.k.includedProperties;
+            this.a = this.k.excludedProperties;
+            this.s = null;
+            this.p = this.k.adjustPrioritiesBasedOnFitness;
+            this.t = new List$1(String_$type, 0);
+            this.u = new List$1(String_$type, 0);
+            this.v = new List$1(DataSeriesPropertyType_$type, 0);
+            if (this.k.supportedSeriesTypes != null) {
+                this.s = new HashSet$1(DataSeriesType_$type, 0);
+                for (let b = 0; b < this.k.supportedSeriesTypes.length; b++) {
+                    this.s.add_1(this.k.supportedSeriesTypes[b]);
                 }
             }
         }
@@ -77,7 +84,7 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this._analyzer = a;
         }
         getSubProvider(a, b) {
-            let c = this.g.h(a, false);
+            let c = this.k.h(a, false);
             this.pushDataSource(c.c);
             if (c.b != null) {
                 this.pushHighlightingDataSource(c.b);
@@ -93,14 +100,14 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             this.popHighlightingDataSource();
             this.popPath();
         }
-        ab(a, b) {
-            return this.g.aq(a, b);
+        aj(a, b) {
+            return this.k.aq(a, b);
         }
         recurseRules(a, b, c) {
-            this.g.bc(this, a, b, c);
+            this.k.bc(this, a, b, c);
         }
         get adjustPrioritiesBasedOnFitness() {
-            return this.l;
+            return this.p;
         }
         get includedProperties() {
             return this.b;
@@ -109,39 +116,73 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             return this.a;
         }
         getCurrentDataSource() {
-            return this.p.d();
+            return this.w.d();
         }
         getCurrentHighlightingDataSource() {
-            return this.q.d();
+            return this.x.d();
         }
         pushDataSource(a) {
-            this.p.h(a);
+            this.w.h(a);
         }
         pushHighlightingDataSource(a) {
-            this.q.h(a);
+            this.x.h(a);
         }
         hasValidType(a) {
-            if (this.o == null) {
+            if (this.s == null) {
                 return true;
             }
-            if (this.o.contains(a.suggestedSeries)) {
+            if (this.s.contains(a.suggestedSeries)) {
                 return true;
             }
             return false;
         }
+        j() {
+            return this.i;
+        }
+        ay(a) {
+            this.i = a;
+        }
+        al(a) {
+            this.t.add(a);
+        }
+        d() {
+            let a = new Array(this.t.count);
+            let b = 0;
+            for (let c of fromEnum(this.t)) {
+                a[b] = c;
+                b++;
+            }
+            return a;
+        }
+        ao() {
+            this.u.clear();
+            this.t.clear();
+            this.v.clear();
+        }
+        am(a, b, c) {
+            this.u.add(a);
+            this.t.add(b);
+            this.v.add(c);
+        }
+        h(a) {
+            return this.v._inner[a];
+        }
+        ai(a) {
+            return this.u._inner[a];
+        }
         popDataSource() {
-            return this.p.e();
+            return this.w.e();
         }
         popHighlightingDataSource() {
-            return this.q.e();
+            return this.x.e();
         }
         getCurrentPathSegment() {
-            return this.s.d();
+            return this.z.d();
         }
         getCurrentPath() {
             let a = "";
             let b = true;
-            for (let c of fromEnum(this.s)) {
+            for (let c of fromEnum(this.z)) {
                 if (b) {
                     b = false;
                 }
@@ -153,24 +194,24 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             return a;
         }
         getParentTitle() {
-            if (this.r.f == 0) {
+            if (this.y.f == 0) {
                 return null;
             }
-            return this.r.d();
+            return this.y.d();
         }
         pushPath(a) {
-            this.s.h(a);
+            this.z.h(a);
         }
         popPath() {
-            return this.s.e();
+            return this.z.e();
         }
         pushParentTitle(a) {
-            this.r.h(a);
+            this.y.h(a);
         }
         popParentTitle() {
-            return this.r.e();
+            return this.y.e();
         }
-        ag(a, b) {
+        ar(a, b) {
             if (a.priority == -1) {
                 a.priority = b.priority;
             }
@@ -188,24 +229,24 @@ export let DataSeriesAdapterRunContext = /*@__PURE__*/ (() => {
             }
         }
         addDataSeries(a, b) {
-            this.ag(a, b);
-            this.h.add(a);
+            this.ar(a, b);
+            this.l.add(a);
         }
         removeDataSeries(a) {
-            this.h.remove(a);
+            this.l.remove(a);
         }
         insertDataSeries(a, b, c) {
-            this.ag(b, c);
-            this.h.insert(a, b);
+            this.ar(b, c);
+            this.l.insert(a, b);
         }
         clearDataSeries() {
-            this.h.clear();
+            this.l.clear();
         }
         getDataSeriesCount() {
-            return this.h.count;
+            return this.l.count;
         }
         getDataSeriesAt(a) {
-            return this.h._inner[a];
+            return this.l._inner[a];
         }
     }
     DataSeriesAdapterRunContext.$t = markType(DataSeriesAdapterRunContext, 'DataSeriesAdapterRunContext');
@@ -1211,7 +1252,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 a.pushHighlightingDataSource(null);
             }
             this.bj(a);
-            this.bl(a);
+            this.br(a);
             this.av();
             this.ac = false;
         }
@@ -1219,49 +1260,105 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             let c = new DataSeriesAdapterRunContext(this);
             let d = this.h(this.itemsSource, true);
             c.pushDataSource(d.c);
-            a.clear();
-            let e = new HashSet$1(String_$type, 0);
-            b.clear();
-            for (let f = 0; f < this.rules.count; f++) {
-                let g = this.rules._inner[f];
-                let h = g.getPrimaryAxisLabelsStrings(c);
-                if (h != null) {
-                    for (let j = 0; j < h.length; j++) {
-                        let i = h[j];
-                        if (i == null) {
+            let e = new List$1(String_$type, 0);
+            let f = new List$1(String_$type, 0);
+            let g = new List$1(DataSeriesPropertyType_$type, 0);
+            let h = new HashSet$1(String_$type, 0);
+            for (let i = 0; i < this.rules.count; i++) {
+                let j = this.rules._inner[i];
+                let k = j.getPrimaryAxisLabelsStrings(c);
+                if (k != null) {
+                    for (let l = 0; l < k.length; l++) {
+                        let m = k[l];
+                        if (m == null) {
                             continue;
                         }
-                        e.add_1(i);
-                        a.add_1(new Tuple$2(String_$type, String_$type, i, c.analyzer.expandCamelCasedWords(i)));
+                        h.add_1(m);
+                        let n = c.ai(l);
+                        if (stringIsNullOrEmpty(n)) {
+                            e.add(m);
+                            f.add(c.analyzer.expandCamelCasedWords(m));
+                        }
+                        else {
+                            e.add(n + "." + m);
+                            f.add(n + "." + c.analyzer.expandCamelCasedWords(m));
+                        }
+                        g.add(c.h(l));
                     }
                 }
             }
-            for (let k = 0; k < this.rules.count; k++) {
-                let l = this.rules._inner[k];
-                let m = l.getAdditionalValuePropertyStrings(c);
-                if (m != null) {
-                    for (let o = 0; o < m.length; o++) {
-                        let n = m[o];
-                        if (n == null) {
+            a.b = e.toArray();
+            a.a = f.toArray();
+            a.c = g.toArray();
+            e = new List$1(String_$type, 0);
+            f = new List$1(String_$type, 0);
+            g = new List$1(DataSeriesPropertyType_$type, 0);
+            c.ao();
+            for (let o = 0; o < this.rules.count; o++) {
+                let p = this.rules._inner[o];
+                let q = p.getAdditionalValuePropertyStrings(c);
+                if (q != null) {
+                    for (let r = 0; r < q.length; r++) {
+                        let s = q[r];
+                        if (s == null) {
                             continue;
                         }
-                        if (e.contains(n)) {
+                        if (h.contains(s)) {
                             continue;
                         }
-                        b.add_1(new Tuple$2(String_$type, String_$type, n, c.analyzer.expandCamelCasedWords(n)));
+                        let t = c.ai(r);
+                        if (stringIsNullOrEmpty(t)) {
+                            e.add(s);
+                            f.add(c.analyzer.expandCamelCasedWords(s));
+                        }
+                        else {
+                            e.add(t + "." + s);
+                            f.add(t + "." + c.analyzer.expandCamelCasedWords(s));
+                        }
+                        g.add(c.h(r));
                     }
                 }
             }
             if (d.c.actualSchema != null) {
-                let p = d.c.actualSchema.propertyNames;
-                for (let r = 0; r < p.length; r++) {
-                    let q = p[r];
-                    if (e.contains(q) && p.length > 1) {
-                        continue;
+                let u = d.c.actualSchema.propertyNames;
+                for (let v = 0; v < u.length; v++) {
+                    let w = u[v];
+                    let x = d.c.actualSchema.propertyTypes[v];
+                    let y = x == 0 ? 0 : x == 8 || x == 9 ? 1 : 2;
+                    if (h.contains(w) && u.length > 1) {
+                        if (h.count <= 1) {
+                            continue;
+                        }
+                        else {
+                            if (y == 2) {
+                                h.remove(w);
+                                let z = new List$1(String_$type, 0);
+                                let aa = new List$1(String_$type, 0);
+                                let ab = new List$1(DataSeriesPropertyType_$type, 0);
+                                for (let ac = 0; ac < a.b.length; ac++) {
+                                    if (!Base.equalsStatic(a.b[ac], w)) {
+                                        z.add(a.b[ac]);
+                                        aa.add(a.a[ac]);
+                                        ab.add(a.c[ac]);
+                                    }
+                                }
+                                a.b = z.toArray();
+                                a.a = aa.toArray();
+                                a.c = ab.toArray();
+                            }
+                            else {
+                                continue;
+                            }
+                        }
                     }
-                    b.add_1(new Tuple$2(String_$type, String_$type, q, c.analyzer.expandCamelCasedWords(q)));
+                    e.add(w);
+                    f.add(c.analyzer.expandCamelCasedWords(w));
+                    g.add(y);
                 }
             }
+            b.b = e.toArray();
+            b.a = f.toArray();
+            b.c = g.toArray();
         }
         bg() {
             for (let a of fromEnum(this.ai.keys)) {
@@ -1283,10 +1380,10 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 this.ai.removeItem(e);
             }
         }
-        bl(a) {
+        br(a) {
             this.bf(a);
             this.be(a);
-            this.bk(a);
+            this.bn(a);
         }
         bf(a) {
             let b = true;
@@ -1315,7 +1412,7 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 }
             }
         }
-        bk(a) {
+        bn(a) {
             let b = 0;
             for (; b < Math.min(this.dataSeries.count, a.getDataSeriesCount()); b++) {
                 if (!this.dataSeries._inner[b].equals(a.getDataSeriesAt(b))) {
@@ -1397,7 +1494,16 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             }
         }
         bi(a, b) {
-            b.evaluate(a);
+            let c = a.j();
+            if (c == 0 || c == 1) {
+                b.evaluate(a);
+            }
+            else if (c == 2) {
+                b.getPrimaryAxisLabelsStrings(a);
+            }
+            else if (c == 3) {
+                b.getAdditionalValuePropertyStrings(a);
+            }
         }
         get ae() {
             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;
@@ -1444,15 +1550,17 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             if (typeCast(IDataSource_$type, a) !== null) {
                 let h = new AggregatedDataProvider();
                 h.targetDataSource = a;
-                this.sortDescriptions.o(h.targetDataSource.sortDescriptions);
-                this.groupDescriptions.o(h.targetDataSource.groupDescriptions);
-                this.filterExpressions.o(h.targetDataSource.filterExpressions);
-                this.summaryDescriptions.o(h.targetDataSource.summaryDescriptions);
+                h.schemaIncludedProperties = h.targetDataSource.schemaIncludedProperties;
+                h.propertiesRequested = h.targetDataSource.propertiesRequested;
+                this.bl(this.sortDescriptions, h.targetDataSource, h.targetDataSource.sortDescriptions);
+                this.bl(this.groupDescriptions, h.targetDataSource, h.targetDataSource.groupDescriptions);
+                this.bk(this.filterExpressions, h.targetDataSource, h.targetDataSource.filterExpressions);
+                this.bm(this.summaryDescriptions, h.targetDataSource, h.targetDataSource.summaryDescriptions);
                 c.e.add(() => {
-                    this.sortDescriptions.s(h.targetDataSource.sortDescriptions);
-                    this.groupDescriptions.s(h.targetDataSource.groupDescriptions);
-                    this.filterExpressions.s(h.targetDataSource.filterExpressions);
-                    this.summaryDescriptions.s(h.targetDataSource.summaryDescriptions);
+                    this.bp(this.sortDescriptions, h.targetDataSource, h.targetDataSource.sortDescriptions);
+                    this.bp(this.groupDescriptions, h.targetDataSource, h.targetDataSource.groupDescriptions);
+                    this.bo(this.filterExpressions, h.targetDataSource, h.targetDataSource.filterExpressions);
+                    this.bq(this.summaryDescriptions, h.targetDataSource, h.targetDataSource.summaryDescriptions);
                 });
                 if (f == 2) {
                     let i = this.q(c, h);
@@ -1476,15 +1584,15 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 j.deferAutoRefresh = true;
                 let k = new AggregatedDataProvider();
                 k.targetDataSource = j;
-                this.sortDescriptions.o(k.targetDataSource.sortDescriptions);
-                this.groupDescriptions.o(k.targetDataSource.groupDescriptions);
-                this.filterExpressions.o(k.targetDataSource.filterExpressions);
-                this.summaryDescriptions.o(k.targetDataSource.summaryDescriptions);
+                this.bl(this.sortDescriptions, k.targetDataSource, k.targetDataSource.sortDescriptions);
+                this.bl(this.groupDescriptions, k.targetDataSource, k.targetDataSource.groupDescriptions);
+                this.bk(this.filterExpressions, k.targetDataSource, k.targetDataSource.filterExpressions);
+                this.bm(this.summaryDescriptions, k.targetDataSource, k.targetDataSource.summaryDescriptions);
                 c.e.add(() => {
-                    this.sortDescriptions.s(k.targetDataSource.sortDescriptions);
-                    this.groupDescriptions.s(k.targetDataSource.groupDescriptions);
-                    this.filterExpressions.s(k.targetDataSource.filterExpressions);
-                    this.summaryDescriptions.s(k.targetDataSource.summaryDescriptions);
+                    this.bp(this.sortDescriptions, k.targetDataSource, k.targetDataSource.sortDescriptions);
+                    this.bp(this.groupDescriptions, k.targetDataSource, k.targetDataSource.groupDescriptions);
+                    this.bo(this.filterExpressions, k.targetDataSource, k.targetDataSource.filterExpressions);
+                    this.bq(this.summaryDescriptions, k.targetDataSource, k.targetDataSource.summaryDescriptions);
                 });
                 j.deferAutoRefresh = false;
                 if (f == 2) {
@@ -1502,6 +1610,69 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             c.c = m;
             return c;
         }
+        bl(a, b, c) {
+            if (b == this.itemsSource) {
+                a.syncTarget = c;
+            }
+            else {
+                a.o(c);
+            }
+        }
+        bp(a, b, c) {
+            if (b == this.itemsSource) {
+                if (a.syncTarget == c) {
+                    a.syncTarget = null;
+                }
+                else {
+                    a.s(c);
+                }
+            }
+            else {
+                a.s(c);
+            }
+        }
+        bm(a, b, c) {
+            if (b == this.itemsSource) {
+                a.syncTarget = c;
+            }
+            else {
+                a.o(c);
+            }
+        }
+        bq(a, b, c) {
+            if (b == this.itemsSource) {
+                if (a.syncTarget == c) {
+                    a.syncTarget = null;
+                }
+                else {
+                    a.s(c);
+                }
+            }
+            else {
+                a.s(c);
+            }
+        }
+        bk(a, b, c) {
+            if (b == this.itemsSource) {
+                a.syncTarget = c;
+            }
+            else {
+                a.o(c);
+            }
+        }
+        bo(a, b, c) {
+            if (b == this.itemsSource) {
+                if (a.syncTarget == c) {
+                    a.syncTarget = null;
+                }
+                else {
+                    a.s(c);
+                }
+            }
+            else {
+                a.s(c);
+            }
+        }
         ay(a) {
             let b = new DataSeriesAdapterRunContext(this);
             a.c.flushAutoRefresh();
@@ -1516,15 +1687,15 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
                 let f = e.clone();
                 let g = f.dataProvider;
                 let h = g.targetDataSource;
-                this.highlightFilterExpressions.o(h.filterExpressions);
-                this.groupDescriptions.o(h.groupDescriptions);
-                this.sortDescriptions.o(h.sortDescriptions);
-                this.summaryDescriptions.o(h.summaryDescriptions);
+                this.bk(this.highlightFilterExpressions, h, h.filterExpressions);
+                this.bl(this.groupDescriptions, h, h.groupDescriptions);
+                this.bl(this.sortDescriptions, h, h.sortDescriptions);
+                this.bm(this.summaryDescriptions, h, 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);
+                    this.bo(this.highlightFilterExpressions, h, h.filterExpressions);
+                    this.bp(this.groupDescriptions, h, h.groupDescriptions);
+                    this.bp(this.sortDescriptions, h, h.sortDescriptions);
+                    this.bq(this.summaryDescriptions, h, h.summaryDescriptions);
                 });
                 f.flushAutoRefresh();
                 let i = new FlatDataProvider();
@@ -1564,8 +1735,8 @@ export let DataSeriesAdapterImplementation = /*@__PURE__*/ (() => {
             c.dataProvider = b;
             let d = new FlatDataProvider();
             d.targetDataSource = c;
-            this.postSortDescriptions.o(d.targetDataSource.sortDescriptions);
-            a.e.add(() => this.postSortDescriptions.s(d.targetDataSource.sortDescriptions));
+            this.bl(this.postSortDescriptions, d.targetDataSource, d.targetDataSource.sortDescriptions);
+            a.e.add(() => this.bp(this.postSortDescriptions, d.targetDataSource, d.targetDataSource.sortDescriptions));
             return d;
         }
         ax(a, b, c) {