@genexus/genexus-ide-ui 1.1.34 → 1.1.36

package/dist/collection/components/team-dev/update/update.js

@@ -1,281 +1,548 @@
-/* STENCIL IMPORTS */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m")
+        throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _GxIdeTeamDevUpdate_componentLocale, _GxIdeTeamDevUpdate_actionsComboBoxModel, _GxIdeTeamDevUpdate_rowCheckedChangedByTheUser, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, _GxIdeTeamDevUpdate_updateCheckedClickedHandler, _GxIdeTeamDevUpdate_reloadClickedHandler, _GxIdeTeamDevUpdate_updateObjectsHandler, _GxIdeTeamDevUpdate_renderActionCellContent, _GxIdeTeamDevUpdate_updateSingleObject, _GxIdeTeamDevUpdate_renderObjectStatus, _GxIdeTeamDevUpdate_renderRows, _GxIdeTeamDevUpdate_rowMarkingChangedHandler, _GxIdeTeamDevUpdate_updatePendingCheckedItems, _GxIdeTeamDevUpdate_searchInputHandler, _GxIdeTeamDevUpdate_actionChangedHandler, _GxIdeTeamDevUpdate_typeChangedHandler, _GxIdeTeamDevUpdate_setInitialObjectsStatus, _GxIdeTeamDevUpdate_loadData, _GxIdeTeamDevUpdate_markPendingObjects, _GxIdeTeamDevUpdate_applyClientFilter, _GxIdeTeamDevUpdate_onRowContextMenuHandler, _GxIdeTeamDevUpdate_revertPendingCommitsCheckboxes, _GxIdeTeamDevUpdate_togglePendingCommitsCheckboxes, _GxIdeTeamDevUpdate_kbPropertiesChangedHandler;
 import { Host, h } from "@stencil/core";
-/* CUSTOM IMPORTS */
+import { getIconPath } from "@genexus/mercury";
 import { Locale } from "../../../common/locale";
-import { config } from "../../../common/config";
-import { renderComboItems } from "../../../common/render-combo-items";
+import { renderObjectTypeWithIcon } from "../common/utilities";
 import { formatDate } from "../../../common/helpers";
+import { config } from "../../../common/config";
+import { mapObjectTypeToComboBoxItemModel } from "../version-control/common/object-type-to-combo-box";
 const CSS_BUNDLES = [
     "resets/box-sizing",
-    "components/tabular-grid"
+    "components/tabular-grid",
+    "utils/form--full",
+    "utils/layout",
+    "utils/typography",
+    "utils/spacing",
+    "chameleon/scrollbar"
 ];
+const CHECKBOX_CHECKED_VALUE = "true";
+const CHECKBOX_UNCHECKED_VALUE = "false";
+const DETAIL_LABEL_CLASSES = "detail__label body-semi-bold-s";
+// icons
+const ADD_ICON = getIconPath({
+    category: "system",
+    name: "add",
+    colorType: "on-elevation"
+});
+const EDITED_ICON = getIconPath({
+    category: "system",
+    name: "edit",
+    colorType: "on-elevation"
+});
+const FILTER_ICON = getIconPath({
+    category: "window-tools",
+    name: "filter",
+    colorType: "on-elevation"
+});
+const SEARCH_ICON = getIconPath({
+    category: "system",
+    name: "search",
+    colorType: "on-elevation"
+});
+const SUBSTRACT_ICON = getIconPath({
+    category: "system",
+    name: "substract",
+    colorType: "on-elevation"
+});
+const WARNING_ICON = getIconPath({
+    category: "system",
+    name: "warning",
+    colorType: "warning"
+});
+const ERROR_ICON = getIconPath({
+    category: "system",
+    name: "error",
+    colorType: "error"
+});
+const SUCCESS_ICON = getIconPath({
+    category: "system",
+    name: "check ",
+    colorType: "success"
+});
+const INFO_ICON = getIconPath({
+    category: "system",
+    name: "information",
+    colorType: "on-elevation"
+});
+const REFRESH_ICON = getIconPath({
+    category: "gemini-tools",
+    name: "reset",
+    colorType: "neutral"
+});
 export class GxIdeTeamDevUpdate {
     constructor() {
-        this.loadDataCalledFirstTime = false; // pending for update grid checkboxes, should be checked, after loadData has loaded objects for the first time.
-        this.renderedFirstTime = false;
-        // 9.LOCAL METHODS //
-        this.onRowContextMenuHandler = (grid) => async (ev) => {
-            if (this.objectsContextMenuCallback) {
-                ev.preventDefault();
-                ev.stopPropagation();
-                let selection = [];
-                if (grid === "pending") {
-                    selection = await this.chGridPendingForUpdateEl.getSelectedRows();
+        /**
+         * The component hard-coded strings translations.
+         */
+        // eslint-disable-next-line @stencil-community/own-props-must-be-private
+        _GxIdeTeamDevUpdate_componentLocale.set(this, void 0);
+        _GxIdeTeamDevUpdate_actionsComboBoxModel.set(this, void 0);
+        /**
+         * Used to determine if pendingItemsCheckedCallback callback has to be called or not.
+         * It should be ignored if the grid checkboxes state is changed programmatically, by
+         * setting markRow to false once the object has been successfully updated, for example.
+         */
+        _GxIdeTeamDevUpdate_rowCheckedChangedByTheUser.set(this, true);
+        _GxIdeTeamDevUpdate_chGridPendingForUpdateEl.set(this, void 0);
+        _GxIdeTeamDevUpdate_updateCheckedClickedHandler.set(this, async () => {
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_updateObjectsHandler, "f").call(this, [...this.markedObjectsSet]);
+        });
+        _GxIdeTeamDevUpdate_reloadClickedHandler.set(this, async () => {
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this, true);
+        });
+        _GxIdeTeamDevUpdate_updateObjectsHandler.set(this, async (selection) => {
+            __classPrivateFieldSet(this, _GxIdeTeamDevUpdate_rowCheckedChangedByTheUser, false, "f");
+            this.updating = true;
+            selection.forEach(itemToUpdate => {
+                this.objectsStatusMap.set(itemToUpdate, "updating");
+            });
+            const updateResult = await this.updateCallback(selection);
+            updateResult.forEach(async (objectResult) => {
+                const messages = objectResult.messages;
+                if (messages.length) {
+                    this.objectsMessagesDataMap.set(objectResult.id, objectResult.messages);
                 }
-                else if (grid === "ignored") {
-                    selection = await this.chGridIgnoredObjectsEl.getSelectedRows();
+                else {
+                    // clear messages
+                    this.objectsMessagesDataMap.delete(objectResult.id);
                 }
-                else if (grid === "results") {
-                    selection = await this.chGridResultsEl.getSelectedRows();
+                if (objectResult.result === "updated") {
+                    this.alreadyUpdatedObjectsIdsSet.add(objectResult.id);
+                    this.objectsStatusMap.set(objectResult.id, "updated");
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").markRow(objectResult.id, false);
                 }
-                await this.objectsContextMenuCallback(grid, {
-                    selection: selection,
-                    clientX: ev.detail.clientX,
-                    clientY: ev.detail.clientY
-                });
+                else {
+                    this.objectsStatusMap.set(objectResult.id, "pending");
+                }
+            });
+            this.updating = false;
+        });
+        _GxIdeTeamDevUpdate_renderActionCellContent.set(this, (action) => {
+            let icon;
+            let caption;
+            let iconColor;
+            if (action === "deleted") {
+                icon = SUBSTRACT_ICON;
+                caption = __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.delete;
+                iconColor = "--mer-icon__error";
             }
-        };
-        this.markAllPendingToUpdateRows = () => {
-            this.chGridPendingForUpdateEl.markAllRows();
-        };
-        this.gridOnSelectionChangedCallbackHandler = (grid) => async (ev) => {
-            if (this.selectCallback) {
-                await this.selectCallback(grid, ev.detail.rowsId);
+            else if (action === "inserted") {
+                icon = ADD_ICON;
+                caption = __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.insert;
+                iconColor = "--mer-icon__success";
             }
-        };
-        this.genexusServerUrlHandler = () => {
-            var _a;
-            if ((_a = this.updateFrom) === null || _a === void 0 ? void 0 : _a.serverUrl) {
-                window.open(this.updateFrom.serverUrl);
+            else if (action === "modified") {
+                icon = EDITED_ICON;
+                caption = __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.modify;
+                iconColor = "--mer-icon__warning";
             }
-        };
-        this.renderOptions = () => {
-            return (h("div", { class: "options-wrapper" }, h("gx-ide-container", { part: "options-update-from", containerTitle: this._componentLocale.options.updateFrom, titleType: "secondary", contentBorderEnd: true, noContentPadding: true }, h("gx-ide-list-selector", { type: "single-selection", listName: "commit-recent-messages", readonly: true, noListBorder: true }, h("gx-ide-list-selector-item", { icon: "window-tools/genexus-cloud", itemId: "genexus-server", itemValue: undefined, class: "genexus-server", onClick: this.genexusServerUrlHandler }, `${this._componentLocale.options.updateFrom}:`, h("gxg-text", { type: "text-link" }, this.updateFrom ? this.updateFrom.serverUrl : "")), h("gx-ide-list-selector-item", { icon: "general/knowledge-base", itemId: "knowledge-base", itemValue: `${this._componentLocale.options.knowledgeBase}: ${this.updateFrom ? this.updateFrom.kbName : ""}` }), h("gx-ide-list-selector-item", { icon: "general/version", itemId: "version", itemValue: `${this._componentLocale.options.version}: ${this.updateFrom ? this.updateFrom.versionName : ""}` }), h("gx-ide-list-selector-item", { icon: "window-tools/last-changes-view", itemId: "last-full-update", itemValue: `${this._componentLocale.options.lastFullUpdate}: ${formatDate(this.updateFrom.lastFullUpdate)}` }))), h("gx-ide-container", { part: "options-scope", containerTitle: this._componentLocale.options.scope, titleType: "secondary" }, h("div", { class: "scope" }, h("div", { class: "row" }, h("gxg-label", { labelPosition: "start", center: true, noMargin: true }, this._componentLocale.options.objects, ":"), h("span", { class: {
-                    bold: this.objectScopeText === "partial",
-                    value: true
-                } }, this._componentLocale.options.scopeData.objects[this.objectScopeText.toLocaleLowerCase()]), h("gxg-text", { type: "text-link", onClick: this.objectsScope, part: "gxg-button gxg-button--scope-objects-change" }, this._componentLocale.options.changeBtn)), h("div", { class: "row" }, h("gxg-label", { labelPosition: "start", center: true, noMargin: true }, this._componentLocale.options.revision, ":"), h("span", { class: {
-                    bold: this.revisionScopeText !== undefined,
-                    value: true
-                } }, this.revisionScopeText === undefined
-                ? this._componentLocale.options.scopeData.revision.latest
-                : this.revisionScopeText), h("gxg-text", { type: "text-link", onClick: this.revisionScope, part: "gxg-button gxg-button--scope-revision-change" }, this._componentLocale.options.changeBtn)), h("div", { class: "row" }, h("gxg-form-checkbox", { label: this._componentLocale.options.kbProperties, class: "align-center", part: "option-kb-properties" }))))));
-        };
-        this.renderFilter = () => {
-            return (h("div", { class: {
-                    "filter-row": true
-                } }, h("gxg-form-text", { "label-position": "start", centerLabel: true, label: this._componentLocale.filter.pattern, ref: (el) => (this.filterPatternEl = el), part: "filter-pattern", onInput: this.loadData, class: "combo" }), h("gxg-combo-box", { "label-position": "start", centerLabel: true, "disable-filter": true, label: this._componentLocale.filter.type, disabled: !this.types, ref: (el) => (this.filterTypeEl = el), onValueChanged: this.loadData, part: "filter-type", value: this.types[0].id, class: "combo" }, renderComboItems(this.types)), h("gxg-button", { type: "secondary-icon-only", icon: "gemini-tools/reset", onClick: this.loadData, part: "gxg-button gxg-button--reload", class: "button" })));
-        };
-        this.renderData = () => {
-            return (h("gx-ide-container", { part: "data-container", noContentPadding: true, class: "gxi-overflow-auto", displayBorderTop: true }, h("gxg-tabs", { id: "dataTabs", part: "data-tabs" }, h("gxg-tab-bar", { slot: "tab-bar-container", displayBorder: true }, h("gxg-tab-button", { slot: "tab-bar", "tab-label": this._componentLocale.tabs.pendingForUpdate, tab: "pendingForUpdate", key: "pendingForUpdate", isSelected: true }), h("gxg-tab-button", { slot: "tab-bar", "tab-label": this._componentLocale.tabs.ignoredObjects, tab: "ignoredObjects", key: "ignoredObjects" }), h("gxg-tab-button", { slot: "tab-bar", "tab-label": this._componentLocale.tabs.results, tab: "results", key: "results", ref: (el) => (this.gxgTabButtonResultsEl = el) })), h("gxg-tab", { tab: "pendingForUpdate", key: "pendingForUpdate", noPadding: true, isSelected: true }, this.renderPendingForUpdate()), h("gxg-tab", { tab: "ignoredObjects", key: "ignoredObjects", noPadding: true }, this.renderIgnoredObjects()), h("gxg-tab", { tab: "results", key: "results", noPadding: true }, this.renderResults()))));
-        };
-        this.renderPendingForUpdate = () => {
-            return (h("ch-tabular-grid", { class: "tabular-grid tabular-grid-pending-update", "row-selection-mode": "multiple", ref: (el) => (this.chGridPendingForUpdateEl = el), part: "ch-tabular-grid-pending-for-updates", onRowContextMenu: this.onRowContextMenuHandler("pending"), onSelectionChanged: this.gridOnSelectionChangedCallbackHandler("pending") }, h("ch-tabular-grid-columnset", { class: "tabular-grid-column-set" }, h("ch-tabular-grid-column", { settingable: false, sortable: false, "column-type": "rich", richRowSelector: true, richRowSelectorMode: "mark", size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { settingable: false, sortable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { settingable: false, sortable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.name, settingable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.type, settingable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.description, settingable: false, size: config.tabularGrid.colSize.commonDouble, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.modifiedOn, settingable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.status, settingable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.action, settingable: false, size: config.tabularGrid.colSize.maxContent, class: "tabular-grid-column" })), this.updateData.pendingForUpdate.map((obj) => (h("ch-tabular-grid-row", { rowid: obj.id, class: "tabular-grid-row" }, h("ch-tabular-grid-cell", { "cell-type": "rich", "row-selector": true, class: "tabular-grid-cell" }), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, h("ch-image", { src: obj.typeIcon, class: "icon-md" })), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, this.renderIconState(obj.state)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.name), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.type), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.description), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, `${formatDate(obj.modifiedOn)}`), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.status), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.action))))));
-        };
-        this.renderIgnoredObjects = () => {
-            return (h("ch-tabular-grid", { class: "tabular-grid", "row-selection-mode": "multiple", ref: (el) => (this.chGridIgnoredObjectsEl = el), part: "ch-grid-ignored-objects", onRowContextMenu: this.onRowContextMenuHandler("ignored"), onSelectionChanged: this.gridOnSelectionChangedCallbackHandler("ignored") }, h("ch-tabular-grid-columnset", { class: "tabular-grid-column-set" }, h("ch-tabular-grid-column", { settingable: false, sortable: false, size: "min-content", class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.name, settingable: false, size: "1fr", class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.type, settingable: false, size: "1fr", class: "tabular-grid-column" })), this.updateData.ignoredObjects.map((obj) => (h("ch-tabular-grid-row", { rowid: obj.id, class: "tabular-grid-row" }, h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, h("ch-image", { src: obj.typeIcon, class: "icon-md" })), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.name), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.type))))));
-        };
-        this.renderResults = () => {
-            return (h("ch-tabular-grid", { class: "tabular-grid tabular-grid-results", "row-selection-mode": "multiple", ref: (el) => (this.chGridResultsEl = el), part: "ch-tabular-grid-results", onRowContextMenu: this.onRowContextMenuHandler("results"), onSelectionChanged: this.gridOnSelectionChangedCallbackHandler("results") }, h("ch-tabular-grid-columnset", { class: "tabular-grid-column-set" }, h("ch-tabular-grid-column", { settingable: false, sortable: false, "column-type": "tree", class: "tabular-grid-column" }), h("ch-tabular-grid-column", { settingable: false, sortable: false, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { settingable: false, sortable: false, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.name, settingable: false, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.type, settingable: false, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.description, settingable: false, class: "tabular-grid-column" }), h("ch-tabular-grid-column", { columnName: this._componentLocale.tableHead.notes, settingable: false, class: "tabular-grid-column" })), this.updateResultData.map((obj) => (h("ch-tabular-grid-row", { rowid: obj.id, class: "tabular-grid-row" }, h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, this.renderIconResult(obj.result)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, h("ch-image", { src: obj.typeIcon, class: "icon-md" })), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, this.renderIconState(obj.state)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.name), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.type), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.description), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, obj.notes), h("ch-tabular-grid-rowset", null, obj.messages.map(msg => {
-                let msgType;
-                switch (msg.type) {
-                    case "info":
-                        msgType = "text-alert-info";
-                        break;
-                    case "success":
-                        msgType = "text-alert-success";
-                        break;
-                    case "warning":
-                        msgType = "text-alert-warning";
-                        break;
-                    case "error":
-                        msgType = "text-alert-error";
-                        break;
-                }
-                return (h("ch-tabular-grid-rowset-empty", null, h("gxg-text", { type: msgType }, msg.text)));
-            })))))));
-        };
-        this.renderIconState = (state) => {
-            let type;
-            switch (state) {
-                case "Modified":
-                    type = "gx-server/changes-commit-pending";
-                    break;
-                case "Inserted":
-                    type = "gx-server/new";
-                    break;
-                case "Deleted":
-                    type = "gx-server/delete";
-                    break;
-                case "Conflicted":
-                    type = "gx-server/conflict";
-                    break;
+            else if (action === "modified-with-conflicts") {
+                icon = WARNING_ICON;
+                caption = __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.modifyWithConflicts;
+                iconColor = "--mer-icon__warning";
             }
-            return h("ch-image", { class: "icon-md", src: type });
-        };
-        this.renderIconResult = (result) => {
-            let type;
-            let color;
-            switch (result) {
-                case "info":
-                    type = "gemini-tools/notice";
-                    color = "primary-active";
-                    break;
-                case "success":
-                    type = "gemini-tools/success";
-                    color = "success";
-                    break;
-                case "warning":
-                    type = "gemini-tools/warning";
-                    color = "warning";
-                    break;
-                case "error":
-                    type = "gemini-tools/error";
-                    color = "error";
-                    break;
+            else if (!action) {
+                // proably is "ignored"
+                return null;
             }
-            return h("gxg-icon", { type: type, color: color });
-        };
-        this.loadData = async () => {
+            return (h("span", { class: "custom-icon-text-wrapper" }, h("ch-image", { type: "mask", class: "icon-md", src: icon, style: { backgroundColor: `var(${iconColor})` } }), `${caption}`));
+        });
+        _GxIdeTeamDevUpdate_updateSingleObject.set(this, objectId => async () => {
+            const newobjectsStatusMap = new Map(this.objectsStatusMap);
+            newobjectsStatusMap.set(objectId, "updating");
+            this.objectsStatusMap = newobjectsStatusMap;
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_updateObjectsHandler, "f").call(this, [objectId]);
+        });
+        _GxIdeTeamDevUpdate_renderObjectStatus.set(this, (objectId) => {
+            const status = this.objectsStatusMap.get(objectId);
+            const caption = status === "pending" && this.updatePillAsButton
+                ? __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").status.update
+                : __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").status[status];
+            if (status === "updating") {
+                return h("span", { class: "updating-spinner-caption" }, caption);
+            }
+            const classes = `pill pill--${status}`;
+            if (this.updatePillAsButton && status === "pending") {
+                return (h("button", { class: "button-secondary pill pill--update", onClick: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_updateSingleObject, "f").call(this, objectId) }, caption));
+            }
+            else {
+                return h("span", { class: classes }, caption);
+            }
+        });
+        _GxIdeTeamDevUpdate_renderRows.set(this, (type) => {
+            let objects;
+            if (type === "pending") {
+                objects = this.pendingObjectsAfterActionFilter;
+            }
+            else if (type === "ignored") {
+                objects = this.ignoredObjectsAfterActionFilter;
+            }
+            return objects.map(object => {
+                const objectType = {
+                    id: object.id,
+                    icon: object.typeIcon,
+                    name: object.name
+                };
+                const alreadyUpdated = this.alreadyUpdatedObjectsIdsSet.has(object.id);
+                const hideCheckbox = alreadyUpdated || type === "ignored";
+                const marked = this.markedObjectsSet.has(object.id);
+                const messages = this.objectsMessagesDataMap.get(object.id);
+                return (h("ch-tabular-grid-row", { class: "tabular-grid-row", key: object.id, rowid: object.id, ref: (el) => marked && (el === null || el === void 0 ? void 0 : el.setAttribute("marked", "true")) }, h("ch-tabular-grid-cell", { "cell-type": "rich", "row-selector": "true", class: {
+                        "tabular-grid-cell": true,
+                        "no-checkbox-custom-selector": hideCheckbox
+                    }, size: "max-content" }, object.name), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, renderObjectTypeWithIcon(objectType)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, object.description), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, formatDate(object.modifiedOn)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell" }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_renderActionCellContent, "f").call(this, object.action)), h("ch-tabular-grid-cell", { class: "tabular-grid-cell tabular-grid-cell--for-pill" }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_renderObjectStatus, "f").call(this, object.id)), (messages === null || messages === void 0 ? void 0 : messages.length) && (h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, h("ch-tabular-grid-rowset-empty", { class: {
+                        "tabular-grid-rowset-empty": true
+                    } }, h("ul", { class: "messages-list" }, messages.map(message => {
+                    let MESSAGE_ICON;
+                    if (message.type === "error") {
+                        MESSAGE_ICON = ERROR_ICON;
+                    }
+                    else if (message.type === "warning") {
+                        MESSAGE_ICON = WARNING_ICON;
+                    }
+                    else if (message.type === "success") {
+                        MESSAGE_ICON = SUCCESS_ICON;
+                    }
+                    else {
+                        // info
+                        MESSAGE_ICON = INFO_ICON;
+                    }
+                    return (h("li", { class: "message-description" }, h("ch-image", { class: "icon-md message-icon", src: MESSAGE_ICON }), message.text));
+                })))))));
+            });
+        });
+        _GxIdeTeamDevUpdate_rowMarkingChangedHandler.set(this, async (event) => {
+            const markedRowsIds = event.detail.rowsId;
+            this.markedObjectsSet = new Set(markedRowsIds.filter(markedObjectId => !this.alreadyUpdatedObjectsIdsSet.has(markedObjectId)));
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevUpdate_rowCheckedChangedByTheUser, "f")) {
+                __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_updatePendingCheckedItems, "f").call(this, event);
+            }
+        });
+        _GxIdeTeamDevUpdate_updatePendingCheckedItems.set(this, async (event) => {
+            const addedRowsIds = event.detail.addedRowsId;
+            const removedRowsId = event.detail.removedRowsId;
+            const pendingItemCheckedResult = await this.pendingItemsCheckedCallback({
+                itemsChecked: addedRowsIds,
+                itemsUnchecked: removedRowsId
+            });
+            if (pendingItemCheckedResult === undefined) {
+                // undo check/uncheck
+                await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_revertPendingCommitsCheckboxes, "f").call(this, addedRowsIds, removedRowsId);
+            }
+            else {
+                await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_togglePendingCommitsCheckboxes, "f").call(this, pendingItemCheckedResult);
+            }
+        });
+        _GxIdeTeamDevUpdate_searchInputHandler.set(this, (event) => {
+            this.searchValue = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this);
+        });
+        // Local Methods Update
+        _GxIdeTeamDevUpdate_actionChangedHandler.set(this, (event) => {
+            this.selectedAction = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this);
+        });
+        _GxIdeTeamDevUpdate_typeChangedHandler.set(this, async (event) => {
+            this.selectedType = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this);
+        });
+        _GxIdeTeamDevUpdate_setInitialObjectsStatus.set(this, () => {
+            this.pendingAndIgnored.pendingForUpdate.forEach(pendingObject => {
+                var _a;
+                const status = (_a = pendingObject.status) !== null && _a !== void 0 ? _a : "pending";
+                this.objectsStatusMap.set(pendingObject.id, status);
+                if (status === "updated") {
+                    this.alreadyUpdatedObjectsIdsSet.add(pendingObject.id);
+                }
+            });
+            this.pendingAndIgnored.ignoredObjects.forEach(ignoredObject => {
+                var _a;
+                const status = (_a = ignoredObject.status) !== null && _a !== void 0 ? _a : "ignored";
+                this.objectsStatusMap.set(ignoredObject.id, status);
+            });
+        });
+        _GxIdeTeamDevUpdate_loadData.set(this, async (forceLoad = false) => {
             const filters = {
-                pattern: this.showFilter ? this.filterPatternEl.value : null,
-                type: this.showFilter ? this.filterTypeEl.value : null
+                search: this.searchValue,
+                type: this.selectedType,
+                kbProperties: this.kbPropertiesChecked,
+                action: this.selectedAction
             };
-            // this.updateData = null;
-            this.isLoading = true;
-            this.updateData = await this.loadCallback(filters);
-            this.isLoading = false;
-            if (!this.loadDataCalledFirstTime) {
-                /* this allows checking the pending commits checkboxes on first load*/
-                this.loadDataCalledFirstTime = true;
+            this.loading = true;
+            this.objectsMessagesDataMap.clear();
+            this.pendingAndIgnored = await this.loadCallback(filters, forceLoad);
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_setInitialObjectsStatus, "f").call(this);
+            this.loading = false;
+            // Is is required to mark/check all objects after loadCallback.
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_markPendingObjects, "f").call(this);
+        });
+        /**
+         * Marks all pending objects that have not been committed yet.
+         *
+         * Iterates through all pending object IDs and adds them to the marked objects set
+         * if they are not already in the committed objects set. This effectively identifies
+         * and marks all the pending objects that still need to be processed.
+         **/
+        _GxIdeTeamDevUpdate_markPendingObjects.set(this, () => {
+            for (const pendingId of this.pendingIdsSet) {
+                if (!this.alreadyUpdatedObjectsIdsSet.has(pendingId)) {
+                    this.markedObjectsSet = new Set([...this.markedObjectsSet, pendingId]);
+                }
             }
-        };
-        this.update = async () => {
-            if (this.updateCallback) {
-                const pendingForUpdateMarked = await this.chGridPendingForUpdateEl.getMarkedRows();
-                this.updateCallback(pendingForUpdateMarked).then((updateResultData) => {
-                    this.updateResultData = updateResultData;
-                    this.gxgTabButtonResultsEl.tabButtonClick();
+        });
+        _GxIdeTeamDevUpdate_applyClientFilter.set(this, () => {
+            // this.pendingObjectsAfterActionFilter = this.#filteredObjects(
+            //   this.pendingAndIgnored.pendingForUpdate
+            // );
+            this.pendingObjectsAfterActionFilter =
+                this.pendingAndIgnored.pendingForUpdate;
+            // this.ignoredObjectsAfterActionFilter = this.#filteredObjects(
+            //   this.pendingAndIgnored.ignoredObjects
+            // );
+            this.ignoredObjectsAfterActionFilter =
+                this.pendingAndIgnored.ignoredObjects;
+        });
+        // #filteredObjects = (objects: ModifiedObject[]): ModifiedObject[] => {
+        //   let filtered = objects;
+        //   // name or description
+        //   if (this.searchValue.length) {
+        //     filtered = filtered.filter(object => {
+        //       const nameFiltered = object.name
+        //         .toLowerCase()
+        //         .includes(this.searchValue.toLowerCase());
+        //       const descriptionFiltered = object.description
+        //         .toLowerCase()
+        //         .includes(this.searchValue.toLowerCase());
+        //       return nameFiltered || descriptionFiltered;
+        //     });
+        //   }
+        //   return filtered;
+        // };
+        _GxIdeTeamDevUpdate_onRowContextMenuHandler.set(this, () => async (ev) => {
+            ev.preventDefault();
+            ev.stopPropagation();
+            const selection = await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").getSelectedRows();
+            const selectedRowId = (await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").getSelectedCell()).rowId;
+            const source = this.pendingIdsSet.has(selectedRowId)
+                ? "pending"
+                : "ignored";
+            let filteredSelection = [];
+            // remove selected rows from the other source, if any.
+            if (selection.length > 1 && source === "pending") {
+                selection.forEach(async (selectedRowId) => {
+                    if (this.ignoredIdsSet.has(selectedRowId)) {
+                        await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").selectRow(selectedRowId, false);
+                    }
+                    else {
+                        filteredSelection.push(selectedRowId);
+                    }
                 });
             }
-        };
-        this.objectsScope = () => {
-            if (this.objectsScopeCallback) {
-                this.objectsScopeCallback().then(objectData => {
-                    if (objectData) {
-                        this.objectScopeText = objectData;
+            else if (selection.length > 1 && source === "ignored") {
+                selection.forEach(async (selectedRowId) => {
+                    if (this.pendingIdsSet.has(selectedRowId)) {
+                        await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").selectRow(selectedRowId, false);
+                    }
+                    else {
+                        filteredSelection.push(selectedRowId);
                     }
                 });
             }
-        };
-        this.revisionScope = () => {
-            if (this.revisionScopeCallback) {
-                this.revisionScopeCallback().then(revisionData => {
-                    this.revisionScopeText = revisionData;
-                });
+            else {
+                filteredSelection = selection;
             }
-        };
-        this.pendingForUpdatesRowMarkingChangedHandler = async (e) => {
-            // remove "rowMarkingChanged" until checkboxes have been added/removed on togglePendingCommitsCheckboxes, to prevent loops.
-            this.chGridPendingForUpdateEl.removeEventListener("rowMarkingChanged", this.pendingForUpdatesRowMarkingChangedHandler);
-            if (this.chGridPendingForUpdateEl) {
-                const addedRowsIds = e.detail.addedRowsId;
-                const removedRowsId = e.detail.removedRowsId;
-                const pendingItemCheckedResult = await this.pendingItemsCheckedCallback({
-                    itemsChecked: addedRowsIds,
-                    itemsUnchecked: removedRowsId
-                });
-                if (pendingItemCheckedResult === undefined) {
-                    // undo check/uncheck
-                    await this.revertPendingCommitsCheckboxes(addedRowsIds, removedRowsId);
+            await this.contextMenuCallback(source, {
+                selection: filteredSelection,
+                clientX: ev.detail.clientX,
+                clientY: ev.detail.clientY
+            });
+        });
+        _GxIdeTeamDevUpdate_revertPendingCommitsCheckboxes.set(this, async (addedRowsIds, removedRowsId) => {
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f")) {
+                for (const rowId of addedRowsIds) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").markRow(rowId, false);
                 }
-                else {
-                    await this.togglePendingCommitsCheckboxes(pendingItemCheckedResult);
+                for (const rowId of removedRowsId) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").markRow(rowId, true);
                 }
-                this.chGridPendingForUpdateEl.addEventListener("rowMarkingChanged", this.pendingForUpdatesRowMarkingChangedHandler);
             }
-            this.chGridPendingForUpdateEl.addEventListener("rowMarkingChanged", this.pendingForUpdatesRowMarkingChangedHandler);
-        };
-        this.togglePendingCommitsCheckboxes = async (itemsToToggle) => {
-            if (this.chGridPendingForUpdateEl) {
+        });
+        _GxIdeTeamDevUpdate_togglePendingCommitsCheckboxes.set(this, async (itemsToToggle) => {
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f")) {
                 const itemsToCheck = itemsToToggle.itemsToCheck;
                 const itemsToUncheck = itemsToToggle.itemsToUncheck;
                 // check
                 for (const rowId of itemsToCheck) {
-                    await this.chGridPendingForUpdateEl.markRow(rowId, true);
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").markRow(rowId, true);
                 }
                 // uncheck
                 for (const rowId of itemsToUncheck) {
-                    await this.chGridPendingForUpdateEl.markRow(rowId, false);
-                }
-            }
-        };
-        this.revertPendingCommitsCheckboxes = async (addedRowsIds, removedRowsId) => {
-            if (this.chGridPendingForUpdateEl) {
-                for (const rowId of addedRowsIds) {
-                    await this.chGridPendingForUpdateEl.markRow(rowId, false);
-                }
-                for (const rowId of removedRowsId) {
-                    await this.chGridPendingForUpdateEl.markRow(rowId, true);
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, "f").markRow(rowId, false);
                 }
             }
-        };
-        this.isLoading = false;
-        this.objectScopeText = "all";
-        this.openTab = "pending";
-        this.revisionScopeText = undefined;
-        this.showFilter = false;
-        this.updateData = {
+        });
+        _GxIdeTeamDevUpdate_kbPropertiesChangedHandler.set(this, (event) => {
+            this.kbPropertiesChecked = event.detail === CHECKBOX_CHECKED_VALUE;
+            __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this, true);
+        });
+        this.atLeastOneObjectIsChecked = false;
+        this.loading = true;
+        this.menuContextAction = undefined;
+        this.searchValue = "";
+        this.selectedAction = "all-actions";
+        this.markedObjectsSet = new Set([]);
+        this.alreadyUpdatedObjectsIdsSet = new Set([]);
+        this.pendingIdsSet = new Set([]);
+        this.ignoredIdsSet = new Set([]);
+        this.objectsMessagesDataMap = new Map();
+        this.updating = false;
+        this.kbPropertiesChecked = false;
+        this.typesComboBoxModel = undefined;
+        this.selectedType = undefined;
+        this.objectsStatusMap = new Map();
+        this.contextMenuCallback = undefined;
+        this.pendingAndIgnored = {
             pendingForUpdate: [],
             ignoredObjects: []
         };
-        this.updateResultData = [];
-        this.displayTitle = false;
-        this.confirmCallback = undefined;
-        this.gridContextMenuCallback = undefined;
+        this.pendingObjectsAfterActionFilter = [];
+        this.ignoredObjectsAfterActionFilter = [];
         this.loadCallback = undefined;
-        this.objectsScopeCallback = undefined;
-        this.openServerCallback = undefined;
         this.pendingItemsCheckedCallback = undefined;
-        this.revisionScopeCallback = undefined;
-        this.objectsContextMenuCallback = undefined;
-        this.selectCallback = undefined;
         this.types = undefined;
+        this.updatePillAsButton = false;
         this.updateCallback = undefined;
+        this.openServerCallback = undefined;
         this.updateFrom = undefined;
     }
-    // 6.COMPONENT LIFECYCLE EVENTS //
+    markedObjectsSetChanged(newMarkedObjectsSet) {
+        this.atLeastOneObjectIsChecked = newMarkedObjectsSet.size > 0;
+    }
+    objectsStatusMapChanged(newObjectsStatusMap) {
+        const someObjectIsUpdating = [...newObjectsStatusMap.entries()].find(([, state]) => state === "updating");
+        if (!someObjectIsUpdating) {
+            this.updating = false;
+        }
+    }
+    pendingAndIgnoredChanged() {
+        __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_applyClientFilter, "f").call(this);
+        this.pendingIdsSet.clear();
+        this.pendingAndIgnored.pendingForUpdate.forEach(pending => {
+            this.pendingIdsSet.add(pending.id);
+        });
+        this.ignoredIdsSet.clear();
+        this.pendingAndIgnored.ignoredObjects.forEach(ignored => {
+            this.ignoredIdsSet.add(ignored.id);
+        });
+    }
     async componentWillLoad() {
-        this._componentLocale = await Locale.getComponentStrings(this.el);
-        this.componentDidLoadEvent.emit(true);
+        var _a;
+        __classPrivateFieldSet(this, _GxIdeTeamDevUpdate_componentLocale, await Locale.getComponentStrings(this.el), "f");
+        // Initiate "actions" combo box filter
+        __classPrivateFieldSet(this, _GxIdeTeamDevUpdate_actionsComboBoxModel, [
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.allActions,
+                value: "all-actions"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.insert,
+                value: "inserted"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.modify,
+                value: "modified"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.modifyWithConflicts,
+                value: "modified-with-conflicts"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").actions.delete,
+                value: "deleted"
+            }
+        ], "f");
+        // Set type initial value
+        this.selectedType = (_a = this.types[0]) === null || _a === void 0 ? void 0 : _a.id;
+        this.typesComboBoxModel = mapObjectTypeToComboBoxItemModel(this.types);
     }
     async componentDidLoad() {
-        await this.loadData();
-        this.filterPatternEl.focus();
+        await __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this, true);
     }
-    async componentDidRender() {
-        if (!this.renderedFirstTime) {
-            this.componentDidRenderFirstTime.emit(this._componentLocale.componentName);
-            this.renderedFirstTime = true;
-        }
-        if (this.loadDataCalledFirstTime) {
-            // call this method only once
-            await this.markAllPendingToUpdateRows();
-            // attach "rowMarkingChanged" after rows have been checked for the first time.
-            this.chGridPendingForUpdateEl.addEventListener("rowMarkingChanged", this.pendingForUpdatesRowMarkingChangedHandler);
-            this.loadDataCalledFirstTime = false;
-        }
-    }
-    // 7.LISTENERS //
-    // 8.PUBLIC METHODS API //
     /**
-     * The method used by the host to instruct the component to force a data reload in the grids.
+     * Used by the host to instruct the component to force a data reload in the grids.
      */
     async reload() {
-        this.loadData();
+        __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_loadData, "f").call(this, true);
     }
-    // 10.RENDER() FUNCTION //
     render() {
-        return (h(Host, { class: "gx-ide-component" }, h("ch-theme", { model: CSS_BUNDLES }), h("div", { class: "gx-ide-main-wrapper" }, h("gx-ide-container", { displayBorderTop: true, noContentPadding: true, slimmerFooter: config.gxIdeContainer.slimmerFooter, containerTitle: this.displayTitle ? this._componentLocale.componentName : null }, this.renderOptions(), this.renderFilter(), this.renderData(), h("gxg-button", { id: "button-update", type: "primary-text-only", onClick: this.update, part: "gxg-button gxg-button--update", disabled: this.isLoading, slot: "footer-end" }, this._componentLocale.footer.btnUpdate)))));
+        const enableRichRowSelector = true;
+        const disableControls = this.updating || this.loading;
+        const gridIsEmpty = this.pendingObjectsAfterActionFilter.length === 0 &&
+            this.ignoredObjectsAfterActionFilter.length === 0;
+        return (h(Host, { class: "widget" }, h("ch-theme", { model: CSS_BUNDLES }), h("section", { class: "section" }, h("header", { class: "header spacing-body-inline spacing-body-block-start" }, h("div", {
+            // header details
+            class: "header__detail header__detail-1"
+        }, h("p", { class: "detail__heading-genexus-server subtitle-semi-bold-s" }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").commitDetail.title), h("div", {
+            // genexus server
+            class: "detail__genexus-server field field-block"
+        }, h("span", { class: DETAIL_LABEL_CLASSES }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").commitDetail.genexusServer), h("button", { class: "detail__link body-regular-s", onClick: this.openServerCallback }, this.updateFrom ? this.updateFrom.serverUrl : "")), h("div", {
+            // knowledge base
+            class: "detail__knowledge-base field field-block"
+        }, h("span", { class: DETAIL_LABEL_CLASSES }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").commitDetail.knowledgeBase), h("p", { class: "body-regular-s" }, this.updateFrom ? this.updateFrom.kbName : "")), h("div", {
+            // version
+            class: "detail__version field field-block"
+        }, h("span", { class: DETAIL_LABEL_CLASSES }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").commitDetail.version), h("p", { class: "body-regular-s" }, this.updateFrom ? this.updateFrom.versionName : "")), h("div", {
+            // last full update
+            class: "detail__last-full-update field field-block"
+        }, h("span", { class: DETAIL_LABEL_CLASSES }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").commitDetail.lastFullUpdate), h("p", { class: "body-regular-s" }, formatDate(this.updateFrom.lastFullUpdate))))), h("div", { class: "filter-container spacing-body-inline" }, h("div", { class: "filter" }, h("ch-edit", {
+            // search
+            class: "input filter__search", disabled: disableControls, startImgSrc: SEARCH_ICON, accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.searchAccessibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.searchPlaceholder, type: "search", onInput: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_searchInputHandler, "f"), debounce: config.inputDebounce
+        }), h("ch-combo-box-render", {
+            // types
+            class: "combo-box filter__types", disabled: disableControls, model: this.typesComboBoxModel, value: this.selectedType, accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.typeAccesibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.typePlaceholder, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_typeChangedHandler, "f")
+        }), h("ch-combo-box-render", {
+            // actions
+            class: "combo-box filter__actions", disabled: disableControls, model: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_actionsComboBoxModel, "f"), value: this.selectedAction, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_actionChangedHandler, "f"), accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.actionAccesibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.actionPlaceholder
+        }), h("ch-checkbox", {
+            // kb properties
+            class: "checkbox filter__kb-properties", caption: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.kbProperties, checkedValue: CHECKBOX_CHECKED_VALUE, value: CHECKBOX_UNCHECKED_VALUE, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_kbPropertiesChangedHandler, "f"), disabled: disableControls
+        }), h("div", { class: "buttons-spacer filter__buttons" }, h("button", {
+            // reload button
+            class: "button-secondary button-icon-and-text", disabled: disableControls, onClick: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_reloadClickedHandler, "f")
+        }, h("ch-image", { class: "icon-md", src: REFRESH_ICON }), __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.reload), h("button", {
+            // update button
+            class: "button-primary button-update", disabled: !this.atLeastOneObjectIsChecked || disableControls, onClick: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_updateCheckedClickedHandler, "f")
+        }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").filter.update)))), h("div", { class: "main spacing-body" }, !this.loading ? (h("ch-tabular-grid", { class: {
+                "tabular-grid": true,
+                "objects-tabular-grid": true,
+                "disabled-custom-selector": this.updating,
+                "empty-result": gridIsEmpty
+            }, keyboardNavigationMode: "focus", rowSelectionMode: "multiple", onRowMarkingChanged: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_rowMarkingChangedHandler, "f"), onRowContextMenu: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_onRowContextMenuHandler, "f").call(this), ref: (el) => (__classPrivateFieldSet(this, _GxIdeTeamDevUpdate_chGridPendingForUpdateEl, el, "f")) }, h("ch-tabular-grid-columnset", { class: "tabular-grid-column-set" }, h("ch-tabular-grid-column", { class: "tabular-grid-column", columnId: "name", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.name, columnType: "rich", richRowSelector: enableRichRowSelector, richRowSelectorMode: "mark", settingable: false, size: "max-content" }), h("ch-tabular-grid-column", { class: "tabular-grid-column", columnId: "type", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.type, settingable: false, size: "max-content" }), h("ch-tabular-grid-column", { class: "tabular-grid-column", columnId: "description", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.description, settingable: false, size: config.tabularGrid.colSize.description }), h("ch-tabular-grid-column", { class: "tabular-grid-column", columnId: "modified-on", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.modifiedOn, settingable: false, size: "max-content" }), h("ch-tabular-grid-column", { class: "tabular-grid-column", columnId: "action", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.action, settingable: false, size: "max-content" }), h("ch-tabular-grid-column", {
+            // size of this column should the enough for the largest pill, and no more.
+            // this prevents layout shifts when pills state changes.
+            class: "tabular-grid-column", columnId: "status", columnName: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.status, settingable: false, size: "100px"
+        })), !gridIsEmpty
+            ? [
+                h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, h("ch-tabular-grid-rowset-legend", { class: "tabular-grid-rowset-legend" }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.pending), __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_renderRows, "f").call(this, "pending")),
+                h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, h("ch-tabular-grid-rowset-legend", { class: "tabular-grid-rowset-legend" }, __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").objects.ignored), __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_renderRows, "f").call(this, "ignored"))
+            ]
+            : null, h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, gridIsEmpty && (h("ch-tabular-grid-rowset-empty", null, h("gx-ide-empty-state", { class: "empty-state", isAnimated: true, stateIconSrc: FILTER_ICON, stateTitle: "No object matched your filter" })))))) : (h("gx-ide-loader", { cancelLabel: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").loader.cancelLabel, loaderTitle: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").loader.title, description: __classPrivateFieldGet(this, _GxIdeTeamDevUpdate_componentLocale, "f").loader.description, show: true, class: "loader" }))))));
     }
     static get is() { return "gx-ide-team-dev-update"; }
     static get encapsulation() { return "shadow"; }
@@ -292,56 +559,17 @@ export class GxIdeTeamDevUpdate {
     static get assetsDirs() { return ["gx-ide-assets/team-dev-update"]; }
     static get properties() {
         return {
-            "displayTitle": {
-                "type": "boolean",
-                "mutable": false,
-                "complexType": {
-                    "original": "false",
-                    "resolved": "boolean",
-                    "references": {}
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "If true it displays the component title on the header"
-                },
-                "attribute": "display-title",
-                "reflect": false,
-                "defaultValue": "false"
-            },
-            "confirmCallback": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "ConfirmCallback",
-                    "resolved": "(data: any) => Promise<boolean>",
-                    "references": {
-                        "ConfirmCallback": {
-                            "location": "local",
-                            "path": "/home/runner/work/genexus-ide-ui/genexus-ide-ui/src/components/team-dev/update/update.tsx",
-                            "id": "src/components/team-dev/update/update.tsx::ConfirmCallback"
-                        }
-                    }
-                },
-                "required": true,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "This is a function provided by the developer that init the process of import a design."
-                }
-            },
-            "gridContextMenuCallback": {
+            "contextMenuCallback": {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "GridContextMenuCallback",
-                    "resolved": "(selection: string[], grid: \"update\" | \"ignored\" | \"results\") => Promise<void>",
+                    "original": "ContextMenuCallback",
+                    "resolved": "(source: UpdateSourceType, contextMenuInfo: ContextMenuInfo) => Promise<void>",
                     "references": {
-                        "GridContextMenuCallback": {
+                        "ContextMenuCallback": {
                             "location": "local",
                             "path": "/home/runner/work/genexus-ide-ui/genexus-ide-ui/src/components/team-dev/update/update.tsx",
-                            "id": "src/components/team-dev/update/update.tsx::GridContextMenuCallback"
+                            "id": "src/components/team-dev/update/update.tsx::ContextMenuCallback"
                         }
                     }
                 },
@@ -349,7 +577,7 @@ export class GxIdeTeamDevUpdate {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "This is a function provided by the developer that return the information of an Image System type of data."
+                    "text": "Callback invoked when user activates the context menu on any of the grids."
                 }
             },
             "loadCallback": {
@@ -357,7 +585,7 @@ export class GxIdeTeamDevUpdate {
                 "mutable": false,
                 "complexType": {
                     "original": "LoadCallback",
-                    "resolved": "(filters: FiltersData) => Promise<UpdateData>",
+                    "resolved": "(filters: FiltersData, forceLoad: boolean) => Promise<UpdateData>",
                     "references": {
                         "LoadCallback": {
                             "location": "local",
@@ -370,47 +598,7 @@ export class GxIdeTeamDevUpdate {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "This is a function provided by the developer that return the list of types of data loaded from file or url."
-                }
-            },
-            "objectsScopeCallback": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "() => Promise<\"all\" | \"partial\">",
-                    "resolved": "() => Promise<\"all\" | \"partial\">",
-                    "references": {
-                        "Promise": {
-                            "location": "global",
-                            "id": "global::Promise"
-                        }
-                    }
-                },
-                "required": true,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "This is a function provided by the developer to call when the user makes a partial selection from button Change of Scope group."
-                }
-            },
-            "openServerCallback": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "() => Promise<void>",
-                    "resolved": "() => Promise<void>",
-                    "references": {
-                        "Promise": {
-                            "location": "global",
-                            "id": "global::Promise"
-                        }
-                    }
-                },
-                "required": true,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "This is a function provided by the developer to call when the user clicked in server url of Update From group."
+                    "text": "Callback invoked to return the list of data types loaded from file or url."
                 }
             },
             "pendingItemsCheckedCallback": {
@@ -431,103 +619,79 @@ export class GxIdeTeamDevUpdate {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "This is a function provided by the developer that return the information of a Font type of data."
+                    "text": "Callback invoked to return information of a Font type of data."
                 }
             },
-            "revisionScopeCallback": {
+            "types": {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "() => Promise<string | undefined>",
-                    "resolved": "() => Promise<string>",
+                    "original": "ObjectType[]",
+                    "resolved": "ObjectType[]",
                     "references": {
-                        "Promise": {
-                            "location": "global",
-                            "id": "global::Promise"
+                        "ObjectType": {
+                            "location": "import",
+                            "path": "../../../common/types",
+                            "id": "src/common/types.ts::ObjectType"
                         }
                     }
                 },
-                "required": true,
+                "required": false,
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "This is a function provided by the developer to call when the user wants to select the revision to work on."
+                    "text": "Possible values for type filter"
                 }
             },
-            "objectsContextMenuCallback": {
-                "type": "unknown",
+            "updatePillAsButton": {
+                "type": "boolean",
                 "mutable": false,
                 "complexType": {
-                    "original": "ObjectsContextMenuCallback",
-                    "resolved": "(source: UpdateSourceType, contextMenuInfo: ContextMenuInfo) => Promise<void>",
-                    "references": {
-                        "ObjectsContextMenuCallback": {
-                            "location": "local",
-                            "path": "/home/runner/work/genexus-ide-ui/genexus-ide-ui/src/components/team-dev/update/update.tsx",
-                            "id": "src/components/team-dev/update/update.tsx::ObjectsContextMenuCallback"
-                        }
-                    }
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
                 },
-                "required": true,
+                "required": false,
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Callback that should be invoked when the user activates the context menu on any of the grids. It receives the internal IDs of the selected elements and in which grid the event occurred. It should prevent the default browser context menu from appearing"
-                }
+                    "text": "If true, the \"Action\" column will display a button instead of a pill, only when the action is"
+                },
+                "attribute": "update-pill-as-button",
+                "reflect": false,
+                "defaultValue": "false"
             },
-            "selectCallback": {
+            "updateCallback": {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "UpdateSelectCallback",
-                    "resolved": "(grid: UpdateSourceType, selectionIds: string[]) => Promise<void>",
+                    "original": "UpdateCallback",
+                    "resolved": "(selection: string[]) => Promise<UpdateResultData[]>",
                     "references": {
-                        "UpdateSelectCallback": {
+                        "UpdateCallback": {
                             "location": "local",
                             "path": "/home/runner/work/genexus-ide-ui/genexus-ide-ui/src/components/team-dev/update/update.tsx",
-                            "id": "src/components/team-dev/update/update.tsx::UpdateSelectCallback"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "Callback that should be invoked when the user selects rows from the grids"
-                }
-            },
-            "types": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "ObjectType[]",
-                    "resolved": "ObjectType[]",
-                    "references": {
-                        "ObjectType": {
-                            "location": "import",
-                            "path": "../../../common/types",
-                            "id": "src/common/types.ts::ObjectType"
+                            "id": "src/components/team-dev/update/update.tsx::UpdateCallback"
                         }
                     }
                 },
-                "required": false,
+                "required": true,
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Possibly values for the filter type"
+                    "text": "Callback invoked when the update process is to be started (\u2019Update\u2019 button)."
                 }
             },
-            "updateCallback": {
+            "openServerCallback": {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "UpdateCallback",
-                    "resolved": "(selection: string[]) => Promise<UpdateResultData[]>",
+                    "original": "() => Promise<void>",
+                    "resolved": "() => Promise<void>",
                     "references": {
-                        "UpdateCallback": {
-                            "location": "local",
-                            "path": "/home/runner/work/genexus-ide-ui/genexus-ide-ui/src/components/team-dev/update/update.tsx",
-                            "id": "src/components/team-dev/update/update.tsx::UpdateCallback"
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
                         }
                     }
                 },
@@ -535,7 +699,7 @@ export class GxIdeTeamDevUpdate {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "This is a function provided by the developer that return the information of a Design System type of data."
+                    "text": "Callback invoked when user clicks in server url of Update From group."
                 }
             },
             "updateFrom": {
@@ -556,55 +720,33 @@ export class GxIdeTeamDevUpdate {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Information to show in the container of group 'Update From'"
+                    "text": "Information to show in Update From group."
                 }
             }
         };
     }
     static get states() {
         return {
-            "isLoading": {},
-            "objectScopeText": {},
-            "openTab": {},
-            "revisionScopeText": {},
-            "showFilter": {},
-            "updateData": {},
-            "updateResultData": {}
+            "atLeastOneObjectIsChecked": {},
+            "loading": {},
+            "menuContextAction": {},
+            "searchValue": {},
+            "selectedAction": {},
+            "markedObjectsSet": {},
+            "alreadyUpdatedObjectsIdsSet": {},
+            "pendingIdsSet": {},
+            "ignoredIdsSet": {},
+            "objectsMessagesDataMap": {},
+            "updating": {},
+            "kbPropertiesChecked": {},
+            "typesComboBoxModel": {},
+            "selectedType": {},
+            "objectsStatusMap": {},
+            "pendingAndIgnored": {},
+            "pendingObjectsAfterActionFilter": {},
+            "ignoredObjectsAfterActionFilter": {}
         };
     }
-    static get events() {
-        return [{
-                "method": "componentDidLoadEvent",
-                "name": "componentDidLoadEvent",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": "This event is emitted once just after the component is fully loaded and the first render() occurs."
-                },
-                "complexType": {
-                    "original": "boolean",
-                    "resolved": "boolean",
-                    "references": {}
-                }
-            }, {
-                "method": "componentDidRenderFirstTime",
-                "name": "componentDidRenderFirstTime",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": "This event is emitted once just after the component is fully loaded and the first render() occurs"
-                },
-                "complexType": {
-                    "original": "boolean",
-                    "resolved": "boolean",
-                    "references": {}
-                }
-            }];
-    }
     static get methods() {
         return {
             "reload": {
@@ -620,12 +762,25 @@ export class GxIdeTeamDevUpdate {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "The method used by the host to instruct the component to force a data reload in the grids.",
+                    "text": "Used by the host to instruct the component to force a data reload in the grids.",
                     "tags": []
                 }
             }
         };
     }
     static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "markedObjectsSet",
+                "methodName": "markedObjectsSetChanged"
+            }, {
+                "propName": "objectsStatusMap",
+                "methodName": "objectsStatusMapChanged"
+            }, {
+                "propName": "pendingAndIgnored",
+                "methodName": "pendingAndIgnoredChanged"
+            }];
+    }
 }
+_GxIdeTeamDevUpdate_componentLocale = new WeakMap(), _GxIdeTeamDevUpdate_actionsComboBoxModel = new WeakMap(), _GxIdeTeamDevUpdate_rowCheckedChangedByTheUser = new WeakMap(), _GxIdeTeamDevUpdate_chGridPendingForUpdateEl = new WeakMap(), _GxIdeTeamDevUpdate_updateCheckedClickedHandler = new WeakMap(), _GxIdeTeamDevUpdate_reloadClickedHandler = new WeakMap(), _GxIdeTeamDevUpdate_updateObjectsHandler = new WeakMap(), _GxIdeTeamDevUpdate_renderActionCellContent = new WeakMap(), _GxIdeTeamDevUpdate_updateSingleObject = new WeakMap(), _GxIdeTeamDevUpdate_renderObjectStatus = new WeakMap(), _GxIdeTeamDevUpdate_renderRows = new WeakMap(), _GxIdeTeamDevUpdate_rowMarkingChangedHandler = new WeakMap(), _GxIdeTeamDevUpdate_updatePendingCheckedItems = new WeakMap(), _GxIdeTeamDevUpdate_searchInputHandler = new WeakMap(), _GxIdeTeamDevUpdate_actionChangedHandler = new WeakMap(), _GxIdeTeamDevUpdate_typeChangedHandler = new WeakMap(), _GxIdeTeamDevUpdate_setInitialObjectsStatus = new WeakMap(), _GxIdeTeamDevUpdate_loadData = new WeakMap(), _GxIdeTeamDevUpdate_markPendingObjects = new WeakMap(), _GxIdeTeamDevUpdate_applyClientFilter = new WeakMap(), _GxIdeTeamDevUpdate_onRowContextMenuHandler = new WeakMap(), _GxIdeTeamDevUpdate_revertPendingCommitsCheckboxes = new WeakMap(), _GxIdeTeamDevUpdate_togglePendingCommitsCheckboxes = new WeakMap(), _GxIdeTeamDevUpdate_kbPropertiesChangedHandler = new WeakMap();
 //# sourceMappingURL=update.js.map