igniteui-webcomponents-layouts 1.4.0 → 3.2.0

package/esm2015/lib/PropertyEditorPropertyDescription.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 { PropertyEditorPropertyDescription } from "./PropertyEditorPropertyDescription_combined";

package/esm2015/lib/PropertyEditorPropertyDescriptionButtonClickEventArgs.js

@@ -0,0 +1,16 @@
+/*
+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 { EventArgs, markType } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+export let PropertyEditorPropertyDescriptionButtonClickEventArgs = /*@__PURE__*/ (() => {
+    class PropertyEditorPropertyDescriptionButtonClickEventArgs extends EventArgs {
+    }
+    PropertyEditorPropertyDescriptionButtonClickEventArgs.$t = /*@__PURE__*/ markType(PropertyEditorPropertyDescriptionButtonClickEventArgs, 'PropertyEditorPropertyDescriptionButtonClickEventArgs', EventArgs.$);
+    return PropertyEditorPropertyDescriptionButtonClickEventArgs;
+})();

package/esm2015/lib/PropertyEditorPropertyDescriptionChangedEventArgs.js

@@ -0,0 +1,26 @@
+/*
+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 { EventArgs, markType } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+export let PropertyEditorPropertyDescriptionChangedEventArgs = /*@__PURE__*/ (() => {
+    class PropertyEditorPropertyDescriptionChangedEventArgs extends EventArgs {
+        constructor() {
+            super(...arguments);
+            this._newValue = null;
+        }
+        get newValue() {
+            return this._newValue;
+        }
+        set newValue(a) {
+            this._newValue = a;
+        }
+    }
+    PropertyEditorPropertyDescriptionChangedEventArgs.$t = /*@__PURE__*/ markType(PropertyEditorPropertyDescriptionChangedEventArgs, 'PropertyEditorPropertyDescriptionChangedEventArgs', EventArgs.$);
+    return PropertyEditorPropertyDescriptionChangedEventArgs;
+})();

package/esm2015/lib/PropertyEditorPropertyDescriptionCollection.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 { PropertyEditorPropertyDescriptionCollection } from "./PropertyEditorPropertyDescription_combined";

package/esm2015/lib/PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.js

@@ -0,0 +1,40 @@
+/*
+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 { EventArgs, markType } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+export let PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs = /*@__PURE__*/ (() => {
+    class PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs extends EventArgs {
+        constructor() {
+            super(...arguments);
+            this._target = null;
+            this._value = null;
+            this._propertyPath = null;
+        }
+        get target() {
+            return this._target;
+        }
+        set target(a) {
+            this._target = a;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(a) {
+            this._value = a;
+        }
+        get propertyPath() {
+            return this._propertyPath;
+        }
+        set propertyPath(a) {
+            this._propertyPath = a;
+        }
+    }
+    PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs.$t = /*@__PURE__*/ markType(PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs, 'PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs', EventArgs.$);
+    return PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs;
+})();

package/esm2015/lib/PropertyEditorPropertyDescription_combined.js

@@ -0,0 +1,522 @@
+/*
+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, enumGetBox, markType, String_$type, typeCast } from "igniteui-webcomponents-core";
+import { PropertyEditorValueType_$type } from "./PropertyEditorValueType";
+import { PropertyEditorPropertyDescriptionButtonClickEventArgs } from "./PropertyEditorPropertyDescriptionButtonClickEventArgs";
+import { PropertyEditorPropertyDescriptionChangedEventArgs } from "./PropertyEditorPropertyDescriptionChangedEventArgs";
+import { PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs } from "./PropertyEditorPropertyDescriptionTargetPropertyUpdatingEventArgs";
+import { ObservableCollection$1 } from "igniteui-webcomponents-core";
+import { List$1 } from "igniteui-webcomponents-core";
+import { stringEndsWith, stringContains, stringReplace } from "igniteui-webcomponents-core";
+import { stringSplit } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+export let PropertyEditorPropertyDescription = /*@__PURE__*/ (() => {
+    class PropertyEditorPropertyDescription extends Base {
+        constructor() {
+            super(...arguments);
+            this.ah = null;
+            this.af = null;
+            this.m = 0;
+            this.ag = null;
+            this.o = false;
+            this.ae = null;
+            this.a = null;
+            this.b = null;
+            this.ab = null;
+            this.u = NaN;
+            this.r = NaN;
+            this.s = NaN;
+            this.t = NaN;
+            this.v = NaN;
+            this.f = null;
+            this.h = null;
+            this.e = null;
+            this.propertyChanged = null;
+            this.buttonClicked = null;
+            this.changed = null;
+            this.targetPropertyUpdating = null;
+        }
+        get al() {
+            return this.ah;
+        }
+        set al(a) {
+            let b = this.ah;
+            this.ah = a;
+            if (this.ah != b) {
+                this.ao("PropertyPath", b, a);
+            }
+        }
+        get aj() {
+            return this.af;
+        }
+        set aj(a) {
+            let b = this.af;
+            this.af = a;
+            if (this.af != b) {
+                this.ao("Label", b, a);
+            }
+        }
+        get n() {
+            return this.m;
+        }
+        set n(a) {
+            let b = this.m;
+            this.m = a;
+            if (this.m != b) {
+                this.ao("ValueType", enumGetBox(PropertyEditorValueType_$type, b), enumGetBox(PropertyEditorValueType_$type, a));
+            }
+        }
+        get ak() {
+            return this.ag;
+        }
+        set ak(a) {
+            let b = this.ag;
+            this.ag = a;
+            if (this.ag != b) {
+                this.ao("PropertyDescriptionType", b, a);
+            }
+        }
+        get q() {
+            return this.o;
+        }
+        set q(a) {
+            let b = this.o;
+            this.o = a;
+            if (this.o != b) {
+                this.ao("ShouldOverrideDefaultEditor", b, a);
+            }
+        }
+        get ai() {
+            return this.ae;
+        }
+        set ai(a) {
+            let b = this.ae;
+            this.ae = a;
+            if (this.ae != b) {
+                this.ao("ElementDescriptionType", b, a);
+            }
+        }
+        get c() {
+            return this.a;
+        }
+        set c(a) {
+            let b = this.a;
+            this.a = a;
+            if (this.a != b) {
+                this.ao("DropDownNames", b, a);
+            }
+        }
+        get d() {
+            return this.b;
+        }
+        set d(a) {
+            let b = this.b;
+            this.b = a;
+            if (this.b != b) {
+                this.ao("DropDownValues", b, a);
+            }
+        }
+        get ad() {
+            return this.ab;
+        }
+        set ad(a) {
+            let b = this.ab;
+            this.ab = a;
+            if (this.ab != b) {
+                this.ao("PrimitiveValue", b, a);
+            }
+        }
+        get z() {
+            return this.u;
+        }
+        set z(a) {
+            let b = this.u;
+            this.u = a;
+            if (this.u != b) {
+                this.ao("Min", b, a);
+            }
+        }
+        get w() {
+            return this.r;
+        }
+        set w(a) {
+            let b = this.r;
+            this.r = a;
+            if (this.r != b) {
+                this.ao("EditorWidth", b, a);
+            }
+        }
+        get x() {
+            return this.s;
+        }
+        set x(a) {
+            let b = this.s;
+            this.s = a;
+            if (this.s != b) {
+                this.ao("LabelWidth", b, a);
+            }
+        }
+        get y() {
+            return this.t;
+        }
+        set y(a) {
+            let b = this.t;
+            this.t = a;
+            if (this.t != b) {
+                this.ao("Max", b, a);
+            }
+        }
+        get aa() {
+            return this.v;
+        }
+        set aa(a) {
+            let b = this.v;
+            this.v = a;
+            if (this.v != b) {
+                this.ao("Step", b, a);
+            }
+        }
+        get g() {
+            return this.f;
+        }
+        set g(a) {
+            let b = this.f;
+            this.f = a;
+            if (this.f != b) {
+                this.ao("ComplexValue", b, a);
+            }
+        }
+        get i() {
+            return this.h;
+        }
+        set i(a) {
+            let b = this.h;
+            this.h = a;
+            if (this.h != b) {
+                this.ao("ComplexValues", b, a);
+            }
+        }
+        ao(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+        }
+        p(a) {
+            let b = false;
+            if (a == null) {
+                return false;
+            }
+            if (a.c != null && (this.c == null || !this.q)) {
+                this.c = a.c;
+            }
+            if (a.d != null && (this.d == null || !this.q)) {
+                this.d = a.d;
+            }
+            if (a.ai != null && (this.ai == null || !this.q)) {
+                this.ai = a.ai;
+            }
+            if (a.ak != null && (this.ak == null || !this.q)) {
+                this.ak = a.ak;
+            }
+            if (a.n != 0 && (this.n == 0 || !this.q)) {
+                this.n = a.n;
+                b = true;
+            }
+            return true;
+        }
+        ac(a, b) {
+            if (b) {
+                return this.e;
+            }
+            if (this.e != null) {
+                return this.e.d(a, false);
+            }
+            return null;
+        }
+        an() {
+            if (this.buttonClicked != null) {
+                this.buttonClicked(this, new PropertyEditorPropertyDescriptionButtonClickEventArgs());
+            }
+        }
+        am() {
+            if (this.changed != null) {
+                this.changed(this, ((() => {
+                    let $ret = new PropertyEditorPropertyDescriptionChangedEventArgs();
+                    $ret.newValue = this.ad;
+                    return $ret;
+                })()));
+            }
+        }
+        ap(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;
+                })()));
+            }
+        }
+    }
+    PropertyEditorPropertyDescription.$t = /*@__PURE__*/ markType(PropertyEditorPropertyDescription, 'PropertyEditorPropertyDescription', Base.$, [INotifyPropertyChanged_$type]);
+    return PropertyEditorPropertyDescription;
+})();
+/**
+ * @hidden
+ */
+export let PropertyEditorPropertyDescriptionCollection = /*@__PURE__*/ (() => {
+    class PropertyEditorPropertyDescriptionCollection extends ObservableCollection$1 {
+        constructor() {
+            super(PropertyEditorPropertyDescription.$, 0);
+        }
+    }
+    PropertyEditorPropertyDescriptionCollection.$t = /*@__PURE__*/ markType(PropertyEditorPropertyDescriptionCollection, 'PropertyEditorPropertyDescriptionCollection', /*@__PURE__*/ ObservableCollection$1.$.specialize(PropertyEditorPropertyDescription.$));
+    return PropertyEditorPropertyDescriptionCollection;
+})();
+/**
+ * @hidden
+ */
+export let PropertyEditorDataSource = /*@__PURE__*/ (() => {
+    class PropertyEditorDataSource extends Base {
+        constructor() {
+            super(...arguments);
+            this.i = null;
+            this.a = null;
+            this.f = null;
+            this.propertyChanged = null;
+        }
+        get l() {
+            return this.i;
+        }
+        set l(a) {
+            let b = this.i;
+            this.i = a;
+            this.n("DescriptionType", b, this.i);
+        }
+        get b() {
+            return this.a;
+        }
+        set b(a) {
+            let b = this.a;
+            this.a = a;
+            this.n("Context", b, this.a);
+        }
+        get g() {
+            return this.f;
+        }
+        set g(a) {
+            let b = this.f;
+            this.f = a;
+            this.n("Data", b, this.f);
+        }
+        n(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+            this.o(a, b, c);
+        }
+        o(a, b, c) {
+            switch (a) {
+                case "DescriptionType":
+                    this.p();
+                    break;
+                case "Context":
+                    this.p();
+                    break;
+            }
+        }
+        e(a) {
+            let b = new PropertyEditorPropertyDescription();
+            b.al = a.propertyName;
+            b.n = this.h(a);
+            b.ak = a.specificExternalType != null ? a.specificExternalType : a.specificType;
+            if (a.knownType == 9) {
+                b.ai = a.collectionElementType;
+                b.e = ((() => {
+                    let $ret = new PropertyEditorDataSource();
+                    $ret.b = this.a;
+                    $ret.l = b.ai;
+                    return $ret;
+                })());
+            }
+            if (b.n == 8) {
+                b.e = ((() => {
+                    let $ret = new PropertyEditorDataSource();
+                    $ret.b = this.a;
+                    $ret.l = b.ak;
+                    return $ret;
+                })());
+            }
+            if (b.n == 15) {
+                b.c = this.a.c(this.l, b.al);
+                b.d = b.d;
+            }
+            return b;
+        }
+        h(a) {
+            switch (a.knownType) {
+                case 10: return 10;
+                case 7: return 7;
+                case 4: return 4;
+                case 6: return 6;
+                case 9: return 9;
+                case 5: return 5;
+                case 16: return 14;
+                case 20: return 18;
+                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;
+        }
+        p() {
+            let a = new PropertyEditorPropertyDescriptionCollection();
+            if (this.l != null && this.b != null) {
+                let b = this.b.b(this.l);
+                if (b == null) {
+                    return;
+                }
+                for (let c = 0; c < b.length; c++) {
+                    if (stringEndsWith(b[c], "@names")) {
+                        continue;
+                    }
+                    if (stringEndsWith(b[c], "@nameBinding")) {
+                        continue;
+                    }
+                    let d = this.b.getMetadata(this.l, b[c]);
+                    let e = this.e(d);
+                    if (e.n == 0) {
+                        continue;
+                    }
+                    a.add(e);
+                }
+            }
+            this.g = a;
+        }
+        d(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.l) {
+                        let l = this.c();
+                        l.l = f;
+                        e = l;
+                        continue;
+                    }
+                }
+                if (b) {
+                    i = true;
+                }
+                if (e != null && typeCast(PropertyEditorPropertyDescription.$, e) !== null) {
+                    let m = e.ac(h, i);
+                    if (m == null) {
+                        return null;
+                    }
+                    e = m;
+                }
+                else {
+                    if (e != null) {
+                        let n = e;
+                        let o = n.d(h, i);
+                        if (o == null) {
+                            return null;
+                        }
+                        e = o;
+                    }
+                    else {
+                        if (this.g == null) {
+                            return null;
+                        }
+                        for (let p = 0; p < this.g.count; p++) {
+                            if (Base.equalsStatic(this.g._inner[p].al, h)) {
+                                e = this.g._inner[p];
+                                break;
+                            }
+                        }
+                        if (e == null) {
+                            return null;
+                        }
+                    }
+                }
+            }
+            return typeCast(PropertyEditorPropertyDescription.$, e);
+        }
+        c() {
+            return ((() => {
+                let $ret = new PropertyEditorDataSource();
+                $ret.b = this.b;
+                $ret.l = this.l;
+                return $ret;
+            })());
+        }
+    }
+    PropertyEditorDataSource.$t = /*@__PURE__*/ markType(PropertyEditorDataSource, 'PropertyEditorDataSource', Base.$, [INotifyPropertyChanged_$type]);
+    return PropertyEditorDataSource;
+})();
+/**
+ * @hidden
+ */
+export let PropertyEditorDescriptionObject = /*@__PURE__*/ (() => {
+    class PropertyEditorDescriptionObject extends Base {
+        constructor() {
+            super(...arguments);
+            this.b = null;
+            this.a = null;
+        }
+    }
+    PropertyEditorDescriptionObject.$t = /*@__PURE__*/ markType(PropertyEditorDescriptionObject, 'PropertyEditorDescriptionObject');
+    return PropertyEditorDescriptionObject;
+})();
+/**
+ * @hidden
+ */
+export let PropertyEditorDescriptionObjectCollection = /*@__PURE__*/ (() => {
+    class PropertyEditorDescriptionObjectCollection extends ObservableCollection$1 {
+        constructor() {
+            super(PropertyEditorDescriptionObject.$, 0);
+        }
+    }
+    PropertyEditorDescriptionObjectCollection.$t = /*@__PURE__*/ markType(PropertyEditorDescriptionObjectCollection, 'PropertyEditorDescriptionObjectCollection', /*@__PURE__*/ ObservableCollection$1.$.specialize(PropertyEditorDescriptionObject.$));
+    return PropertyEditorDescriptionObjectCollection;
+})();