@genexus/genexus-ide-ui 0.0.60 → 0.0.61

package/dist/components/gx-ide-kb-manager-import.js

@@ -0,0 +1,499 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { L as Locale } from './locale.js';
+import { c as config } from './config.js';
+import { c as countTreeItems } from './helpers2.js';
+import { d as defineCustomElement$m } from './checkbox.js';
+import { d as defineCustomElement$l } from './icon.js';
+import { d as defineCustomElement$k } from './tree-x.js';
+import { d as defineCustomElement$j } from './tree-x-list-item.js';
+import { d as defineCustomElement$i } from './ch-window2.js';
+import { d as defineCustomElement$h } from './ch-window-close2.js';
+import { d as defineCustomElement$g } from './container.js';
+import { d as defineCustomElement$f } from './list-selector.js';
+import { d as defineCustomElement$e } from './list-selector-item.js';
+import { d as defineCustomElement$d } from './gx-ide-status-buttons2.js';
+import { d as defineCustomElement$c } from './button.js';
+import { d as defineCustomElement$b } from './button-group.js';
+import { d as defineCustomElement$a } from './form-checkbox.js';
+import { d as defineCustomElement$9 } from './form-text.js';
+import { d as defineCustomElement$8 } from './icon2.js';
+import { d as defineCustomElement$7 } from './ide-loader.js';
+import { d as defineCustomElement$6 } from './gxg-label2.js';
+import { d as defineCustomElement$5 } from './text.js';
+import { d as defineCustomElement$4 } from './title.js';
+import { d as defineCustomElement$3 } from './tooltip.js';
+import { d as defineCustomElement$2 } from './tree-view.js';
+
+const convertImportItemToTreeItem = (importCatIcon, importItems) => {
+  const importTreeItems = [];
+  importItems.forEach(importItem => {
+    importTreeItems.push({
+      id: importItem.id,
+      caption: importItem.name,
+      leftImgSrc: importCatIcon,
+      checkbox: true,
+      expanded: true,
+      leaf: true,
+      class: "object"
+    });
+  });
+  return importTreeItems;
+};
+/**
+ * @description This function converts ReferenceData[] data to TreeItemData[]
+ */
+const convertImportCategoryToTreeView = (importCategoryData) => {
+  const treeData = [];
+  if (!importCategoryData) {
+    return treeData;
+  }
+  importCategoryData.forEach(importCat => {
+    const importCategoryTreeItem = {
+      id: importCat.id,
+      caption: `${importCat.name} (${importCat.items.length})`,
+      leftImgSrc: importCat.icon,
+      checkbox: true,
+      expanded: true,
+      leaf: false,
+      class: "category",
+      items: convertImportItemToTreeItem(importCat.icon, importCat.items)
+    };
+    treeData.push(importCategoryTreeItem);
+  });
+  return treeData;
+};
+const createImportResultDataMessages = (importItemId, messagesArray) => {
+  const messages = [];
+  messagesArray.forEach((message, i) => {
+    messages.push({
+      id: `${importItemId}-message-${i}}]`,
+      caption: message,
+      leftImgSrc: "gx-test/test-results",
+      leaf: true
+    });
+  });
+  return messages;
+};
+const updateImportStatusTree = (importItemResultFullData, importTreeActualState) => {
+  var _a;
+  const objectCategoryIndex = importTreeActualState.findIndex(objectCategoryItem => {
+    return objectCategoryItem.id === importItemResultFullData.categoryId;
+  });
+  if (objectCategoryIndex === -1) {
+    // object category node does not exists. We have to create it, and insert the import result tree node inside.
+    const importTreeItem = {
+      id: importItemResultFullData.categoryId,
+      // the count is (1), because this is the first item for this category
+      caption: `${importItemResultFullData.categoryName} (1)`,
+      leftImgSrc: importItemResultFullData.categoryIcon,
+      class: `tree-view-item tree-view-item--${importItemResultFullData.status}`,
+      expanded: true,
+      items: [
+        {
+          id: importItemResultFullData.id,
+          caption: importItemResultFullData.name,
+          items: createImportResultDataMessages(importItemResultFullData.id, importItemResultFullData.messages),
+          class: `tree-view-item tree-view-item--${importItemResultFullData.status}`,
+          expanded: true,
+          leaf: importItemResultFullData.messages.length === 0
+        }
+      ]
+    };
+    importTreeActualState.push(importTreeItem);
+  }
+  else {
+    // Object category node already exists. Just create the import result node, and insert into the parent category node (if it doesn't exists already).
+    // first search for the importItemResult node...
+    const importItemIndex = (_a = importTreeActualState[objectCategoryIndex].items) === null || _a === void 0 ? void 0 : _a.findIndex(importItem => {
+      return importItem.id === importItemResultFullData.id;
+    });
+    if (importItemIndex === -1) {
+      // ImportItem does not exists already
+      const importTreeItem = {
+        id: importItemResultFullData.id,
+        caption: importItemResultFullData.name,
+        expanded: true,
+        items: createImportResultDataMessages(importItemResultFullData.id, importItemResultFullData.messages),
+        class: `tree-view-item tree-view-item--${importItemResultFullData.status}`
+      };
+      // Insert the import node into the category node
+      importTreeActualState[objectCategoryIndex].items.push(importTreeItem);
+      // Then, update the category node caption (the name is the same, but the (count) should be the actual items.length, because we have just added a new child import node. )
+      importTreeActualState[objectCategoryIndex].caption = `${importItemResultFullData.categoryName} (${importTreeActualState[objectCategoryIndex].items.length})`;
+    }
+  }
+  return importTreeActualState;
+};
+/**
+ * This function takes an ImportItemResultData item, and updates it to a ImportCategoryFullData, which has the same information, plus the category parent needed information, that will be used for creating the "virtual" parent category node on the "Import Status" section.
+ */
+const createImportResultFullData = (importItemResultData, importCategoryData) => {
+  const importCategoryFullData = Object.assign({ categoryId: undefined, categoryName: undefined, categoryIcon: undefined }, importItemResultData);
+  importCategoryDataFor: for (let i = 0; i < importCategoryData.length; i++) {
+    const categoryNode = importCategoryData[i];
+    for (let j = 0; j < categoryNode.items.length; j++) {
+      if (categoryNode.items[j].id === importItemResultData.id) {
+        importCategoryFullData.categoryId = categoryNode.id;
+        importCategoryFullData.categoryName = categoryNode.name;
+        importCategoryFullData.categoryIcon = categoryNode.icon;
+        break importCategoryDataFor;
+      }
+    }
+  }
+  return importCategoryFullData;
+};
+/**
+ * @description This function adds an ImportItemResultData item to the "importTreeState", and returns the updated tree with the new item added.
+ */
+const addImportItemResultDataItem = (importItemResultData, importCategoryData, importTreeActualState) => {
+  let updatedImportStatusTree = [...importTreeActualState];
+  // first, update importItemResultData with the category data. It will be needed later.
+  const importItemResultFullData = createImportResultFullData(importItemResultData, importCategoryData);
+  updatedImportStatusTree = updateImportStatusTree(importItemResultFullData, updatedImportStatusTree);
+  return updatedImportStatusTree;
+};
+
+const kbManagerImportCss = ".gxi-hidden{display:none !important}.gxi-full-height{height:100%}.gxi-overflow-auto{overflow:auto}.gxi-display-flex{display:flex}.align-start{display:flex;align-items:start}.align-center{display:flex;align-items:center}.align-end{display:flex;align-items:end}.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}ch-grid-cell{display:flex}ch-grid{overflow:auto;height:100%}ch-grid-column{z-index:99;border-bottom:1px solid var(--gray-01)}gxg-tabs{box-shadow:none}:host(.gx-ide-component){box-shadow:var(--box-shadow-01) !important;height:100% !important;display:flex !important;flex-direction:column !important}:host(:focus-within) gx-ide-top-bar::part(wrapper){background-color:var(--color-secondary-enabled)}.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}.gx-ide-main{flex-grow:1;overflow-y:auto;}.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-inline-end:2px}.gx-ide-overflow{overflow-y:auto;}.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-inline-end:2px}:host{display:block}.header{display:flex;flex-direction:row;gap:var(--gx-ide-grid-column-gap)}.header .select-file{flex:1}.main{min-height:250px;display:grid;grid-template-columns:1fr 1fr}.main .left-grid-item{border-right:1px solid var(--gx-ide-container-border-color)}.main .tree-container{height:100%;max-height:300px;display:flex;}.main .tree-container--empty{align-items:center;justify-content:center}.main .tree-container--import-status .tree-view-item--success::part(action){grid-template:\"first-img left-img text right-img\"/max-content max-content 1fr max-content}.main .tree-container--import-status .tree-view-item--success::part(action)::before{grid-area:first-img;content:\"\";width:var(--spacing-comp-02);height:var(--spacing-comp-02);border-radius:50%;background-color:var(--gray-03);background-color:var(--color-success-dark)}.main .tree-container--import-status .tree-view-item--warning::part(action){grid-template:\"first-img left-img text right-img\"/max-content max-content 1fr max-content}.main .tree-container--import-status .tree-view-item--warning::part(action)::before{grid-area:first-img;content:\"\";width:var(--spacing-comp-02);height:var(--spacing-comp-02);border-radius:50%;background-color:var(--gray-03);background-color:var(--color-warning-dark)}.main .tree-container--import-status .tree-view-item--error::part(action){grid-template:\"first-img left-img text right-img\"/max-content max-content 1fr max-content}.main .tree-container--import-status .tree-view-item--error::part(action)::before{grid-area:first-img;content:\"\";width:var(--spacing-comp-02);height:var(--spacing-comp-02);border-radius:50%;background-color:var(--gray-03);background-color:var(--color-error-dark)}.main .tree-container--no-warnings .tree-view-item--warning{display:none}.main .tree-container--no-errors .tree-view-item--error{display:none}.main .tree-container--no-successes .tree-view-item--success{display:none}.ghost-element{display:block;width:0;height:24px;}";
+
+const GxIdeKbManagerImport$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.__attachShadow();
+    this.componentDidRenderFirstTime = createEvent(this, "componentDidRenderFirstTime", 7);
+    this.componentDidLoadEvent = createEvent(this, "componentDidLoadEvent", 7);
+    this.renderedFirstTime = false;
+    /* ImportCategoryBasicData Holds the original name of category data, and its id. Used to create parent nodes on the imported tree*/
+    this.importCategoryData = [];
+    this.objectsInFileTotalNodes = 0;
+    // 9.LOCAL METHODS //
+    this.evaluateObjects = () => {
+      var _a;
+      this.noObjects = !!(((_a = this.objectsTreeState) === null || _a === void 0 ? void 0 : _a.length) === 0 || !this.objectsTreeState);
+    };
+    this.evaluateImport = () => {
+      var _a;
+      this.noImport = !!(((_a = this.importTreeState) === null || _a === void 0 ? void 0 : _a.length) === 0 || !this.importTreeState);
+    };
+    this.selectFileHandler = () => {
+      this.fileInputEl.openFile();
+    };
+    this.loadFileHandler = async () => {
+      if (this.loadCallback && this.selectedFile) {
+        this.importCategoryData = await this.loadCallback(this.selectedFile);
+        const importCategoryTreeData = convertImportCategoryToTreeView(this.importCategoryData);
+        this.objectsTreeState = importCategoryTreeData;
+        if (this.importCategoryData.length > 0) {
+          // clear input
+          this.selectedFile = null;
+        }
+      }
+    };
+    this.fileSelectedHandler = (fileEvent) => {
+      this.selectedFile = fileEvent.detail[0];
+    };
+    this.evaluateHeaderActiveButton = () => {
+      if (!this.selectedFile) {
+        this.headerButtonsGroup.activeButtonId = "select-file-btn";
+        this.fileInputEl.value = undefined;
+      }
+      else {
+        this.headerButtonsGroup.activeButtonId = "load-file-btn";
+      }
+    };
+    this.importObjectsHandler = async () => {
+      if (this.importCallback) {
+        this.importingObjects = true;
+        this.objectsButtonsGroup.activeButtonId = "cancel-import-btn";
+        const result = await this.importCallback(this.checkedObjectsIds);
+        if (result || result === false) {
+          this.importingObjects = false;
+          this.objectsButtonsGroup.activeButtonId = "import-btn";
+        }
+      }
+    };
+    this.objectsTreeCheckedItemsChangedHandler = (event) => {
+      const allItemsWithCheckbox = [...event.detail.values()];
+      const checkedItems = allItemsWithCheckbox.filter(node => node.item.checked);
+      // objects checked
+      const checkedObjects = checkedItems.filter(node => node.item.class === "object");
+      const checkedObjectsIds = [];
+      if (checkedObjects.length > 0) {
+        checkedObjects.forEach(objectChecked => {
+          checkedObjectsIds.push(objectChecked.item.id);
+        });
+      }
+      this.checkedObjectsIds = checkedObjectsIds;
+    };
+    this.cancelImportHandler = () => {
+      if (this.cancelCallback) {
+        this.cancelCallback();
+        // returns boolean
+      }
+    };
+    this.optionsHandler = () => {
+      if (this.optionsCallback) {
+        this.optionsCallback();
+        // returns boolean
+      }
+    };
+    this.clearStatusHandler = () => {
+      this.importTreeState = [];
+      this.statusInfo.error.number = 0;
+      this.statusInfo.warning.number = 0;
+      this.statusInfo.success.number = 0;
+    };
+    this.selectAllClickedHandler = () => {
+      const checked = this.checkAllCheckboxEl.checked;
+      if (checked && this.objectsTreeEl) {
+        console.log("check");
+        this.objectsTreeEl.updateAllItemsProperties({ checked: true });
+      }
+    };
+    this.statusButtonsSelectionChangedHandler = (e) => {
+      const activeStates = e.detail;
+      const newStatusInfo = Object.assign({}, this.statusInfo);
+      newStatusInfo.warning.display = false;
+      newStatusInfo.error.display = false;
+      newStatusInfo.success.display = false;
+      activeStates.forEach(activeState => {
+        const status = activeState.itemId;
+        newStatusInfo[status].display = true;
+        this.statusInfo = newStatusInfo;
+      });
+      this.evaluateHiddenImportsMessage();
+    };
+    this.evaluateHiddenImportsMessage = () => {
+      /* to do*/
+    };
+    this.checkedObjectsIds = [];
+    this.noObjects = undefined;
+    this.showHiddenImportsMessage = false;
+    this.statusInfo = {
+      error: {
+        display: true,
+        number: 0
+      },
+      warning: {
+        display: true,
+        number: 0
+      },
+      success: {
+        display: true,
+        number: 0
+      }
+    };
+    this.objectsTreeState = [];
+    this.noImport = undefined;
+    this.importTreeState = [];
+    this.importingObjects = false;
+    this.selectedFile = undefined;
+    this.optionsCallback = undefined;
+    this.importCallback = undefined;
+    this.loadCallback = undefined;
+    this.cancelCallback = undefined;
+    this.statusMinimal = false;
+  }
+  watchObjectsTreeStateHandler(newState) {
+    this.noObjects = !!(newState.length === 0 || !newState);
+    this.objectsInFileTotalNodes = countTreeItems(newState);
+  }
+  watchImportTreeStateHandler(newState) {
+    this.noImport = !!(newState.length === 0 || !newState);
+  }
+  watchSelectedFileHandler() {
+    this.evaluateHeaderActiveButton();
+  }
+  // 6.COMPONENT LIFECYCLE EVENTS //
+  async componentWillLoad() {
+    this._componentLocale = await Locale.getComponentStrings(this.el);
+    this.componentDidLoadEvent.emit(true);
+    this.evaluateObjects();
+    this.evaluateImport();
+  }
+  componentDidRender() {
+    if (!this.renderedFirstTime) {
+      this.componentDidRenderFirstTime.emit(this._componentLocale.componentName);
+      this.renderedFirstTime = true;
+    }
+  }
+  // 7.LISTENERS //
+  // 8.PUBLIC METHODS API //
+  /**
+   * Add the result of importing an item
+   */
+  async addResultItem(item) {
+    this.importTreeState = addImportItemResultDataItem(item, this.importCategoryData, this.importTreeState);
+    this.statusInfo[`${item.status}`].number += item.messages.length;
+  }
+  //  10.RENDER() FUNCTION //
+  render() {
+    return (h(Host, { class: "gx-ide-component" }, h("div", { class: "gx-ide-main-wrapper" }, h("gx-ide-container", { noContentPadding: true, noFooterPadding: true }, h("header", { class: "header", slot: "header" }, h("gxg-form-text", { type: "file", class: "select-file", label: this._componentLocale.header.fileNameLabel, placeholder: this._componentLocale.header.fileNamePlaceholder, part: "file-name", acceptFile: ".xpz, .xml", clearButton: true, iconPosition: "start", onFileSelected: this.fileSelectedHandler, ref: (el) => (this.fileInputEl = el) }), h("gxg-button-group", {
+      // default-selected-btn-id="select-file-btn"
+      ref: (el) => (this.headerButtonsGroup = el)
+    }, h("button", { id: "select-file-btn", part: "select-file-button", onClick: this.selectFileHandler }, this._componentLocale.header.selectFileButton), h("button", { id: "load-file-btn", part: "load-file-button", disabled: !this.selectedFile, onClick: this.loadFileHandler }, this._componentLocale.header.loadButton))), h("main", { class: "main" }, h("gx-ide-container", { containerTitle: this._componentLocale.main.objectsInFile.title, noContentPadding: true, noBorderFooter: true, class: "left-grid-item", slimmerFooter: true, inactiveTitle: this.noObjects, footerSubtleShadow: !this.noObjects }, h("div", { class: {
+        "tree-container": true,
+        "tree-container--objects-in-file": true,
+        "tree-container--empty": this.noObjects
+      } }, !this.noObjects ? (h("gxg-tree-view", { positionRelative: true, treeModel: this.objectsTreeState, toggleCheckboxes: true, onCheckedItemsChange: this.objectsTreeCheckedItemsChangedHandler, ref: el => (this.objectsTreeEl = el) })) : (h("gxg-text", { textAlign: config.gxgMessage.common.textAlign, padding: config.gxgMessage.common.textAlign, type: config.gxgMessage.common.type, maxWidth: config.gxgMessage.common.maxWidth, part: "objects-in-file-empty-status-message" }, "There are no Objects. ", h("br", null), h("gxg-text", { type: "text-link-no-line", onClick: this.selectFileHandler }, "Begin by selecting a file.")))), h("gxg-form-checkbox", { label: this.objectsTreeState.length > 0 &&
+        this.objectsInFileTotalNodes ===
+          this.checkedObjectsIds.length
+        ? this._componentLocale.main.objectsInFile.deselectAll
+        : this._componentLocale.main.objectsInFile.selectAll, part: "select-all-checkbox", slot: "footer-start", disabled: this.importingObjects || this.objectsTreeState.length === 0, ref: el => (this.checkAllCheckboxEl = el), onClick: this.selectAllClickedHandler }), h("gxg-button-group", { slot: "footer-end", ref: (el) => (this.objectsButtonsGroup = el) }, h("button", { id: "import-btn", part: "import-button", disabled: this.importingObjects ||
+        this.checkedObjectsIds.length === 0, onClick: this.importObjectsHandler }, this._componentLocale.main.objectsInFile.importButton), h("button", { id: "cancel-import-btn", part: "cancel-import-button", disabled: !this.importingObjects, onClick: this.cancelImportHandler }, this._componentLocale.main.objectsInFile.cancelButton)), h("gxg-button", { type: "secondary-icon-only", icon: "gemini-tools/settings", slot: "footer-end", part: "select-kb-btn", onClick: this.optionsHandler }, this._componentLocale.header.optionsButton)), h("gx-ide-container", { containerTitle: this._componentLocale.main.importStatus.title, noContentPadding: true, noBorderFooter: true, slimmerFooter: true, inactiveTitle: this.noImport, footerSubtleShadow: !this.noImport, class: "right-grid-item" }, h("div", { class: {
+        "tree-container": true,
+        "tree-container--import-status": true,
+        "tree-container--empty": this.noImport,
+        "tree-container--no-warnings": !this.statusInfo.warning.display,
+        "tree-container--no-errors": !this.statusInfo.error.display,
+        "tree-container--no-successes": this.statusInfo.success.display === false
+      } }, !this.noImport ? (h("gxg-tree-view", { positionRelative: true, treeModel: this.importTreeState, toggleCheckboxes: true, ref: el => (this.objectsTreeEl = el) })) : (h("gxg-text", { textAlign: config.gxgMessage.common.textAlign, padding: config.gxgMessage.common.textAlign, type: config.gxgMessage.common.type, maxWidth: config.gxgMessage.common.maxWidth, part: "objects-in-file-empty-status-message" }, "There are no Imported files."))), h("gxg-text", { type: "button-like", slot: "footer-end", part: "select-kb-btn", onClick: this.clearStatusHandler, disabled: this.noImport }, this._componentLocale.main.importStatus.clearButton), h("span", { class: "ghost-element", slot: "footer-start" }))), h("footer", { slot: "footer-start" }, h("gx-ide-status-buttons", { errors: this.statusInfo.error.number, warnings: this.statusInfo.warning.number, successes: this.statusInfo.success.number, compact: true, noBorderTop: true, noBorderBottom: true, noBorderStart: true, minimal: this.statusMinimal, onSelectionChanged: this.statusButtonsSelectionChangedHandler }))), h("gxg-ide-loader", { description: "Importing objects..." }))));
+  }
+  static get assetsDirs() { return ["gx-ide-assets/kb-manager-import"]; }
+  get el() { return this; }
+  static get watchers() { return {
+    "objectsTreeState": ["watchObjectsTreeStateHandler"],
+    "importTreeState": ["watchImportTreeStateHandler"],
+    "selectedFile": ["watchSelectedFileHandler"]
+  }; }
+  static get style() { return kbManagerImportCss; }
+}, [1, "gx-ide-kb-manager-import", {
+    "selectedFile": [1040],
+    "optionsCallback": [16],
+    "importCallback": [16],
+    "loadCallback": [16],
+    "cancelCallback": [16],
+    "statusMinimal": [4, "status-minimal"],
+    "checkedObjectsIds": [32],
+    "noObjects": [32],
+    "showHiddenImportsMessage": [32],
+    "statusInfo": [32],
+    "objectsTreeState": [32],
+    "noImport": [32],
+    "importTreeState": [32],
+    "importingObjects": [32],
+    "addResultItem": [64]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["gx-ide-kb-manager-import", "ch-checkbox", "ch-icon", "ch-tree-x", "ch-tree-x-list-item", "ch-window", "ch-window-close", "gx-ide-container", "gx-ide-list-selector", "gx-ide-list-selector-item", "gx-ide-status-buttons", "gxg-button", "gxg-button-group", "gxg-form-checkbox", "gxg-form-text", "gxg-icon", "gxg-ide-loader", "gxg-label", "gxg-text", "gxg-title", "gxg-tooltip", "gxg-tree-view"];
+  components.forEach(tagName => { switch (tagName) {
+    case "gx-ide-kb-manager-import":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, GxIdeKbManagerImport$1);
+      }
+      break;
+    case "ch-checkbox":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$m();
+      }
+      break;
+    case "ch-icon":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$l();
+      }
+      break;
+    case "ch-tree-x":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$k();
+      }
+      break;
+    case "ch-tree-x-list-item":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$j();
+      }
+      break;
+    case "ch-window":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$i();
+      }
+      break;
+    case "ch-window-close":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$h();
+      }
+      break;
+    case "gx-ide-container":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$g();
+      }
+      break;
+    case "gx-ide-list-selector":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$f();
+      }
+      break;
+    case "gx-ide-list-selector-item":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$e();
+      }
+      break;
+    case "gx-ide-status-buttons":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$d();
+      }
+      break;
+    case "gxg-button":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$c();
+      }
+      break;
+    case "gxg-button-group":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$b();
+      }
+      break;
+    case "gxg-form-checkbox":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$a();
+      }
+      break;
+    case "gxg-form-text":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$9();
+      }
+      break;
+    case "gxg-icon":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$8();
+      }
+      break;
+    case "gxg-ide-loader":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$7();
+      }
+      break;
+    case "gxg-label":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$6();
+      }
+      break;
+    case "gxg-text":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$5();
+      }
+      break;
+    case "gxg-title":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$4();
+      }
+      break;
+    case "gxg-tooltip":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$3();
+      }
+      break;
+    case "gxg-tree-view":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+
+const GxIdeKbManagerImport = GxIdeKbManagerImport$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { GxIdeKbManagerImport, defineCustomElement };

package/dist/components/gx-ide-list-selector-item.js

@@ -1,105 +1,4 @@
-import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
-
-const listSelectorItemCss = "*,::after,::before{box-sizing:border-box}gx-ide-list-selector-item{display:block;max-width:100%;display:flex}gx-ide-list-selector-item:not(:last-child){border-block-end:1px solid var(--gx-ide-container-border-color)}gx-ide-list-selector-item[selectable]:not([selectable=false]):hover label{cursor:pointer;background-color:var(--gxg-background-color-item-hover)}gx-ide-list-selector-item[ellipsis]:not([ellipsis=false]) label{overflow:hidden;white-space:nowrap;text-overflow:ellipsis}input{width:0;height:0;opacity:0;margin:0}input:focus+label{outline:var(--border-width-md) solid var(--color-primary-active);outline-offset:-2px}input:checked+label{background-color:var(--gxg-background-color-item-selected)}label{flex-shrink:0;display:block;padding:var(--spacing-comp-01);width:100%}";
-
-const GxIdeListSelectorItem$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
-  constructor() {
-    super();
-    this.__registerHost();
-    this.itemSelected = createEvent(this, "itemSelected", 7);
-    // 6.COMPONENT LIFECYCLE METHODS //
-    // 7.LISTENERS //
-    // 8.PUBLIC METHODS API //
-    // 9.LOCAL METHODS //
-    /**
-     * Evaluates if is selectable, considering the parent list-selector 'selectable' property value, only if it is undefined on this item
-     */
-    this.evaluateSelectable = () => {
-      if (this.selectable === undefined && this.parentIsListSelector) {
-        this.selectable = this.parentList.selectable;
-      }
-    };
-    /**
-     * Evaluates if text should truncate with ellipsis, considering the parent list-selector 'ellipsis' property value, only if it is undefined on this item
-     */
-    this.evaluateEllipsis = () => {
-      if (this.ellipsis === undefined && this.parentIsListSelector) {
-        this.ellipsis = this.parentList.ellipsis;
-      }
-    };
-    /**
-     * Evaluates if this item should be initially checked, only if the parent list-selector listValue equals this item value.
-     */
-    this.evaluateChecked = () => {
-      if (this.checked === undefined &&
-        this.parentIsListSelector &&
-        this.parentList.value !== undefined &&
-        this.parentList.value === this.itemValue) {
-        this.checked = true;
-      }
-    };
-    /**
-     * Checks if this item parentElement is a gx-ide-list-selector, and assigns a reference
-     */
-    this.evaluateParentIsListSelector = () => {
-      const parentList = this.el.parentElement;
-      this.parentIsListSelector = (parentList === null || parentList === void 0 ? void 0 : parentList.nodeName) === "GX-IDE-LIST-SELECTOR";
-      this.parentIsListSelector && (this.parentList = parentList);
-    };
-    /**
-     * Gets the listName required value, that is needed for the list selection to properly work
-     */
-    this.assignName = () => {
-      this.parentIsListSelector &&
-        this.parentList.listName &&
-        (this.name = this.parentList.listName);
-    };
-    this.onChangeHandler = () => {
-      if (this.selectable) {
-        this.itemSelected.emit({
-          itemId: this.itemId,
-          itemValue: this.itemValue
-        });
-      }
-    };
-    this.itemId = undefined;
-    this.itemValue = undefined;
-    this.selectable = undefined;
-    this.ellipsis = undefined;
-  }
-  // 5.EVENTS (EMIT) //
-  componentWillLoad() {
-    this.evaluateParentIsListSelector();
-    this.evaluateSelectable();
-    this.evaluateEllipsis();
-    this.evaluateChecked();
-    this.assignName();
-  }
-  // 10.RENDER() FUNCTION //
-  render() {
-    return (h(Host, { role: "listitem" }, h("input", { type: "radio", id: this.itemId, name: this.name, value: this.itemValue, checked: this.checked, onChange: this.onChangeHandler, disabled: !this.selectable }), h("label", { htmlFor: this.itemId }, this.itemValue)));
-  }
-  get el() { return this; }
-  static get style() { return listSelectorItemCss; }
-}, [0, "gx-ide-list-selector-item", {
-    "itemId": [1, "item-id"],
-    "itemValue": [1, "item-value"],
-    "selectable": [1540],
-    "ellipsis": [1540]
-  }]);
-function defineCustomElement$1() {
-  if (typeof customElements === "undefined") {
-    return;
-  }
-  const components = ["gx-ide-list-selector-item"];
-  components.forEach(tagName => { switch (tagName) {
-    case "gx-ide-list-selector-item":
-      if (!customElements.get(tagName)) {
-        customElements.define(tagName, GxIdeListSelectorItem$1);
-      }
-      break;
-  } });
-}
+import { G as GxIdeListSelectorItem$1, d as defineCustomElement$1 } from './list-selector-item.js';
 
 const GxIdeListSelectorItem = GxIdeListSelectorItem$1;
 const defineCustomElement = defineCustomElement$1;