igniteui-webcomponents-layouts 7.1.1-beta.2 → 7.1.1-beta.4

package/esm2022/lib/PropertyEditorDataSource_combined.js

@@ -0,0 +1,694 @@
+/*
+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 { Base, INotifyPropertyChanged_$type, PropertyChangedEventArgs, String_$type, typeCast, markType, enumGetBox, EventArgs } from "igniteui-webcomponents-core";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { PropertyEditorValueType_$type } from "./PropertyEditorValueType";
+import { List$1 } from "igniteui-webcomponents-core";
+import { stringEndsWith, stringContains, stringReplace } from "igniteui-webcomponents-core";
+import { stringSplit } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescriptionButtonClickEventArgs } from "./PropertyEditorPropertyDescriptionButtonClickEventArgs";
+import { PropertyEditorPropertyDescriptionChangedEventArgs } from "./PropertyEditorPropertyDescriptionChangedEventArgs";
+import { PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs } from "./PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs";
+import { ObservableCollection$1 } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+class PropertyEditorDataSource extends Base {
+    constructor() {
+        super(...arguments);
+        this.k = null;
+        this.a = null;
+        this.g = null;
+        this.propertyChanged = null;
+        this.j = null;
+    }
+    static { this.$t = markType(PropertyEditorDataSource, 'PropertyEditorDataSource', Base.$, [INotifyPropertyChanged_$type]); }
+    get n() {
+        return this.k;
+    }
+    set n(a) {
+        let b = this.k;
+        this.k = a;
+        this.p("DescriptionType", b, this.k);
+    }
+    get b() {
+        return this.a;
+    }
+    set b(a) {
+        let b = this.a;
+        this.a = a;
+        this.p("Context", b, this.a);
+    }
+    get h() {
+        return this.g;
+    }
+    set h(a) {
+        let b = this.g;
+        this.g = a;
+        this.p("Data", b, this.g);
+    }
+    p(a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.q(a, b, c);
+    }
+    q(a, b, c) {
+        switch (a) {
+            case "DescriptionType":
+                this.r();
+                break;
+            case "Context":
+                this.r();
+                break;
+        }
+    }
+    static d(a, b, c) {
+        let d = new PropertyEditorDataSource();
+        d.j = c;
+        d.b = a;
+        d.n = b;
+        d.j = null;
+        return d;
+    }
+    f(a) {
+        let b = new PropertyEditorPropertyDescription();
+        b.a3 = a.propertyName;
+        b.w = this.i(a);
+        b.a2 = a.specificExternalType != null ? a.specificExternalType : a.specificType;
+        if (a.knownType == 9) {
+            b.ay = a.collectionElementType;
+            if (this.j != null && this.j.containsKey(b.ay)) {
+                b.e = this.j.item(b.ay);
+            }
+            else {
+                b.e = PropertyEditorDataSource.d(this.a, b.ay, this.j);
+            }
+        }
+        if (b.w == 8) {
+            if (this.j != null && this.j.containsKey(b.a2)) {
+                b.e = this.j.item(b.a2);
+            }
+            else {
+                b.e = PropertyEditorDataSource.d(this.a, b.a2, this.j);
+            }
+        }
+        if (b.w == 15) {
+            b.c = this.a.c(this.n, b.a3);
+            b.d = b.d;
+        }
+        return b;
+    }
+    i(a) {
+        switch (a.knownType) {
+            case 10: return 10;
+            case 7: return 7;
+            case 4: return 4;
+            case 6: return 6;
+            case 23: return 23;
+            case 9: return 9;
+            case 5: return 5;
+            case 16: return 14;
+            case 20: return 18;
+            case 22: return 22;
+            case 15: return 0;
+            case 3: return 3;
+            case 19: return 17;
+            case 8:
+                if (a.specificExternalType == "string") {
+                    return 15;
+                }
+                return 8;
+            case 13: return 0;
+            case 18: return 0;
+            case 1: return 1;
+            case 11: return 11;
+            case 14: return 13;
+            case 12: return 12;
+            case 2: return 2;
+            case 21: return 19;
+            case 17: return 0;
+            case 0: return 0;
+        }
+        return 0;
+    }
+    r() {
+        let a = new PropertyEditorPropertyDescriptionCollection();
+        if (this.n != null && this.b != null) {
+            let b = false;
+            if (this.j == null) {
+                b = true;
+                this.j = new Dictionary$2(String_$type, PropertyEditorDataSource.$, 0);
+            }
+            this.j.item(this.n, this);
+            let c = this.b.getAllProperties(this.n);
+            if (c == null) {
+                return;
+            }
+            for (let d = 0; d < c.length; d++) {
+                if (stringEndsWith(c[d], "@names")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@args")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@nameBinding")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@ngQueryList")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@mustSetInCode")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@stringUnion")) {
+                    continue;
+                }
+                if (stringEndsWith(c[d], "@constantValues")) {
+                    continue;
+                }
+                let e = this.b.getMetadata(this.n, c[d]);
+                let f = this.f(e);
+                if (f.w == 0) {
+                    continue;
+                }
+                a.add(f);
+            }
+            if (b) {
+                this.j = null;
+            }
+        }
+        this.h = a;
+    }
+    e(a, b) {
+        if (a == null) {
+            return null;
+        }
+        let c = stringSplit(a, ['.', '['], 0);
+        let d = new List$1(String_$type, 1, c);
+        let e = null;
+        let f = null;
+        let g = null;
+        while (d.count > 0) {
+            let h = d._inner[0];
+            d.removeAt(0);
+            let i = false;
+            if (stringContains(h, "]")) {
+                h = stringReplace(h, "]", "");
+                i = true;
+                let j = h.split(',');
+                h = j[0].trim();
+                if (stringContains(h, "as")) {
+                    let k = h.indexOf("as");
+                    g = h.substr(0, k).trim();
+                    f = h.substr(k + 2).trim();
+                }
+                if (f != null && f != this.n) {
+                    let l = this.c();
+                    l.n = f;
+                    e = l;
+                    continue;
+                }
+            }
+            if (b) {
+                i = true;
+            }
+            if (e != null && typeCast(PropertyEditorPropertyDescription.$, e) !== null) {
+                let m = e.aq(h, i);
+                if (m == null) {
+                    return null;
+                }
+                e = m;
+            }
+            else {
+                if (e != null) {
+                    let n = e;
+                    let o = n.e(h, i);
+                    if (o == null) {
+                        return null;
+                    }
+                    e = o;
+                }
+                else {
+                    if (this.h == null) {
+                        return null;
+                    }
+                    for (let p = 0; p < this.h.count; p++) {
+                        if (Base.equalsStatic(this.h._inner[p].a3, h)) {
+                            e = this.h._inner[p];
+                            break;
+                        }
+                    }
+                    if (e == null) {
+                        return null;
+                    }
+                }
+            }
+        }
+        return typeCast(PropertyEditorPropertyDescription.$, e);
+    }
+    c() {
+        return ((() => {
+            let $ret = new PropertyEditorDataSource();
+            $ret.b = this.b;
+            $ret.n = this.n;
+            return $ret;
+        })());
+    }
+}
+export { PropertyEditorDataSource };
+/**
+ * @hidden
+ */
+class PropertyEditorPropertyDescription extends Base {
+    constructor() {
+        super(...arguments);
+        this.au = null;
+        this.aw = null;
+        this.at = null;
+        this.ax = null;
+        this.u = 0;
+        this.t = 0;
+        this.av = null;
+        this.x = false;
+        this.as = null;
+        this.a = null;
+        this.b = null;
+        this.aa = false;
+        this.ao = null;
+        this.an = null;
+        this.ag = NaN;
+        this.ad = NaN;
+        this.ae = NaN;
+        this.af = NaN;
+        this.ah = NaN;
+        this.g = null;
+        this.f = null;
+        this.k = new PropertyEditorDescriptionObjectCollection();
+        this.j = new PropertyEditorDescriptionObjectCollection();
+        this.y = false;
+        this.q = new PropertyEditorPropertyDescriptionCollection();
+        this.e = null;
+        this.propertyChanged = null;
+        this.buttonClicked = null;
+        this.changed = null;
+        this.targetPropertyUpdating = null;
+        this.coercingValue = null;
+    }
+    static { this.$t = markType(PropertyEditorPropertyDescription, 'PropertyEditorPropertyDescription', Base.$, [INotifyPropertyChanged_$type]); }
+    get a0() {
+        return this.au;
+    }
+    set a0(a) {
+        let b = this.au;
+        this.au = a;
+        if (b != this.au) {
+            this.a8("Name", b, a);
+        }
+    }
+    get a3() {
+        return this.aw;
+    }
+    set a3(a) {
+        let b = this.aw;
+        this.aw = a;
+        if (this.aw != b) {
+            this.a8("PropertyPath", b, a);
+        }
+    }
+    get az() {
+        return this.at;
+    }
+    set az(a) {
+        let b = this.at;
+        this.at = a;
+        if (this.at != b) {
+            this.a8("Label", b, a);
+        }
+    }
+    get a4() {
+        return this.ax;
+    }
+    set a4(a) {
+        let b = this.ax;
+        this.ax = a;
+        if (this.ax != b) {
+            this.a8("Subtitle", b, a);
+        }
+    }
+    get w() {
+        return this.u;
+    }
+    set w(a) {
+        let b = this.u;
+        this.u = a;
+        if (this.u != b) {
+            this.a8("ValueType", enumGetBox(PropertyEditorValueType_$type, b), enumGetBox(PropertyEditorValueType_$type, a));
+        }
+    }
+    get v() {
+        return this.t;
+    }
+    set v(a) {
+        let b = this.t;
+        this.t = a;
+        if (this.t != b) {
+            this.a8("CoercedValueType", enumGetBox(PropertyEditorValueType_$type, b), enumGetBox(PropertyEditorValueType_$type, a));
+        }
+    }
+    get a2() {
+        return this.av;
+    }
+    set a2(a) {
+        let b = this.av;
+        this.av = a;
+        if (this.av != b) {
+            this.a8("PropertyDescriptionType", b, a);
+        }
+    }
+    get ab() {
+        return this.x;
+    }
+    set ab(a) {
+        let b = this.x;
+        this.x = a;
+        if (this.x != b) {
+            this.a8("ShouldOverrideDefaultEditor", b, a);
+        }
+    }
+    get ay() {
+        return this.as;
+    }
+    set ay(a) {
+        let b = this.as;
+        this.as = a;
+        if (this.as != b) {
+            this.a8("ElementDescriptionType", b, a);
+        }
+    }
+    get c() {
+        return this.a;
+    }
+    set c(a) {
+        let b = this.a;
+        this.a = a;
+        if (this.a != b) {
+            this.a8("DropDownNames", b, a);
+        }
+    }
+    get d() {
+        return this.b;
+    }
+    set d(a) {
+        let b = this.b;
+        this.b = a;
+        if (this.b != b) {
+            this.a8("DropDownValues", b, a);
+        }
+    }
+    get ar() {
+        return this.ao;
+    }
+    set ar(a) {
+        let b = this.ao;
+        this.ao = a;
+        if (this.ao != b) {
+            this.a8("PrimitiveValue", b, a);
+        }
+    }
+    get ap() {
+        return this.an;
+    }
+    set ap(a) {
+        let b = this.an;
+        this.an = a;
+        if (this.ao != b) {
+            this.a8("CoercedPrimitiveValue", b, a);
+        }
+    }
+    get al() {
+        return this.ag;
+    }
+    set al(a) {
+        let b = this.ag;
+        this.ag = a;
+        if (this.ag != b) {
+            this.a8("Min", b, a);
+        }
+    }
+    get ai() {
+        return this.ad;
+    }
+    set ai(a) {
+        let b = this.ad;
+        this.ad = a;
+        if (this.ad != b) {
+            this.a8("EditorWidth", b, a);
+        }
+    }
+    get aj() {
+        return this.ae;
+    }
+    set aj(a) {
+        let b = this.ae;
+        this.ae = a;
+        if (this.ae != b) {
+            this.a8("LabelWidth", b, a);
+        }
+    }
+    get ak() {
+        return this.af;
+    }
+    set ak(a) {
+        let b = this.af;
+        this.af = a;
+        if (this.af != b) {
+            this.a8("Max", b, a);
+        }
+    }
+    get am() {
+        return this.ah;
+    }
+    set am(a) {
+        let b = this.ah;
+        this.ah = a;
+        if (this.ah != b) {
+            this.a8("Step", b, a);
+        }
+    }
+    get i() {
+        return this.g;
+    }
+    set i(a) {
+        let b = this.g;
+        this.g = a;
+        if (this.g != b) {
+            this.a8("ComplexValue", b, a);
+        }
+    }
+    get h() {
+        return this.f;
+    }
+    set h(a) {
+        let b = this.f;
+        this.f = a;
+        if (this.f != b) {
+            this.a8("CoercedComplexValue", b, a);
+        }
+    }
+    get m() {
+        return this.k;
+    }
+    set m(a) {
+        let b = this.k;
+        this.k = a;
+        if (this.k != b) {
+            this.a8("ComplexValues", b, a);
+        }
+    }
+    get l() {
+        return this.j;
+    }
+    set l(a) {
+        let b = this.j;
+        this.j = a;
+        if (this.j != b) {
+            this.a8("CoercedComplexValues", b, a);
+        }
+    }
+    get ac() {
+        return this.y;
+    }
+    set ac(a) {
+        let b = this.y;
+        this.y = a;
+        if (this.y != b) {
+            this.a8("UseCoercedValue", b, a);
+        }
+    }
+    get r() {
+        return this.q;
+    }
+    set r(a) {
+        let b = this.q;
+        this.q = a;
+        if (this.q != b) {
+            this.a8("Properties", b, a);
+        }
+    }
+    a8(a, b, c) {
+        if (a == "PrimitiveValue") {
+            this.a7();
+        }
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+    }
+    z(a) {
+        let b = false;
+        if (a == null) {
+            return false;
+        }
+        if (a.c != null && (this.c == null || !this.ab)) {
+            this.c = a.c;
+        }
+        if (a.d != null && (this.d == null || !this.ab)) {
+            this.d = a.d;
+        }
+        if (a.ay != null && (this.ay == null || !this.ab)) {
+            this.ay = a.ay;
+        }
+        if (a.a2 != null && (this.a2 == null || !this.ab)) {
+            this.a2 = a.a2;
+        }
+        if (a.w != 0 && (this.w == 0 || !this.ab)) {
+            this.w = a.w;
+            b = true;
+        }
+        if (a.v != 0 && (this.v == 0 || !this.ab)) {
+            this.v = a.v;
+            b = true;
+        }
+        if (a.ac) {
+            this.ac = a.ac;
+        }
+        return true;
+    }
+    aq(a, b) {
+        if (b) {
+            return this.e;
+        }
+        if (this.e != null) {
+            return this.e.e(a, false);
+        }
+        return null;
+    }
+    a6() {
+        if (this.buttonClicked != null) {
+            this.buttonClicked(this, new PropertyEditorPropertyDescriptionButtonClickEventArgs());
+        }
+    }
+    a5() {
+        if (this.changed != null) {
+            this.changed(this, ((() => {
+                let $ret = new PropertyEditorPropertyDescriptionChangedEventArgs();
+                $ret.newValue = this.ar;
+                return $ret;
+            })()));
+        }
+    }
+    a9(a, b, c) {
+        if (this.targetPropertyUpdating != null) {
+            this.targetPropertyUpdating(this, ((() => {
+                let $ret = new PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs();
+                $ret.propertyPath = a;
+                $ret.target = b;
+                $ret.value = c;
+                return $ret;
+            })()));
+        }
+    }
+    a7() {
+        if (this.coercingValue != null) {
+            let a = ((() => {
+                let $ret = new PropertyEditorPropertyDescriptionCoercingValueEventArgs();
+                $ret.value = this.ar;
+                $ret.complexValue = this.i;
+                $ret.complexValues = this.m;
+                return $ret;
+            })());
+            this.coercingValue(this, a);
+            this.ap = a.value;
+            this.h = a.complexValue;
+            this.l = a.complexValues;
+        }
+    }
+}
+export { PropertyEditorPropertyDescription };
+/**
+ * @hidden
+ */
+class PropertyEditorPropertyDescriptionCoercingValueEventArgs extends EventArgs {
+    constructor() {
+        super(...arguments);
+        this._value = null;
+        this._complexValue = null;
+        this._complexValues = null;
+    }
+    static { this.$t = markType(PropertyEditorPropertyDescriptionCoercingValueEventArgs, 'PropertyEditorPropertyDescriptionCoercingValueEventArgs', EventArgs.$); }
+    get value() {
+        return this._value;
+    }
+    set value(a) {
+        this._value = a;
+    }
+    get complexValue() {
+        return this._complexValue;
+    }
+    set complexValue(a) {
+        this._complexValue = a;
+    }
+    get complexValues() {
+        return this._complexValues;
+    }
+    set complexValues(a) {
+        this._complexValues = a;
+    }
+}
+export { PropertyEditorPropertyDescriptionCoercingValueEventArgs };
+/**
+ * @hidden
+ */
+class PropertyEditorDescriptionObject extends Base {
+    constructor() {
+        super(...arguments);
+        this.b = null;
+        this.a = null;
+    }
+    static { this.$t = markType(PropertyEditorDescriptionObject, 'PropertyEditorDescriptionObject'); }
+}
+export { PropertyEditorDescriptionObject };
+/**
+ * @hidden
+ */
+class PropertyEditorDescriptionObjectCollection extends ObservableCollection$1 {
+    static { this.$t = markType(PropertyEditorDescriptionObjectCollection, 'PropertyEditorDescriptionObjectCollection', ObservableCollection$1.$.specialize(PropertyEditorDescriptionObject.$)); }
+    constructor() {
+        super(PropertyEditorDescriptionObject.$, 0);
+    }
+}
+export { PropertyEditorDescriptionObjectCollection };
+/**
+ * @hidden
+ */
+class PropertyEditorPropertyDescriptionCollection extends ObservableCollection$1 {
+    static { this.$t = markType(PropertyEditorPropertyDescriptionCollection, 'PropertyEditorPropertyDescriptionCollection', ObservableCollection$1.$.specialize(PropertyEditorPropertyDescription.$)); }
+    constructor() {
+        super(PropertyEditorPropertyDescription.$, 0);
+    }
+}
+export { PropertyEditorPropertyDescriptionCollection };

package/esm2022/lib/PropertyEditorDescriptionObject.d.ts

@@ -0,0 +1 @@
+export { PropertyEditorDescriptionObject } from "./PropertyEditorDataSource_combined";

package/esm2022/lib/PropertyEditorDescriptionObject.js

@@ -0,0 +1,7 @@
+/*
+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.
+*/
+export { PropertyEditorDescriptionObject } from "./PropertyEditorDataSource_combined";

package/esm2022/lib/PropertyEditorDescriptionObjectCollection.d.ts

@@ -0,0 +1 @@
+export { PropertyEditorDescriptionObjectCollection } from "./PropertyEditorDataSource_combined";

package/esm2022/lib/PropertyEditorDescriptionObjectCollection.js

@@ -0,0 +1,7 @@
+/*
+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.
+*/
+export { PropertyEditorDescriptionObjectCollection } from "./PropertyEditorDataSource_combined";

package/esm2022/lib/PropertyEditorPanel.d.ts

@@ -0,0 +1 @@
+export { PropertyEditorPanel } from "./PropertyEditorPanelView_combined";