igniteui-webcomponents-layouts 3.2.3 → 3.5.0

package/esm2015/lib/igc-list-panel-template-width-requested-event-args.js

@@ -0,0 +1,42 @@
+import { ListPanelTemplateWidthRequestedEventArgs as ListPanelTemplateWidthRequestedEventArgs_internal } from "./ListPanelTemplateWidthRequestedEventArgs";
+export class IgcListPanelTemplateWidthRequestedEventArgs {
+    createImplementation() {
+        return new ListPanelTemplateWidthRequestedEventArgs_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+    }
+    get dataRow() {
+        return this.i.b;
+    }
+    set dataRow(v) {
+        this.i.b = +v;
+    }
+    get dataItem() {
+        return this.i.c;
+    }
+    set dataItem(v) {
+        this.i.c = v;
+    }
+    get width() {
+        return this.i.a;
+    }
+    set width(v) {
+        this.i.a = +v;
+    }
+}

package/esm2015/lib/igc-popup-component.js

@@ -245,6 +245,11 @@ export let IgcPopupComponent = /*@__PURE__*/ (() => {
             this._a("background", brushToString(this.i.a8));
         }
         findByName(name) {
+            if (this.findEphemera) {
+                if (name && name.indexOf("@@e:") == 0) {
+                    return this.findEphemera(name);
+                }
+            }
             return null;
         }
         get hasUserValues() {
@@ -347,6 +352,7 @@ export let IgcPopupComponent = /*@__PURE__*/ (() => {
                 }
             };
             this.i.onClosed = delegateCombine(this.i.onClosed, this._onClosed_wrapped);
+            ;
         }
         /**
          * Fires when the popup is shown
@@ -372,6 +378,7 @@ export let IgcPopupComponent = /*@__PURE__*/ (() => {
                 }
             };
             this.i.onPopup = delegateCombine(this.i.onPopup, this._onPopup_wrapped);
+            ;
         }
     }
     IgcPopupComponent._observedAttributesIgcPopupComponent = null;

package/esm2015/lib/igc-property-editor-data-source.js

@@ -22,10 +22,10 @@ export class IgcPropertyEditorDataSource {
         this.onImplementationCreated();
     }
     get descriptionType() {
-        return this.i.l;
+        return this.i.n;
     }
     set descriptionType(v) {
-        this.i.l = v;
+        this.i.n = v;
     }
     get context() {
         return this.i.b;
@@ -34,6 +34,11 @@ export class IgcPropertyEditorDataSource {
         this.i.b = v;
     }
     findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
         return null;
     }
 }

package/esm2015/lib/igc-property-editor-description-object.js

@@ -62,6 +62,11 @@ export class IgcPropertyEditorDescriptionObject {
         this.i.a = innerColl;
     }
     findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
         if (this.properties != null && this.properties.findByName && this.properties.findByName(name)) {
             return this.properties.findByName(name);
         }

package/esm2015/lib/igc-property-editor-panel-component.js

@@ -1,4 +1,4 @@
-import { fromSize, brushToString, stringToBrush, ensureBool, initializePropertiesFromCss, NamePatcher, toSpinal, getAllPropertyNames, fromSpinal } from "igniteui-webcomponents-core";
+import { brushToString, stringToBrush, ensureBool, initializePropertiesFromCss, NamePatcher, toSpinal, getAllPropertyNames, fromSpinal } from "igniteui-webcomponents-core";
 import { FontInfo } from "igniteui-webcomponents-core";
 import { WebComponentRenderer, PortalManager } from "igniteui-webcomponents-core";
 import { CollectionAdapter } from "igniteui-webcomponents-core";
@@ -356,6 +356,11 @@ export let IgcPropertyEditorPanelComponent = /*@__PURE__*/ (() => {
             this._a("textColor", brushToString(this.i.d9));
         }
         findByName(name) {
+            if (this.findEphemera) {
+                if (name && name.indexOf("@@e:") == 0) {
+                    return this.findEphemera(name);
+                }
+            }
             if (this.actualDataSource != null && this.actualDataSource.findByName && this.actualDataSource.findByName(name)) {
                 return this.actualDataSource.findByName(name);
             }
@@ -417,10 +422,6 @@ export let IgcPropertyEditorPanelComponent = /*@__PURE__*/ (() => {
             }
             this._inStyling = false;
         }
-        getDesiredSize() {
-            let iv = this.i.ea();
-            return fromSize(iv);
-        }
         notifySetItem(index, oldItem, newItem) {
             this.i.dq(index, oldItem, newItem);
         }

package/esm2015/lib/igc-property-editor-property-description-component.js

@@ -99,11 +99,25 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
             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 (IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent == null) {
                 let names = getAllPropertyNames(IgcPropertyEditorPropertyDescriptionComponent);
@@ -229,15 +243,21 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
             this._a("step", this.i.aa);
         }
         get complexValue() {
-            if (this.i.g == null) {
+            const r = this.i.g;
+            if (r == null) {
                 return null;
             }
-            if (!this.i.g.externalObject) {
+            if (!r.externalObject) {
                 let e = new IgcPropertyEditorDescriptionObject();
-                e._implementation = this.i.g;
-                this.i.g.externalObject = e;
+                if (e.i.setNativeElement) {
+                    e.i.setNativeElement(r);
+                }
+                else {
+                    e._implementation = r;
+                }
+                r.externalObject = e;
             }
-            return this.i.g.externalObject;
+            return r.externalObject;
         }
         set complexValue(v) {
             v == null ? this.i.g = null : this.i.g = v.i;
@@ -272,6 +292,11 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
             this.i.i = innerColl;
         }
         findByName(name) {
+            if (this.findEphemera) {
+                if (name && name.indexOf("@@e:") == 0) {
+                    return this.findEphemera(name);
+                }
+            }
             if (this.complexValue && this.complexValue.name && this.complexValue.name == name) {
                 return this.complexValue;
             }
@@ -354,6 +379,7 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
                 }
             };
             this.i.buttonClicked = delegateCombine(this.i.buttonClicked, this._buttonClicked_wrapped);
+            ;
         }
         get changed() {
             return this._changed;
@@ -376,6 +402,7 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
                 }
             };
             this.i.changed = delegateCombine(this.i.changed, this._changed_wrapped);
+            ;
         }
         get targetPropertyUpdating() {
             return this._targetPropertyUpdating;
@@ -398,6 +425,7 @@ export let IgcPropertyEditorPropertyDescriptionComponent = /*@__PURE__*/ (() =>
                 }
             };
             this.i.targetPropertyUpdating = delegateCombine(this.i.targetPropertyUpdating, this._targetPropertyUpdating_wrapped);
+            ;
         }
     }
     IgcPropertyEditorPropertyDescriptionComponent._observedAttributesIgcPropertyEditorPropertyDescriptionComponent = null;

package/esm2015/lib/igc-tool-action-checkbox-component.js

@@ -0,0 +1,63 @@
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionCheckbox } from "./ToolActionCheckbox";
+import { getAllPropertyNames, toSpinal } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+export let IgcToolActionCheckboxComponent = /*@__PURE__*/ (() => {
+    class IgcToolActionCheckboxComponent extends IgcToolActionComponent {
+        constructor() {
+            super();
+        }
+        createImplementation() {
+            return new ToolActionCheckbox();
+        }
+        /**
+                                     * @hidden
+                                     */
+        get i() {
+            return this._implementation;
+        }
+        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 (IgcToolActionCheckboxComponent._observedAttributesIgcToolActionCheckboxComponent == null) {
+                let names = getAllPropertyNames(IgcToolActionCheckboxComponent);
+                for (let i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcToolActionCheckboxComponent._observedAttributesIgcToolActionCheckboxComponent = names;
+            }
+            return IgcToolActionCheckboxComponent._observedAttributesIgcToolActionCheckboxComponent;
+        }
+        static register() {
+            if (!IgcToolActionCheckboxComponent._isElementRegistered) {
+                IgcToolActionCheckboxComponent._isElementRegistered = true;
+                RegisterElementHelper.registerElement(IgcToolActionCheckboxComponent.htmlTagName, IgcToolActionCheckboxComponent);
+            }
+        }
+    }
+    IgcToolActionCheckboxComponent._observedAttributesIgcToolActionCheckboxComponent = null;
+    IgcToolActionCheckboxComponent.htmlTagName = "igc-tool-action-checkbox";
+    IgcToolActionCheckboxComponent._isElementRegistered = false;
+    return IgcToolActionCheckboxComponent;
+})();

package/esm2015/lib/igc-tool-action-checkbox-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 { IgcToolActionCheckboxComponent } from './igc-tool-action-checkbox-component';
+import { ToolActionCheckbox } from './ToolActionCheckbox';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+export class IgcToolActionCheckboxModule {
+    static register() {
+        IgcToolActionCheckboxComponent.register();
+        TypeRegistrar.registerCons("IgcToolActionCheckboxComponent", IgcToolActionCheckboxComponent);
+        TypeRegistrar.register("ToolActionCheckbox", ToolActionCheckbox.$type);
+    }
+}

package/esm2015/lib/igc-tool-action-collection.js

@@ -0,0 +1,48 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolAction as ToolAction_internal } from './ToolAction';
+import { IgcToolActionComponent as IgcToolActionComponent } from './igc-tool-action-component';
+export class IgcToolActionCollection extends IgCollection {
+    constructor(list) {
+        super();
+        if (!IgcToolActionComponent.$type) {
+            IgcToolActionComponent.$type = markType(IgcToolActionComponent, "IgcToolActionComponent");
+        }
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                this.add(list[i]);
+            }
+        }
+    }
+    _createInnerColl() {
+        if (!IgcToolActionComponent.$type) {
+            IgcToolActionComponent.$type = markType(IgcToolActionComponent, "IgcToolActionComponent");
+        }
+        let coll = new SyncableObservableCollection$2(IgcToolActionComponent.$type, ToolAction_internal.$type, 0);
+        coll.compare = (ext, int) => {
+            let comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = (ext) => {
+            return ext._implementation;
+        };
+        coll.createFrom = (int) => {
+            let ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcToolActionComponent();
+                if (ext) {
+                    ext._implementation = int;
+                }
+            }
+            return ext;
+        };
+        return coll;
+    }
+}

package/esm2015/lib/igc-tool-action-component.js

@@ -0,0 +1,333 @@
+import { IgcHTMLElement } from "igniteui-webcomponents-core";
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { IgcToolCommandEventArgs } from "./igc-tool-command-event-args";
+import { IgcToolActionPerformedEventArgs } from "./igc-tool-action-performed-event-args";
+import { ToolAction } from "./ToolAction";
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+import { NamePatcher, getAllPropertyNames, fromSpinal, toSpinal, initializePropertiesFromCss } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+/**
+ * Represents base class for all tool actions in toolbar
+*/
+export let IgcToolActionComponent = /*@__PURE__*/ (() => {
+    class IgcToolActionComponent extends IgcHTMLElement {
+        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._onCommand = null;
+            this._onCommand_wrapped = null;
+            this._performed = null;
+            this._performed_wrapped = null;
+            if (this._styling) {
+                NamePatcher.ensureStylablePatched(Object.getPrototypeOf(this));
+            }
+            this._implementation = this.createImplementation();
+            this._implementation.externalObject = this;
+            this.onImplementationCreated();
+        }
+        createImplementation() {
+            return new ToolAction();
+        }
+        /**
+         * @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() {
+        }
+        _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 (IgcToolActionComponent._observedAttributesIgcToolActionComponent == null) {
+                let names = getAllPropertyNames(IgcToolActionComponent);
+                for (let i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcToolActionComponent._observedAttributesIgcToolActionComponent = names;
+            }
+            return IgcToolActionComponent._observedAttributesIgcToolActionComponent;
+        }
+        attributeChangedCallback(name, oldValue, newValue) {
+            if (this._settingAttributes) {
+                return;
+            }
+            let setName = fromSpinal(name);
+            this._updatingFromAttribute = true;
+            this[setName] = newValue;
+            this._updatingFromAttribute = false;
+        }
+        static register() {
+            if (!IgcToolActionComponent._isElementRegistered) {
+                IgcToolActionComponent._isElementRegistered = true;
+                RegisterElementHelper.registerElement(IgcToolActionComponent.htmlTagName, IgcToolActionComponent);
+            }
+        }
+        get id() {
+            return this.i.ao;
+        }
+        get parentId() {
+            return this.i.ax;
+        }
+        set parentId(v) {
+            this.i.ax = v;
+        }
+        get commandId() {
+            return this.i.ai;
+        }
+        set commandId(v) {
+            this.i.ai = v;
+        }
+        get commandArgument() {
+            return this.i.af;
+        }
+        set commandArgument(v) {
+            this.i.af = v;
+        }
+        get commandArgumentValue() {
+            return this.i.v;
+        }
+        set commandArgumentValue(v) {
+            this.i.v = v;
+        }
+        get paddingLeft() {
+            return this.i.r;
+        }
+        set paddingLeft(v) {
+            this.i.r = +v;
+            this._a("paddingLeft", this.i.r);
+        }
+        get paddingRight() {
+            return this.i.s;
+        }
+        set paddingRight(v) {
+            this.i.s = +v;
+            this._a("paddingRight", this.i.s);
+        }
+        get paddingBottom() {
+            return this.i.q;
+        }
+        set paddingBottom(v) {
+            this.i.q = +v;
+            this._a("paddingBottom", this.i.q);
+        }
+        get paddingTop() {
+            return this.i.t;
+        }
+        set paddingTop(v) {
+            this.i.t = +v;
+            this._a("paddingTop", this.i.t);
+        }
+        get name() {
+            return this.i.ar;
+        }
+        set name(v) {
+            this.i.ar = v;
+        }
+        get label() {
+            return this.i.ap;
+        }
+        set label(v) {
+            this.i.ap = v;
+        }
+        get iconName() {
+            return this.i.am;
+        }
+        set iconName(v) {
+            this.i.am = v;
+        }
+        get iconCollectionName() {
+            return this.i.ak;
+        }
+        set iconCollectionName(v) {
+            this.i.ak = v;
+        }
+        findByName(name) {
+            if (this.findEphemera) {
+                if (name && name.indexOf("@@e:") == 0) {
+                    return this.findEphemera(name);
+                }
+            }
+            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("ToolActionComponent");
+            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;
+        }
+        fromInfo(info) {
+            this.i.a6(info);
+        }
+        get onCommand() {
+            return this._onCommand;
+        }
+        set onCommand(ev) {
+            if (this._onCommand_wrapped !== null) {
+                this.i.onCommand = delegateRemove(this.i.onCommand, this._onCommand_wrapped);
+                this._onCommand_wrapped = null;
+                this._onCommand = null;
+            }
+            this._onCommand = ev;
+            this._onCommand_wrapped = (o, e) => {
+                let outerArgs = new IgcToolCommandEventArgs();
+                outerArgs._provideImplementation(e);
+                if (this.beforeOnCommand) {
+                    this.beforeOnCommand(this, outerArgs);
+                }
+                if (this._onCommand) {
+                    this._onCommand(this, outerArgs);
+                }
+            };
+            this.i.onCommand = delegateCombine(this.i.onCommand, this._onCommand_wrapped);
+            ;
+        }
+        get performed() {
+            return this._performed;
+        }
+        set performed(ev) {
+            if (this._performed_wrapped !== null) {
+                this.i.performed = delegateRemove(this.i.performed, this._performed_wrapped);
+                this._performed_wrapped = null;
+                this._performed = null;
+            }
+            this._performed = ev;
+            this._performed_wrapped = (o, e) => {
+                let outerArgs = new IgcToolActionPerformedEventArgs();
+                outerArgs._provideImplementation(e);
+                if (this.beforePerformed) {
+                    this.beforePerformed(this, outerArgs);
+                }
+                if (this._performed) {
+                    this._performed(this, outerArgs);
+                }
+            };
+            this.i.performed = delegateCombine(this.i.performed, this._performed_wrapped);
+            ;
+        }
+    }
+    IgcToolActionComponent._observedAttributesIgcToolActionComponent = null;
+    IgcToolActionComponent.htmlTagName = "igc-tool-action";
+    IgcToolActionComponent._isElementRegistered = false;
+    return IgcToolActionComponent;
+})();