igniteui-webcomponents-inputs 1.3.3

package/esm5/lib/IconView_combined.js

@@ -0,0 +1,706 @@
+/*
+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 * as tslib_1 from "tslib";
+import { Base, Delegate_$type, fromEnum, runOn, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs } from "igniteui-webcomponents-core";
+import { List$1 } from "igniteui-webcomponents-core";
+import { IIcon_$type } from "igniteui-webcomponents-core";
+import { NativeUI } from "igniteui-webcomponents-core";
+import { IconVisualModelExport } from "./IconVisualModelExport";
+import { AppearanceHelper } from "igniteui-webcomponents-core";
+import { FontUtil } from "igniteui-webcomponents-core";
+import { isNaN_ } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+var IconView = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(IconView, _super);
+    function IconView() {
+        var _this = _super.call(this) || this;
+        _this.a = null;
+        _this.g = null;
+        _this.b = null;
+        _this.f = new List$1(Delegate_$type, 0);
+        _this.k = null;
+        _this.c = true;
+        _this.h = null;
+        _this.i = null;
+        return _this;
+    }
+    IconView.prototype.r = function () {
+    };
+    IconView.prototype.d = function () {
+        return true;
+    };
+    Object.defineProperty(IconView.prototype, "j", {
+        get: function () {
+            return this.h;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IconView.prototype, "w", {
+        get: function () {
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(IconView.prototype, "e", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    IconView.prototype.p = function (a) {
+        var e_1, _a;
+        if (a == null) {
+            try {
+                for (var _b = tslib_1.__values(fromEnum(this.f)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var b = _c.value;
+                    b();
+                }
+            }
+            catch (e_1_1) {
+                e_1 = { error: e_1_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_1)
+                        throw e_1.error;
+                }
+            }
+            this.f.clear();
+        }
+        this.g = a;
+        a.rootWrapper.setStyleProperty("position", "relative");
+        this.g.rootWrapper.setStyleProperty("display", "flex");
+        this.g.rootWrapper.setStyleProperty("flex-direction", "row");
+        this.g.rootWrapper.setStyleProperty("flex-wrap", "no-wrap");
+        this.g.rootWrapper.setStyleProperty("align-items", "center");
+        this.t();
+        var c = this.g.createElementNS("svg", "http://www.w3.org/2000/svg");
+        c.setStyleProperty("position", "absolute");
+        c.setStyleProperty("top", "0");
+        c.setStyleProperty("left", "0");
+        c.setStyleProperty("right", "0");
+        c.setStyleProperty("bottom", "0");
+        c.setAttribute("viewBox", "0 0 24 24");
+        this.h = c;
+        var d = this.g.createElementNS("path", "http://www.w3.org/2000/svg");
+        d.setAttribute("d", "");
+        this.h.append(d);
+        if (this.k != null) {
+            d.setAttribute("d", this.k);
+        }
+        this.i = d;
+        this.g.append(this.h);
+        this.a.a8();
+    };
+    IconView.prototype.u = function (a) {
+        if (this.k != a) {
+            this.k = a;
+            if (this.i != null) {
+                this.i.setAttribute("d", this.k);
+            }
+        }
+    };
+    IconView.prototype.t = function () {
+        this.g.rootWrapper.setStyleProperty("width", "1.5rem");
+        this.g.rootWrapper.setStyleProperty("height", "1.5rem");
+    };
+    IconView.prototype.l = function (a) {
+    };
+    IconView.prototype.s = function () {
+        if (this.d()) {
+        }
+    };
+    IconView.prototype.m = function (a) {
+        this.a.a5();
+    };
+    IconView.prototype.n = function (a) {
+        this.a.a6();
+    };
+    IconView.prototype.o = function () {
+        this.c = true;
+        this.f.add(this.g.rootWrapper.listen("mouseenter", runOn(this, this.m)));
+        this.f.add(this.g.rootWrapper.listen("mouseleave", runOn(this, this.n)));
+    };
+    IconView.prototype.q = function () {
+        var e_2, _a;
+        this.c = false;
+        try {
+            for (var _b = tslib_1.__values(fromEnum(this.f)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var a = _c.value;
+                a();
+            }
+        }
+        catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_2)
+                    throw e_2.error;
+            }
+        }
+        this.f.clear();
+    };
+    IconView.prototype.v = function (a) {
+        if (a != null) {
+            this.g.rootWrapper.setStyleProperty("font", a.fontString);
+        }
+    };
+    IconView.$t = markType(IconView, 'IconView');
+    return IconView;
+}(Base));
+export { IconView };
+/**
+ * @hidden
+ */
+var Icon = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(Icon, _super);
+    function Icon() {
+        var _this = _super.call(this) || this;
+        _this._view = null;
+        _this.bd = Icon.bt;
+        _this.bh = Icon.bx;
+        _this.be = Icon.bu;
+        _this.bf = Icon.bv;
+        _this.bg = Icon.bw;
+        _this.m = Icon.s;
+        _this.n = Icon.t;
+        _this.bi = Icon.bt;
+        _this.bn = Icon.bx;
+        _this.ac = null;
+        _this.bj = Icon.bu;
+        _this.bk = Icon.bv;
+        _this.bm = Icon.bw;
+        _this.o = Icon.s;
+        _this.p = Icon.t;
+        _this.c = null;
+        _this.bl = null;
+        _this.ab = "ig-icon-" + Icon.y++;
+        _this.w = 0;
+        _this.e = false;
+        _this.aa = null;
+        _this.g = false;
+        _this.f = false;
+        _this.propertyChanged = null;
+        var a = new IconView();
+        a.a = _this;
+        _this.view = a;
+        _this.view.r();
+        return _this;
+    }
+    Object.defineProperty(Icon.prototype, "view", {
+        get: function () {
+            return this._view;
+        },
+        set: function (a) {
+            this._view = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Icon.prototype.destroy = function () {
+        this.provideContainer(null);
+    };
+    Icon.prototype.a7 = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.a9(a, b, c);
+    };
+    Icon.prototype.a9 = function (a, b, c) {
+        switch (a) {
+            case "Fill":
+            case "Stroke":
+            case "StrokeThickness":
+            case "HoverFill":
+            case "HoverStroke":
+            case "HoverStrokeThickness":
+                this.bc();
+                break;
+            case "ActualFill":
+            case "ActualStroke":
+            case "ActualHoverFill":
+            case "ActualHoverStroke":
+            case "ActualStrokeThickness":
+            case "ActualHoverStrokeThickness":
+            case "SVGPath":
+                this.bb();
+                break;
+        }
+    };
+    Icon.prototype.bc = function () {
+        this.bo = this.fill != null ? this.fill : Icon.bt;
+        this.bp = this.by != null ? this.by : Icon.bu;
+        this.br = this.b1 != null ? this.b1 : Icon.bw;
+        this.bq = this.bz != null ? this.bz : Icon.bv;
+        this.r = !isNaN_(this.v) ? this.v : Icon.t;
+        this.q = !isNaN_(this.u) ? this.u : Icon.s;
+        this.bs = this.b2 != null ? this.b2 : Icon.bx;
+    };
+    Object.defineProperty(Icon.prototype, "i", {
+        get: function () {
+            return this.svgPath != null && !this.view.e;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Icon.prototype.bb = function () {
+        var a = this.view.j;
+        if (this.i) {
+            var b = this.view.w;
+            if (this.k) {
+                b._fill = this.bp;
+                b._stroke = this.bq;
+                b.ac = this.q;
+            }
+            else {
+                b._fill = this.bo;
+                b._stroke = this.br;
+                b.ac = this.r;
+            }
+        }
+        else {
+            if (this.svgPath != null) {
+                this.view.u(this.svgPath);
+            }
+            var c = this.view.j;
+            if (this.k) {
+                if (this.bp != null) {
+                    NativeUI.o(c, this.bp);
+                }
+                if (this.bq != null) {
+                    NativeUI.v(c, this.bq);
+                }
+                if (!isNaN_(this.q)) {
+                    NativeUI.y(c, this.q);
+                }
+            }
+            else {
+                if (this.bo != null) {
+                    NativeUI.o(c, this.bo);
+                }
+                if (this.br != null) {
+                    NativeUI.v(c, this.br);
+                }
+                if (!isNaN_(this.r)) {
+                    NativeUI.y(c, this.r);
+                }
+            }
+        }
+        if (this.d != null) {
+            this.view.v(this.d);
+        }
+        if (this.bs != null) {
+            NativeUI.n(this.view.j, this.bs);
+        }
+    };
+    Object.defineProperty(Icon.prototype, "bo", {
+        get: function () {
+            return this.bd;
+        },
+        set: function (a) {
+            var b = this.bd;
+            this.bd = a;
+            if (b != this.bd) {
+                this.a7("ActualFill", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "bs", {
+        get: function () {
+            return this.bh;
+        },
+        set: function (a) {
+            var b = this.bh;
+            this.bh = a;
+            if (b != this.bh) {
+                this.a7("ActualTextColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "bp", {
+        get: function () {
+            return this.be;
+        },
+        set: function (a) {
+            var b = this.be;
+            this.be = a;
+            if (b != this.be) {
+                this.a7("ActualHoverFill", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "bq", {
+        get: function () {
+            return this.bf;
+        },
+        set: function (a) {
+            var b = this.bf;
+            this.bf = a;
+            if (b != this.bf) {
+                this.a7("ActualHoverStroke", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "br", {
+        get: function () {
+            return this.bg;
+        },
+        set: function (a) {
+            var b = this.bg;
+            this.bg = a;
+            if (b != this.bg) {
+                this.a7("ActualStroke", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "q", {
+        get: function () {
+            return this.m;
+        },
+        set: function (a) {
+            var b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.a7("ActualHoverStrokeThickness", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "r", {
+        get: function () {
+            return this.n;
+        },
+        set: function (a) {
+            var b = this.n;
+            this.n = a;
+            if (b != this.n) {
+                this.a7("ActualStrokeThickness", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "fill", {
+        get: function () {
+            return this.bi;
+        },
+        set: function (a) {
+            var b = this.bi;
+            this.bi = a;
+            if (b != this.bi) {
+                this.a7("Fill", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "b2", {
+        get: function () {
+            return this.bn;
+        },
+        set: function (a) {
+            var b = this.bn;
+            this.bn = a;
+            if (b != this.bn) {
+                this.a7("TextColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "svgPath", {
+        get: function () {
+            return this.ac;
+        },
+        set: function (a) {
+            var b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.a7("SVGPath", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "by", {
+        get: function () {
+            return this.bj;
+        },
+        set: function (a) {
+            var b = this.bj;
+            this.bj = a;
+            if (b != this.bj) {
+                this.a7("HoverFill", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "bz", {
+        get: function () {
+            return this.bk;
+        },
+        set: function (a) {
+            var b = this.bk;
+            this.bk = a;
+            if (b != this.bk) {
+                this.a7("HoverStroke", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "b1", {
+        get: function () {
+            return this.bm;
+        },
+        set: function (a) {
+            var b = this.bm;
+            this.bm = a;
+            if (b != this.bm) {
+                this.a7("Stroke", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "u", {
+        get: function () {
+            return this.o;
+        },
+        set: function (a) {
+            var b = this.o;
+            this.o = a;
+            if (b != this.o) {
+                this.a7("HoverStrokeThickness", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "v", {
+        get: function () {
+            return this.p;
+        },
+        set: function (a) {
+            var b = this.p;
+            this.p = a;
+            if (b != this.p) {
+                this.a7("StrokeThickness", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Icon.prototype.a5 = function () {
+        this.k = true;
+    };
+    Icon.prototype.a6 = function () {
+        this.k = false;
+    };
+    Object.defineProperty(Icon.prototype, "d", {
+        get: function () {
+            return this.c;
+        },
+        set: function (a) {
+            var b = this.c;
+            this.c = a;
+            if (b != this.c) {
+                this.a7("TextStyle", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "b0", {
+        get: function () {
+            return this.bl;
+        },
+        set: function (a) {
+            var b = this.bl;
+            this.bl = a;
+            if (b != this.bl) {
+                this.a7("HoverTextColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "as", {
+        get: function () {
+            return this.ab;
+        },
+        set: function (a) {
+            var b = this.ab;
+            this.ab = a;
+            if (b != this.ab) {
+                this.a7("Id", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "h", {
+        get: function () {
+            return this.e;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "x", {
+        get: function () {
+            return this.w;
+        },
+        set: function (a) {
+            var b = this.w;
+            this.w = a;
+            this.e = true;
+            if (b != this.w) {
+                this.a7("TabIndex", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "ak", {
+        get: function () {
+            return this.aa;
+        },
+        set: function (a) {
+            var b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.a7("AriaLabel", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "k", {
+        get: function () {
+            return this.g;
+        },
+        set: function (a) {
+            var b = this.g;
+            this.g = a;
+            if (b != this.g) {
+                this.a7("IsHover", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Icon.prototype, "disabled", {
+        get: function () {
+            return this.f;
+        },
+        set: function (a) {
+            var b = this.f;
+            this.f = a;
+            if (b != this.f) {
+                this.a7("IsDisabled", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Icon.prototype.a8 = function () {
+    };
+    Icon.prototype.onDetachedFromUI = function () {
+        this.view.q();
+    };
+    Icon.prototype.onAttachedToUI = function () {
+        this.view.o();
+    };
+    Icon.prototype.l = function () {
+        return this.view.d();
+    };
+    Icon.prototype.z = function () {
+        return this.a();
+    };
+    Icon.prototype.am = function () {
+        var a = this.a();
+        return a.f();
+    };
+    Icon.prototype.a = function () {
+        var a = new IconVisualModelExport();
+        var b = this.view.j;
+        a.a = AppearanceHelper.a(NativeUI.af(b));
+        a.c = AppearanceHelper.a(NativeUI.af(b));
+        a.b = AppearanceHelper.a(NativeUI.ag(b));
+        a.d = this.r;
+        if (this.d != null) {
+            var c = this.d;
+            if (this.view != null && c.n == null) {
+                var d = this.view.g;
+                var e = FontUtil.getFontInfoFromString(d, c.fontString);
+                c.n = e.n;
+                c.d = e.d;
+                c.o = e.o;
+                c.q = e.q;
+                c.r = e.r;
+                c.s = e.s;
+            }
+            if (c.n != null) {
+                a.h = c.n;
+            }
+            if (!isNaN_(c.d)) {
+                a.e = c.d;
+            }
+            if (c.s != null) {
+                a.l = c.s;
+            }
+            if (c.q != null) {
+                a.j = c.q;
+            }
+            if (c.o != null) {
+                a.i = c.q;
+            }
+        }
+        return a;
+    };
+    Icon.prototype.provideContainer = function (a) {
+        this.view.p(a);
+    };
+    Icon.$t = markType(Icon, 'Icon', Base.$, [INotifyPropertyChanged_$type, IIcon_$type]);
+    Icon.bt = null;
+    Icon.bx = null;
+    Icon.bw = null;
+    Icon.bu = null;
+    Icon.bv = null;
+    Icon.t = 0;
+    Icon.s = 0;
+    Icon.y = 0;
+    return Icon;
+}(Base));
+export { Icon };
+//# sourceMappingURL=IconView_combined.js.map