igniteui-webcomponents-inputs 7.1.0-alpha.0 → 7.1.0-alpha.2

package/esm2015/lib/XInputBridge.js

@@ -263,18 +263,18 @@ let XInputBridge = /*@__PURE__*/ (() => {
             let c = a;
             let d = typeCast(XInput.$, c.inputs._inner[0]);
             switch (b) {
-                case 103: return a.mc;
+                case 104: return a.mc;
                 case 3:
                     this.an(a);
                     let e = this.v(a);
                     return e.text;
-                case 100:
+                case 101:
                     this.ao(a);
                     return this.u.svgPath;
-                case 101:
+                case 102:
                     this.ao(a);
                     return this.u.fill;
-                case 102:
+                case 103:
                     this.ao(a);
                     return this.u.ea;
                 case 2: return d.cq;
@@ -310,11 +310,11 @@ let XInputBridge = /*@__PURE__*/ (() => {
                     }
                     break;
                 case 21: return d.a1;
-                case 32: return d.disabled;
-                case 33: return d.d8;
-                case 105: return d.selectionStart;
-                case 106: return d.selectionEnd;
-                case 107: return c.an;
+                case 33: return d.disabled;
+                case 34: return d.d8;
+                case 106: return d.selectionStart;
+                case 107: return d.selectionEnd;
+                case 108: return c.an;
             }
             return null;
         }
@@ -322,7 +322,7 @@ let XInputBridge = /*@__PURE__*/ (() => {
             let d = a;
             let e = typeCast(XInput.$, d.inputs._inner[0]);
             switch (b) {
-                case 103:
+                case 104:
                     a.mc = c;
                     break;
                 case 3:
@@ -330,15 +330,15 @@ let XInputBridge = /*@__PURE__*/ (() => {
                     let f = this.v(a);
                     f.text = c;
                     break;
-                case 100:
+                case 101:
                     this.ao(a);
                     this.u.svgPath = c;
                     break;
-                case 101:
+                case 102:
                     this.ao(a);
                     this.u.fill = c;
                     break;
-                case 102:
+                case 103:
                     this.ao(a);
                     this.u.ea = c;
                     break;
@@ -409,19 +409,19 @@ let XInputBridge = /*@__PURE__*/ (() => {
                 case 21:
                     e.a1 = c;
                     break;
-                case 32:
+                case 33:
                     e.disabled = c;
                     break;
-                case 33:
+                case 34:
                     e.d8 = c;
                     break;
-                case 105:
+                case 106:
                     e.selectionStart = typeGetValue(c);
                     break;
-                case 106:
+                case 107:
                     e.selectionEnd = typeGetValue(c);
                     break;
-                case 107:
+                case 108:
                     d.an = c;
                     break;
             }

package/esm2015/lib/XPopupBridge.js

@@ -165,28 +165,28 @@ let XPopupBridge = /*@__PURE__*/ (() => {
             let c = a;
             switch (b) {
                 case 22: return c.ax;
-                case 60: return c.av;
-                case 61: return c.aq;
+                case 61: return c.av;
+                case 62: return c.aq;
                 case 25: return c.am;
                 case 26: return c.a9;
                 case 17: return c.a1;
                 case 23: return c.c0;
-                case 35: switch (c.p) {
+                case 36: switch (c.p) {
                     case 1: return enumGetBox(NativeUIPopupAnimationType_$type, 1);
                     default: return enumGetBox(NativeUIPopupAnimationType_$type, 0);
                 }
-                case 36: return c.at;
-                case 37: return c.as;
-                case 40: return c.bb;
-                case 41: return c.au;
-                case 43: switch (c.v) {
+                case 37: return c.at;
+                case 38: return c.as;
+                case 41: return c.bb;
+                case 42: return c.au;
+                case 44: switch (c.v) {
                     case 1: return enumGetBox(NativeUIPopupPointerPosition_$type, 1);
                     default: return enumGetBox(NativeUIPopupPointerPosition_$type, 2);
                 }
-                case 42: return c.c4;
-                case 39: return c.ao;
-                case 62: return c.a4;
-                case 110: return c.ay;
+                case 43: return c.c4;
+                case 40: return c.ao;
+                case 63: return c.a4;
+                case 111: return c.ay;
             }
             return super.getValue(a, b);
         }
@@ -205,7 +205,7 @@ let XPopupBridge = /*@__PURE__*/ (() => {
                 case 23:
                     d.c0 = c;
                     break;
-                case 35:
+                case 36:
                     switch (EnumUtil.getEnumValue(NativeUIPopupAnimationType_$type, c)) {
                         case 1:
                             d.p = 1;
@@ -215,22 +215,22 @@ let XPopupBridge = /*@__PURE__*/ (() => {
                             break;
                     }
                     break;
-                case 36:
+                case 37:
                     d.at = c;
                     break;
-                case 37:
+                case 38:
                     d.as = c;
                     break;
-                case 40:
+                case 41:
                     d.bb = typeGetValue(c);
                     break;
-                case 41:
+                case 42:
                     d.au = c;
                     break;
-                case 42:
+                case 43:
                     d.c4 = c;
                     break;
-                case 43:
+                case 44:
                     switch (EnumUtil.getEnumValue(NativeUIPopupPointerPosition_$type, c)) {
                         case 1:
                             d.v = 1;
@@ -240,13 +240,13 @@ let XPopupBridge = /*@__PURE__*/ (() => {
                             break;
                     }
                     break;
-                case 39:
+                case 40:
                     d.ao = c;
                     break;
-                case 62:
+                case 63:
                     d.a4 = c;
                     break;
-                case 110:
+                case 111:
                     d.ay = c;
                     break;
             }
@@ -256,7 +256,7 @@ let XPopupBridge = /*@__PURE__*/ (() => {
             a.showRelativeToExclusionRect(b, this.v(c), this.u(d));
         }
         showRelativeToTarget(a, b, c, d) {
-            let e = b.an.getNativeElement();
+            let e = b.ao.getNativeElement();
             a.cr(e, this.v(c), this.u(d));
         }
         close(a) {
@@ -288,17 +288,17 @@ let XPopupBridge = /*@__PURE__*/ (() => {
             }
         }
         exportVisualData(a) {
-            return a.bg();
+            return a.bi();
         }
         addChild(a, b) {
             this.ae.add(b);
             let c = a;
-            c.appendPopupContent(b.an);
+            c.appendPopupContent(b.ao);
         }
         insertChild(a, b, c) {
             this.ae.add(c);
             let d = a;
-            d.appendPopupContent(c.an);
+            d.appendPopupContent(c.ao);
         }
         getChildAt(a, b) {
             return this.ae._inner[b];
@@ -308,12 +308,12 @@ let XPopupBridge = /*@__PURE__*/ (() => {
         }
         removeChild(a, b) {
             let c = a;
-            c.removePopupContent(b.an);
+            c.removePopupContent(b.ao);
             this.ae.remove(b);
         }
         removeChildAt(a, b) {
             let c = a;
-            c.removePopupContent(this.ae._inner[b].an);
+            c.removePopupContent(this.ae._inner[b].ao);
             this.ae.removeAt(b);
         }
     }

package/esm2015/lib/igc-multi-slider-thumb-collection.js

@@ -2,12 +2,12 @@ import { IgCollection } from "igniteui-webcomponents-core";
 import { markType } from "igniteui-webcomponents-core";
 import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
 import { MultiSliderThumb as MultiSliderThumb_internal } from './MultiSliderThumb';
-import { IgcMultiSliderThumb as IgcMultiSliderThumb } from './igc-multi-slider-thumb';
+import { IgcMultiSliderThumbComponent as IgcMultiSliderThumbComponent } from './igc-multi-slider-thumb-component';
 export class IgcMultiSliderThumbCollection extends IgCollection {
     constructor(list) {
         super();
-        if (!IgcMultiSliderThumb.$type) {
-            IgcMultiSliderThumb.$type = markType(IgcMultiSliderThumb, "IgcMultiSliderThumb");
+        if (!IgcMultiSliderThumbComponent.$type) {
+            IgcMultiSliderThumbComponent.$type = markType(IgcMultiSliderThumbComponent, "IgcMultiSliderThumbComponent");
         }
         if (list) {
             for (let i = 0; i < list.length; i++) {
@@ -16,10 +16,10 @@ export class IgcMultiSliderThumbCollection extends IgCollection {
         }
     }
     _createInnerColl() {
-        if (!IgcMultiSliderThumb.$type) {
-            IgcMultiSliderThumb.$type = markType(IgcMultiSliderThumb, "IgcMultiSliderThumb");
+        if (!IgcMultiSliderThumbComponent.$type) {
+            IgcMultiSliderThumbComponent.$type = markType(IgcMultiSliderThumbComponent, "IgcMultiSliderThumbComponent");
         }
-        let coll = new SyncableObservableCollection$2(IgcMultiSliderThumb.$type, MultiSliderThumb_internal.$type, 0);
+        let coll = new SyncableObservableCollection$2(IgcMultiSliderThumbComponent.$type, MultiSliderThumb_internal.$type, 0);
         coll.compare = (ext, int) => {
             let comp = ext;
             if (comp._implementation) {
@@ -36,7 +36,7 @@ export class IgcMultiSliderThumbCollection extends IgCollection {
         coll.createFrom = (int) => {
             let ext = int.externalObject;
             if (!ext) {
-                ext = new IgcMultiSliderThumb();
+                ext = new IgcMultiSliderThumbComponent();
                 if (ext) {
                     if (!int.$type && ext._implementation.setNativeElement) {
                         ext._implementation.setNativeElement(int);

package/esm2015/lib/igc-multi-slider-thumb-component.js

@@ -0,0 +1,271 @@
+import { IgcHTMLElement } from "igniteui-webcomponents-core";
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { MultiSliderThumbRangePosition_$type } from "./MultiSliderThumbRangePosition";
+import { IgcMultiSliderTrackThumbRange } from "./igc-multi-slider-track-thumb-range";
+import { IgcPropertyUpdatedEventArgs } from "igniteui-webcomponents-core";
+import { MultiSliderThumb } from "./MultiSliderThumb";
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+import { NamePatcher, getAllPropertyNames, fromSpinal, toSpinal, ensureEnum, enumToString, initializePropertiesFromCss } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+let IgcMultiSliderThumbComponent = /*@__PURE__*/ (() => {
+    class IgcMultiSliderThumbComponent extends IgcHTMLElement {
+        createImplementation() {
+            return new MultiSliderThumb();
+        }
+        /**
+         * @hidden
+         */
+        get i() {
+            return this._implementation;
+        } /**
+                                     * @hidden
+                                     */
+        static _createFromInternal(internal) {
+            if (!internal) {
+                return null;
+            }
+            if (!internal.$type) {
+                return null;
+            }
+            let name = internal.$type.name;
+            let externalName = "Igc" + name + "Component";
+            if (!TypeRegistrar.isRegistered(externalName)) {
+                return null;
+            }
+            return TypeRegistrar.create(externalName);
+        }
+        onImplementationCreated() {
+        }
+        constructor() {
+            super();
+            this._settingAttributes = false;
+            this._attached = false;
+            this._queuedSetAttributes = [];
+            this._updatingFromAttribute = false;
+            this.__p = null;
+            this._hasUserValues = new Set();
+            this._stylingContainer = null;
+            this._stylingParent = null;
+            this._inStyling = false;
+            this._propertyUpdated = null;
+            this._propertyUpdated_wrapped = null;
+            if (this._styling) {
+                NamePatcher.ensureStylablePatched(Object.getPrototypeOf(this));
+            }
+            this._implementation = this.createImplementation();
+            this._implementation.externalObject = this;
+            this.onImplementationCreated();
+            if (this._initializeAdapters) {
+                this._initializeAdapters();
+            }
+        }
+        _enqueueSetAttribute(attrName, attrValue) {
+            this._queuedSetAttributes.push({ attrName: attrName, attrValue: attrValue });
+        }
+        _flushQueuedAttributes() {
+            this._settingAttributes = true;
+            for (let i = 0; i < this._queuedSetAttributes.length; i++) {
+                this.setAttribute(this._queuedSetAttributes[i].attrName, this._queuedSetAttributes[i].attrValue);
+            }
+            this._settingAttributes = false;
+            this._queuedSetAttributes.length = 0;
+        }
+        _a(attrName, attrValue) {
+            if (this._updatingFromAttribute) {
+                return;
+            }
+            if (attrValue) {
+                attrValue = attrValue.toString();
+            }
+            this._settingAttributes = true;
+            attrName = toSpinal(attrName);
+            if (this._attached) {
+                this.setAttribute(attrName, attrValue);
+            }
+            else {
+                this._enqueueSetAttribute(attrName, attrValue);
+            }
+            this._settingAttributes = false;
+        }
+        connectedCallback() {
+            if (super["connectedCallback"]) {
+                super["connectedCallback"]();
+            }
+            if (this.i.connectedCallback) {
+                this.i.connectedCallback();
+            }
+            if (!this._attached) {
+                this._attached = true;
+                this._flushQueuedAttributes();
+            }
+        }
+        disconnectedCallback() {
+            if (super["disconnectedCallback"]) {
+                super["disconnectedCallback"]();
+            }
+            if (this.i.disconnectedCallback) {
+                this.i.disconnectedCallback();
+            }
+            if (this._attached) {
+                this._attached = false;
+            }
+        }
+        static get observedAttributes() {
+            if (IgcMultiSliderThumbComponent._observedAttributesIgcMultiSliderThumbComponent == null) {
+                let names = getAllPropertyNames(IgcMultiSliderThumbComponent);
+                for (let i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcMultiSliderThumbComponent._observedAttributesIgcMultiSliderThumbComponent = names;
+            }
+            return IgcMultiSliderThumbComponent._observedAttributesIgcMultiSliderThumbComponent;
+        }
+        attributeChangedCallback(name, oldValue, newValue) {
+            if (this._settingAttributes) {
+                return;
+            }
+            let setName = fromSpinal(name);
+            this._updatingFromAttribute = true;
+            this[setName] = newValue;
+            this._updatingFromAttribute = false;
+        }
+        static register() {
+            if (!IgcMultiSliderThumbComponent._isElementRegistered) {
+                IgcMultiSliderThumbComponent._isElementRegistered = true;
+                RegisterElementHelper.registerElement(IgcMultiSliderThumbComponent.htmlTagName, IgcMultiSliderThumbComponent);
+            }
+        }
+        get value() {
+            return this.i.s;
+        }
+        set value(v) {
+            this.i.s = +v;
+            this._a("value", this.i.s);
+        }
+        get rangePosition() {
+            return this.i.g;
+        }
+        set rangePosition(v) {
+            this.i.g = ensureEnum(MultiSliderThumbRangePosition_$type, v);
+            this._a("rangePosition", enumToString(MultiSliderThumbRangePosition_$type, this.i.g));
+        }
+        get range() {
+            const r = this.i.i;
+            if (r == null) {
+                return null;
+            }
+            if (!r.externalObject) {
+                let e = new IgcMultiSliderTrackThumbRange();
+                if (r.$type) {
+                    e._implementation = r;
+                }
+                else {
+                    if (e.i.setNativeElement) {
+                        e.i.setNativeElement(r);
+                    }
+                }
+                r.externalObject = e;
+            }
+            return r.externalObject;
+        }
+        set range(v) {
+            v == null ? this.i.i = null : this.i.i = v.i;
+        }
+        findByName(name) {
+            if (this.findEphemera) {
+                if (name && name.indexOf("@@e:") == 0) {
+                    return this.findEphemera(name);
+                }
+            }
+            if (this.range && this.range.name && this.range.name == name) {
+                return this.range;
+            }
+            return null;
+        }
+        get hasUserValues() {
+            return this._hasUserValues;
+        }
+        __m(propertyName) {
+            if (!this._inStyling) {
+                this._hasUserValues.add(propertyName);
+            }
+        }
+        _styling(container, component, parent) {
+            if (this._inStyling) {
+                return;
+            }
+            this._inStyling = true;
+            this._stylingContainer = container;
+            this._stylingParent = component;
+            let genericPrefix = "";
+            let typeName = this.i.$type.name;
+            if (typeName.indexOf("Xam") === 0) {
+                typeName = typeName.substring(3);
+            }
+            genericPrefix = toSpinal("MultiSliderThumbComponent");
+            let additionalPrefixes = [];
+            let prefix = toSpinal(typeName);
+            additionalPrefixes.push(prefix + "-");
+            let b = this.i.$type.baseType;
+            while (b && b.name != "Object" &&
+                b.name != "Base" &&
+                b.name != "Control" &&
+                b.Name != "DependencyObject" &&
+                b.Name != "FrameworkElement") {
+                typeName = b.name;
+                if (typeName.indexOf("Xam") === 0) {
+                    typeName = typeName.substring(3);
+                }
+                let basePrefix = toSpinal(typeName);
+                additionalPrefixes.push(basePrefix + "-");
+                b = b.baseType;
+            }
+            if (parent) {
+                let parentTypeName = parent.i.$type.name;
+                if (parentTypeName.indexOf("Xam") === 0) {
+                    parentTypeName = parentTypeName.substring(3);
+                }
+                let parentPrefix = toSpinal(parentTypeName);
+                additionalPrefixes.push(parentPrefix + "-" + genericPrefix + "-");
+                additionalPrefixes.push(parentPrefix + "-" + prefix + "-");
+            }
+            initializePropertiesFromCss(container, this, genericPrefix + "-", this.hasUserValues, false, additionalPrefixes);
+            if (this._otherStyling) {
+                this._otherStyling(container, component, parent);
+            }
+            this._inStyling = false;
+        }
+        push(amount) {
+            let iv = this.i.r(amount);
+            return (iv);
+        }
+        get propertyUpdated() {
+            return this._propertyUpdated;
+        }
+        set propertyUpdated(ev) {
+            if (this._propertyUpdated_wrapped !== null) {
+                this.i.propertyUpdated = delegateRemove(this.i.propertyUpdated, this._propertyUpdated_wrapped);
+                this._propertyUpdated_wrapped = null;
+                this._propertyUpdated = null;
+            }
+            this._propertyUpdated = ev;
+            this._propertyUpdated_wrapped = (o, e) => {
+                let outerArgs = new IgcPropertyUpdatedEventArgs();
+                outerArgs._provideImplementation(e);
+                if (this.beforePropertyUpdated) {
+                    this.beforePropertyUpdated(this, outerArgs);
+                }
+                if (this._propertyUpdated) {
+                    this._propertyUpdated(this, outerArgs);
+                }
+            };
+            this.i.propertyUpdated = delegateCombine(this.i.propertyUpdated, this._propertyUpdated_wrapped);
+            ;
+        }
+    }
+    IgcMultiSliderThumbComponent._observedAttributesIgcMultiSliderThumbComponent = null;
+    IgcMultiSliderThumbComponent.htmlTagName = "igc-multi-slider-thumb";
+    IgcMultiSliderThumbComponent._isElementRegistered = false;
+    return IgcMultiSliderThumbComponent;
+})();
+export { IgcMultiSliderThumbComponent };

package/esm2015/lib/igc-multi-slider-thumb-module.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 { IgcMultiSliderThumbComponent } from './igc-multi-slider-thumb-component';
+import { MultiSliderThumb } from './MultiSliderThumb';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+export class IgcMultiSliderThumbModule {
+    static register() {
+        IgcMultiSliderThumbComponent.register();
+        TypeRegistrar.registerCons("IgcMultiSliderThumbComponent", IgcMultiSliderThumbComponent);
+        TypeRegistrar.register("MultiSliderThumb", MultiSliderThumb.$type);
+    }
+}

package/esm2015/lib/igc-multi-slider-thumb-value-changing-event-args.js

@@ -1,4 +1,4 @@
-import { IgcMultiSliderThumb } from "./igc-multi-slider-thumb";
+import { IgcMultiSliderThumbComponent } from "./igc-multi-slider-thumb-component";
 import { MultiSliderThumbValueChangingEventArgs as MultiSliderThumbValueChangingEventArgs_internal } from "./MultiSliderThumbValueChangingEventArgs";
 export class IgcMultiSliderThumbValueChangingEventArgs {
     createImplementation() {
@@ -40,15 +40,10 @@ export class IgcMultiSliderThumbValueChangingEventArgs {
             return null;
         }
         if (!r.externalObject) {
-            let e = new IgcMultiSliderThumb();
-            if (r.$type) {
+            let e = IgcMultiSliderThumbComponent._createFromInternal(r);
+            if (e) {
                 e._implementation = r;
             }
-            else {
-                if (e.i.setNativeElement) {
-                    e.i.setNativeElement(r);
-                }
-            }
             r.externalObject = e;
         }
         return r.externalObject;

package/esm2015/lib/igc-multi-slider-track-thumb-range.js

@@ -1,4 +1,4 @@
-import { IgcMultiSliderThumb } from "./igc-multi-slider-thumb";
+import { IgcMultiSliderThumbComponent } from "./igc-multi-slider-thumb-component";
 import { MultiSliderTrackThumbRange as MultiSliderTrackThumbRange_internal } from "./MultiSliderTrackThumbRange";
 export class IgcMultiSliderTrackThumbRange {
     createImplementation() {
@@ -58,15 +58,10 @@ export class IgcMultiSliderTrackThumbRange {
             return null;
         }
         if (!r.externalObject) {
-            let e = new IgcMultiSliderThumb();
-            if (r.$type) {
+            let e = IgcMultiSliderThumbComponent._createFromInternal(r);
+            if (e) {
                 e._implementation = r;
             }
-            else {
-                if (e.i.setNativeElement) {
-                    e.i.setNativeElement(r);
-                }
-            }
             r.externalObject = e;
         }
         return r.externalObject;
@@ -80,15 +75,10 @@ export class IgcMultiSliderTrackThumbRange {
             return null;
         }
         if (!r.externalObject) {
-            let e = new IgcMultiSliderThumb();
-            if (r.$type) {
+            let e = IgcMultiSliderThumbComponent._createFromInternal(r);
+            if (e) {
                 e._implementation = r;
             }
-            else {
-                if (e.i.setNativeElement) {
-                    e.i.setNativeElement(r);
-                }
-            }
             r.externalObject = e;
         }
         return r.externalObject;