@genexus/genexus-ide-ui 0.0.13 → 0.0.14

package/dist/collection/components/references/references.css

@@ -0,0 +1,194 @@
+/* Helper Classes */
+.gxi-hidden {
+  display: none !important;
+}
+
+.gxi-full-height {
+  height: 100%;
+}
+
+.align-start {
+  display: flex;
+  align-items: start;
+}
+
+.align-center {
+  display: flex;
+  align-items: center;
+}
+
+.align-end {
+  display: flex;
+  align-items: end;
+}
+
+/* Grids */
+.grid {
+  display: grid;
+  grid-row-gap: var(--gx-ide-grid-row-gap);
+  grid-column-gap: var(--gx-ide-grid-column-gap);
+  grid-template-rows: auto;
+}
+
+/*All components Host should have this class set. !important is set on every rule, since this styles could be overridden by the host user, since they are applied on the host component*/
+:host(.gx-ide-component) {
+  box-shadow: var(--box-shadow-01) !important;
+  height: 100% !important;
+  display: flex !important;
+  flex-direction: column !important;
+}
+
+/*stylize the top bar*/
+:host(:focus-within) gx-ide-top-bar::part(wrapper) {
+  background-color: var(--color-secondary-enabled);
+}
+
+/* Main wrapper (should be the first element inside the host. Everything should be inside .gx-ide-main-wrapper) */
+.gx-ide-main-wrapper {
+  color: var(--gx-ide-component-text-color);
+  font-weight: var(--font-weight-regular);
+  font-size: var(--font-size-lg);
+  line-height: 1.6em;
+  height: 100%;
+  background-color: var(--gx-ide-component-background-color);
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+}
+
+/*This is the main element. This is the one that take the remaining vertical space*/
+.gx-ide-main {
+  flex-grow: 1;
+  overflow-y: auto;
+  /* Track */
+  /* Handle */
+  /* Handle on hover */
+}
+.gx-ide-main::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+.gx-ide-main::-webkit-scrollbar-track {
+  background-color: var(--gray-02);
+  border-radius: 10px;
+}
+.gx-ide-main::-webkit-scrollbar-thumb {
+  background: var(--gray-05);
+  border-radius: 10px;
+}
+.gx-ide-main::-webkit-scrollbar-thumb:hover {
+  background: var(--gray-04);
+  cursor: pointer;
+}
+.gx-ide-main .gxg-scroll {
+  display: block;
+  overflow-y: auto;
+  padding-right: 2px;
+}
+
+.gx-ide-overflow {
+  overflow-y: auto;
+  /* Track */
+  /* Handle */
+  /* Handle on hover */
+}
+.gx-ide-overflow::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+.gx-ide-overflow::-webkit-scrollbar-track {
+  background-color: var(--gray-02);
+  border-radius: 10px;
+}
+.gx-ide-overflow::-webkit-scrollbar-thumb {
+  background: var(--gray-05);
+  border-radius: 10px;
+}
+.gx-ide-overflow::-webkit-scrollbar-thumb:hover {
+  background: var(--gray-04);
+  cursor: pointer;
+}
+.gx-ide-overflow .gxg-scroll {
+  display: block;
+  overflow-y: auto;
+  padding-right: 2px;
+}
+
+:host {
+  display: block;
+}
+
+/*HEADER*/
+.header {
+  /*Top*/
+  /*Bottom*/
+}
+.header__top {
+  grid-template-columns: min-content auto 1fr min-content;
+  grid-template-rows: 1fr;
+  grid-template-areas: "hide-bar-button suggest-label gxg-suggest selector-dialog-button";
+}
+.header__top .hide-bar-button {
+  grid-area: hide-bar-button;
+}
+.header__top .suggest-label {
+  grid-area: suggest-label;
+}
+.header__top gxg-suggest {
+  grid-area: gxg-suggest;
+}
+.header__top .selector-dialog-button {
+  grid-area: selector-dialog-button;
+}
+.header__bottom {
+  display: grid;
+  grid-template-rows: 1fr;
+  transition: var(--gx-ide-timing-super-fast-ms) grid-template-rows;
+}
+.header__bottom--hidden {
+  grid-template-rows: 0fr;
+}
+.header__bottom .outer-wrapper {
+  overflow: hidden;
+}
+.header__bottom .inner-wrapper {
+  padding-top: var(--gx-ide-grid-row-gap);
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-between;
+}
+.header__bottom .inner-wrapper__left {
+  display: flex;
+  align-items: center;
+  gap: var(--gx-ide-grid-row-gap);
+}
+
+/*Header hidable*/
+.header-hidden .first-row {
+  grid-template-columns: auto 1fr auto;
+}
+.header-hidden .first-row > :nth-child(3) {
+  align-self: end;
+}
+.header-hidden .second-row {
+  display: none;
+}
+
+/*MAIN*/
+.main {
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: 1fr;
+  grid-template-areas: "is-referenced has-references";
+  height: 100%;
+  gap: 0;
+}
+.main > *:first-child {
+  border-right: 1px solid var(--gx-ide-container-border-color);
+}
+.main .is-referenced {
+  grid-area: is-referenced;
+}
+.main .has-references {
+  grid-area: has-references;
+}

package/dist/collection/components/references/references.js

@@ -0,0 +1,377 @@
+/* STENCIL IMPORTS */
+import { Host, h } from "@stencil/core";
+/* OTHER LIBRARIES IMPORTS */
+/* CUSTOM IMPORTS */
+import { Locale } from "../../common/locale";
+import { renderTreeItems } from "../../common/render-tree";
+import { renderSuggestLists } from "../../common/render-suggest";
+import { convertObjectDataToSuggestData, convertReferenceDataToTreeData, updateSuggestedObjects } from "./helpers";
+export class GxIdeReferences {
+  constructor() {
+    /**
+     * Keeps an array of the last suggested objects, returned by selectorSourceCallback
+     */
+    this.suggestedObjects = [];
+    /**
+     * The references messages max. width that appear if the tree is empty or could not be retrieved.
+     */
+    this.referencesMessagesMaxWidth = "200px";
+    // 7.LISTENERS //
+    // 8.PUBLIC METHODS API //
+    // 9.LOCAL METHODS //
+    /**
+     * @description It attaches on the ch-suggest, the "itemSelected" event triggered by the ch-suggest-list-item. This helps set the new 'selectedObject'.
+     */
+    this.attachSelectObjectListener = () => {
+      this.selectObjectSuggestEl.addEventListener("itemSelected", (e) => {
+        const itemValue = e.detail.value;
+        this.selectedObject = this.suggestedObjects.find(item => {
+          return item.id === itemValue;
+        });
+      });
+    };
+    /**
+     * @description It attaches several events on the 'referencedByEl' element, which is a tree.
+     */
+    this.attachReferencedByListeners = () => {
+      /* 'toggleIconClicked' Event: This events gets fired when the user clicks on the toggle icon, that opens/close a tree. Here we only use it to check if the item has lazy items to be loaded. */
+      this.referencedByEl.addEventListener("toggleIconClicked", async (e) => {
+        if (e.detail.lazy && e.detail.id) {
+          this.loadReferencesCallback(e.detail.id, false)
+            .then(result => {
+            this.referencedBy = result;
+          })
+            .catch(() => {
+            // to do
+          });
+        }
+      });
+      /* 'selectionChanged' Event: Fired when a new tree item was selected.*/
+      this.referencedByEl.addEventListener("selectionChanged", (e) => {
+        this.selectReferenceCallback(e.detail.id);
+        /* Returns void Promise*/
+      });
+      /* 'doubleClicked' Event: Fired when a tree item was double-clicked.*/
+      this.referencedByEl.addEventListener("doubleClicked", (e) => {
+        this.openObjectCallback(e.detail.id);
+        /* Returns void Promise*/
+      });
+    };
+    /**
+     * @description It attaches several events on the 'referencesToEl' element, which is a tree.
+     */
+    this.attachReferencesToListeners = () => {
+      /* 'toggleIconClicked' Event: (Read description on 'attachReferencedByListeners' as it does the same)*/
+      this.referencesToEl.addEventListener("toggleIconClicked", async (e) => {
+        if (e.detail.lazy && e.detail.id) {
+          this.loadReferencesCallback(e.detail.id, true)
+            .then(result => {
+            this.referencesTo = result;
+          })
+            .catch(() => {
+            // to do
+          });
+        }
+      });
+      /* 'selectionChanged' Event: Fired when a new tree item was selected.*/
+      this.referencesToEl.addEventListener("selectionChanged", (e) => {
+        this.selectReferenceCallback(e.detail.id);
+        /* Returns void Promise*/
+      });
+      /* 'doubleClicked' Event: Fired when a tree item was double-clicked.*/
+      this.referencesToEl.addEventListener("doubleClicked", (e) => {
+        this.openObjectCallback(e.detail.id);
+        /* Returns void Promise*/
+      });
+    };
+    /**
+     * @description This handler gets fired every time the value of the 'Select Object' ch-suggest changes. Then, it calls the 'updateSuggestedObjects' method, that keeps the state of the last suggested objects that were passed bu the host. Also, it shows the suggested objects on the ch-suggest box.
+     */
+    this.selectObjectValueChangedHandler = async (e) => {
+      const value = e.detail;
+      this.selectorSourceCallback(value)
+        .then(result => {
+        /* update selected objects state*/
+        this.suggestedObjects = updateSuggestedObjects(result);
+        /* show suggestions*/
+        this.objectsSuggestions = convertObjectDataToSuggestData(result);
+      })
+        .catch(() => {
+        // to do
+      });
+    };
+    this.openObjectCallbackHandler = async () => {
+      this.openObjectCallback(this.selectedObject.id);
+      /* Returns an empty Promise*/
+    };
+    /**
+     * @description handler that gets fired when the use clicks on the ch-suggest button (...)
+     */
+    this.openSelectorDialogCallbackHandler = async () => {
+      this.selectedObject = await this.openSelectorDialogCallback();
+    };
+    /**
+     * @description It evaluates if loadReferencesCallback should be called, depending wether there is or not an actual selected object.
+     */
+    this.evaluateInitialReferenceData = () => {
+      var _a;
+      const selectedObjectId = (_a = this.selectedObject) === null || _a === void 0 ? void 0 : _a.id;
+      selectedObjectId && this.loadReferencesHandler(selectedObjectId);
+    };
+    /**
+     * @description This method invokes 'loadReferencesCallback' callback for 'Is Referenced By' and 'Has References To' panels.
+     */
+    this.loadReferencesHandler = async (id) => {
+      /* Referenced By*/
+      if (this.loadReferencesCallback) {
+        this.loadReferencesCallback(id, false)
+          .then(result => {
+          this.referencedBy = result;
+        })
+          .catch(() => {
+          /* To do*/
+        });
+      }
+      /* References To*/
+      if (this.loadReferencesCallback) {
+        this.loadReferencesCallback(id, true)
+          .then(result => {
+          this.referencesTo = result;
+        })
+          .catch(() => {
+          /* To do*/
+        });
+      }
+    };
+    /**
+     * @description It hides/show the bar (The header bottom section).
+     */
+    this.hideBarButtonClickedHandler = () => {
+      this.barHidden = !this.barHidden;
+    };
+    this.barHidden = false;
+    this.objectsSuggestions = undefined;
+    this.referencedBy = undefined;
+    this.referencesTo = undefined;
+    this.hideTopBar = false;
+    this.selectedObject = undefined;
+    this.selectorSourceCallback = undefined;
+    this.loadReferencesCallback = undefined;
+    this.openObjectCallback = undefined;
+    this.openSelectorDialogCallback = undefined;
+    this.selectReferenceCallback = undefined;
+  }
+  selectedObjectHandler(newSelectedObject) {
+    this.loadReferencesHandler(newSelectedObject.id);
+  }
+  // 6.COMPONENT LIFECYCLE EVENTS //
+  async componentWillLoad() {
+    this._componentLocale = await Locale.getComponentStrings(this.el);
+    this.evaluateInitialReferenceData();
+  }
+  componentDidLoad() {
+    this.attachSelectObjectListener();
+    this.attachReferencedByListeners();
+    this.attachReferencesToListeners();
+  }
+  componentDidRender() {
+    this.componentDidRenderEvent.emit(this._componentLocale.componentName);
+  }
+  // 10.RENDER() FUNCTION //
+  render() {
+    var _a, _b, _c, _d, _e, _f;
+    return (h(Host, { class: "gx-ide-component" }, !this.hideTopBar ? (h("gx-ide-top-bar", { topBarTitle: this._componentLocale.componentName })) : null, h("div", { class: "gx-ide-main-wrapper gx-ide-overflow" }, h("gx-ide-container", { displayBorderBottom: true }, h("header", { class: "header" }, h("div", { class: "header__top grid" }, h("gxg-button", { icon: "navigation/arrow-down", type: "secondary-icon-only", class: "hide-bar-button", onClick: this.hideBarButtonClickedHandler, part: "toggle-bar-button" }), h("gxg-label", { labelPosition: "start", class: "suggest-label", part: "select-object-label" }, this._componentLocale.header.selectObject), h("gxg-suggest", null, h("ch-suggest", { value: this.selectedObject.id, onValueChanged: this.selectObjectValueChangedHandler, ref: el => (this.selectObjectSuggestEl = el), part: "object-selector-suggest" }, renderSuggestLists(this.objectsSuggestions))), h("gxg-button", { type: "secondary-icon-only", icon: "gemini-tools/show-more-horizontal", onClick: this.openSelectorDialogCallbackHandler, class: "selector-dialog-button", part: "open-selector-dialog-button" })), h("div", { class: {
+        "header__bottom": true,
+        "header__bottom--hidden": this.barHidden
+      } }, h("div", { class: "outer-wrapper" }, h("div", { class: "inner-wrapper" }, h("div", { class: "inner-wrapper__left" }, h("gxg-icon", { type: this.selectedObject.icon, color: "auto" }), h("gxg-text", { padding: "s", type: "text-link", part: "open-object-text-link", onClick: this.openObjectCallbackHandler }, `${this.selectedObject.name} : ${this.selectedObject.description}`)), h("div", { class: "inner-wrapper__right gxi-hidden" }, h("gxg-form-checkbox", { id: "references-by-type", label: "Group references by type", required: true, "display-validation-styles": true, part: "references-type-checkbox" }))))))), h("main", { class: "main grid" }, h("gx-ide-container", { containerTitle: this._componentLocale.main.isReferencedBy, justifyContent: "center", part: "referenced-by-container" }, h("gxg-tree", { ref: el => (this.referencedByEl = el), class: { "gxi-hidden": !((_a = this.referencedBy) === null || _a === void 0 ? void 0 : _a.length) }, checkbox: false, part: "referenced-by-tree" }, renderTreeItems(convertReferenceDataToTreeData(this.referencedBy))), !((_b = this.referencedBy) === null || _b === void 0 ? void 0 : _b.length) && (h("gxg-text", { textAlign: "center", padding: "m", type: "text-regular", maxWidth: this.referencesMessagesMaxWidth, part: "referenced-by-text" }, ((_c = this.referencedBy) === null || _c === void 0 ? void 0 : _c.length) === 0
+      ? this._componentLocale.main.isReferencedByEmpty
+      : this._componentLocale.main.isReferencedByError))), h("gx-ide-container", { containerTitle: this._componentLocale.main.hasReferencesTo, justifyContent: "center", part: "references-to-container" }, h("gxg-tree", { ref: el => (this.referencesToEl = el), class: { "gxi-hidden": !((_d = this.referencesTo) === null || _d === void 0 ? void 0 : _d.length) }, checkbox: false, part: "references-to-tree" }, renderTreeItems(convertReferenceDataToTreeData(this.referencesTo))), !((_e = this.referencesTo) === null || _e === void 0 ? void 0 : _e.length) && (h("gxg-text", { textAlign: "center", padding: "m", type: "text-regular", maxWidth: this.referencesMessagesMaxWidth, part: "references-to-text" }, ((_f = this.referencesTo) === null || _f === void 0 ? void 0 : _f.length) === 0
+      ? this._componentLocale.main.hasReferencesEmpty
+      : this._componentLocale.main.hasReferencesToError)))))));
+  }
+  static get is() { return "gx-ide-references"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["references.scss"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["references.css"]
+    };
+  }
+  static get assetsDirs() { return ["gx-ide-assets/references"]; }
+  static get properties() {
+    return {
+      "hideTopBar": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "false",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "If true, will hide the top-bar"
+        },
+        "attribute": "hide-top-bar",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "selectedObject": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "ObjectData",
+          "resolved": "{ id: string; icon: string; name: string; description?: string; }",
+          "references": {
+            "ObjectData": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Currently selected object"
+        }
+      },
+      "selectorSourceCallback": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "SelectorSourceCallback",
+          "resolved": "(prefix: string) => Promise<SelectorCategoryData[]>",
+          "references": {
+            "SelectorSourceCallback": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Callback invoked when user writes on object selector input, return possible options to show in autocomplete list"
+        }
+      },
+      "loadReferencesCallback": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "LoadReferencesCallback",
+          "resolved": "(id: string, to: boolean) => Promise<ReferenceData[]>",
+          "references": {
+            "LoadReferencesCallback": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Callback invoked when a node is expanded in any of the references panels"
+        }
+      },
+      "openObjectCallback": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "OpenObjectCallback",
+          "resolved": "(id: string) => Promise<void>",
+          "references": {
+            "OpenObjectCallback": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Callback invoked when user wants to open an object"
+        }
+      },
+      "openSelectorDialogCallback": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "OpenSelectorDialogCallback",
+          "resolved": "() => Promise<ObjectData>",
+          "references": {
+            "OpenSelectorDialogCallback": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Callback invoked when user wants to show object selection dialog"
+        }
+      },
+      "selectReferenceCallback": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "SelectReferenceCallback",
+          "resolved": "(id: string) => Promise<void>",
+          "references": {
+            "SelectReferenceCallback": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Callback invoked when any item from the references panels is selected"
+        }
+      }
+    };
+  }
+  static get states() {
+    return {
+      "barHidden": {},
+      "objectsSuggestions": {},
+      "referencedBy": {},
+      "referencesTo": {}
+    };
+  }
+  static get events() {
+    return [{
+        "method": "componentDidRenderEvent",
+        "name": "componentDidRenderEvent",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [{
+              "name": "description",
+              "text": "Gets fired when the component has rendered for the first time."
+            }],
+          "text": ""
+        },
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        }
+      }];
+  }
+  static get elementRef() { return "el"; }
+  static get watchers() {
+    return [{
+        "propName": "selectedObject",
+        "methodName": "selectedObjectHandler"
+      }];
+  }
+}

package/dist/collection/index.js

@@ -1,2 +1,3 @@
 import "@genexus/gemini";
 export * from "./components";
+import "@genexus/chameleon-controls-library";

package/dist/components/ch-suggest-list-item.js

@@ -1,61 +1,4 @@
-import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
-
-const chSuggestListItemCss = ":host{display:block}:where(button){all:unset;display:flex;width:100%;cursor:pointer}*,::after,::before{box-sizing:border-box}";
-
-const ARROW_DOWN = "ArrowDown";
-const ARROW_UP = "ArrowUp";
-const ChSuggestListItem$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
-  constructor() {
-    super();
-    this.__registerHost();
-    this.__attachShadow();
-    this.itemSelected = createEvent(this, "itemSelected", 7);
-    this.focusChangeAttempt = createEvent(this, "focusChangeAttempt", 7);
-    // 6.COMPONENT LIFECYCLE EVENTS //
-    // 7.LISTENERS //
-    // 8.PUBLIC METHODS API //
-    // 9.LOCAL METHODS //
-    this.handleClick = () => {
-      this.itemSelected.emit({
-        value: this.value || this.el.innerText,
-        description: this.description
-      });
-    };
-    this.handleKeyDown = (e) => {
-      if (e.code === ARROW_UP || e.code === ARROW_DOWN) {
-        e.preventDefault();
-        this.focusChangeAttempt.emit({
-          el: this.el,
-          code: e.code
-        });
-      }
-    };
-  }
-  // 10.RENDER() FUNCTION //
-  render() {
-    return (h(Host, { role: "listitem", onKeyDown: this.handleKeyDown }, h("button", { part: "button", onClick: this.handleClick }, h("slot", { name: "icon" }), h("div", { class: "content-wrapper", part: "content-wrapper" }, h("slot", null), this.description && (h("span", { part: "description" }, this.description))))));
-  }
-  static get delegatesFocus() { return true; }
-  get el() { return this; }
-  static get style() { return chSuggestListItemCss; }
-}, [17, "ch-suggest-list-item", {
-    "iconSrc": [1, "icon-src"],
-    "description": [1],
-    "value": [8]
-  }]);
-function defineCustomElement$1() {
-  if (typeof customElements === "undefined") {
-    return;
-  }
-  const components = ["ch-suggest-list-item"];
-  components.forEach(tagName => { switch (tagName) {
-    case "ch-suggest-list-item":
-      if (!customElements.get(tagName)) {
-        customElements.define(tagName, ChSuggestListItem$1);
-      }
-      break;
-  } });
-}
+import { C as ChSuggestListItem$1, d as defineCustomElement$1 } from './ch-suggest-list-item2.js';
 
 const ChSuggestListItem = ChSuggestListItem$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/{esm/ch-suggest-list-item.entry.js → components/ch-suggest-list-item2.js}

@@ -1,12 +1,14 @@
-import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-4f0a5746.js';
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
 
 const chSuggestListItemCss = ":host{display:block}:where(button){all:unset;display:flex;width:100%;cursor:pointer}*,::after,::before{box-sizing:border-box}";
 
 const ARROW_DOWN = "ArrowDown";
 const ARROW_UP = "ArrowUp";
-const ChSuggestListItem = class {
-  constructor(hostRef) {
-    registerInstance(this, hostRef);
+const ChSuggestListItem = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.__attachShadow();
     this.itemSelected = createEvent(this, "itemSelected", 7);
     this.focusChangeAttempt = createEvent(this, "focusChangeAttempt", 7);
     // 6.COMPONENT LIFECYCLE EVENTS //
@@ -34,8 +36,25 @@ const ChSuggestListItem = class {
     return (h(Host, { role: "listitem", onKeyDown: this.handleKeyDown }, h("button", { part: "button", onClick: this.handleClick }, h("slot", { name: "icon" }), h("div", { class: "content-wrapper", part: "content-wrapper" }, h("slot", null), this.description && (h("span", { part: "description" }, this.description))))));
   }
   static get delegatesFocus() { return true; }
-  get el() { return getElement(this); }
-};
-ChSuggestListItem.style = chSuggestListItemCss;
+  get el() { return this; }
+  static get style() { return chSuggestListItemCss; }
+}, [17, "ch-suggest-list-item", {
+    "iconSrc": [1, "icon-src"],
+    "description": [1],
+    "value": [8]
+  }]);
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["ch-suggest-list-item"];
+  components.forEach(tagName => { switch (tagName) {
+    case "ch-suggest-list-item":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ChSuggestListItem);
+      }
+      break;
+  } });
+}
 
-export { ChSuggestListItem as ch_suggest_list_item };
+export { ChSuggestListItem as C, defineCustomElement as d };