@genexus/genexus-ide-ui 1.1.35 → 1.1.37

package/dist/collection/components/team-dev/version-control/commit/commit.js

@@ -0,0 +1,801 @@
+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 _GxIdeTeamDevCommit_componentLocale, _GxIdeTeamDevCommit_localStatesComboBoxModel, _GxIdeTeamDevCommit_rowCheckedChangedByTheUser, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, _GxIdeTeamDevCommit_commitCheckedClickedHandler, _GxIdeTeamDevCommit_commitSingleObject, _GxIdeTeamDevCommit_commitObjectsHandler, _GxIdeTeamDevCommit_rowMarkingChangedHandler, _GxIdeTeamDevCommit_rowSelectionChangedHandler, _GxIdeTeamDevCommit_commentsInputHandler, _GxIdeTeamDevCommit_applyClientFilter, _GxIdeTeamDevCommit_filteredObjects, _GxIdeTeamDevCommit_evaluateSecondaryFilterHasConditions, _GxIdeTeamDevCommit_toggleFiltersHandler, _GxIdeTeamDevCommit_searchInputHandler, _GxIdeTeamDevCommit_typeChangedHandler, _GxIdeTeamDevCommit_stateChangedHandler, _GxIdeTeamDevCommit_folderChanged, _GxIdeTeamDevCommit_onRowContextMenuHandler, _GxIdeTeamDevCommit_updatePendingCheckedItems, _GxIdeTeamDevCommit_setInitialObjectsStatus, _GxIdeTeamDevCommit_loadData, _GxIdeTeamDevCommit_markPendingObjects, _GxIdeTeamDevCommit_revertPendingCommitsCheckboxes, _GxIdeTeamDevCommit_togglePendingCommitsCheckboxes;
+// stencil
+import { Host, h } from "@stencil/core";
+// local
+import { Locale } from "../../../../common/locale";
+import clearGridSelection from "../common/clear-grid-selection";
+import headerDetail, { headerTitle } from "../common/header-renders";
+import { changesetToComboBoxModel } from "./utilities/changeset-to-combo-box";
+import { foldersToComboBoxModel } from "./utilities/folders-to-combo-box";
+import { typesToComboBoxItemModel } from "./utilities/types-to-combo-box";
+import renderTabularGridRows, { renderTabularGridColumns } from "../common/tabular-grid-render";
+import { CSS_SELECTORS as CLASSES, ALL_VALUE } from "../common/constants";
+import ICONS from "../common/constants";
+const FILTER_SECONDARY_CONTAINER_ID = "filters-secondary-container";
+const FILTER_SECONDARY_BUTTON_ID = "filter-toggle-button";
+const CSS_BUNDLES = [
+    "resets/box-sizing",
+    "components/tabular-grid",
+    "utils/form--full",
+    "utils/layout",
+    "utils/typography",
+    "utils/spacing",
+    "chameleon/scrollbar"
+];
+export class GxIdeTeamDevCommit {
+    constructor() {
+        /**
+         * The component hard-coded strings translations.
+         */
+        // eslint-disable-next-line @stencil-community/own-props-must-be-private
+        _GxIdeTeamDevCommit_componentLocale.set(this, void 0);
+        /**
+         * The ComboBoxModel for "Local State" filter.
+         */
+        _GxIdeTeamDevCommit_localStatesComboBoxModel.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.
+         */
+        _GxIdeTeamDevCommit_rowCheckedChangedByTheUser.set(this, true);
+        /**
+         * A reference to the tablar grid. Used to call methods.
+         */
+        _GxIdeTeamDevCommit_chGridPendingForUpdateEl.set(this, void 0);
+        // commit related
+        _GxIdeTeamDevCommit_commitCheckedClickedHandler.set(this, () => {
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commitObjectsHandler, "f").call(this, [...this.markedObjectsSet]);
+        });
+        _GxIdeTeamDevCommit_commitSingleObject.set(this, objectId => async () => {
+            const newobjectsStatusMap = new Map(this.objectsStatusMap);
+            newobjectsStatusMap.set(objectId, "commiting");
+            this.objectsStatusMap = newobjectsStatusMap;
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commitObjectsHandler, "f").call(this, [objectId]);
+        });
+        _GxIdeTeamDevCommit_commitObjectsHandler.set(this, async (selection) => {
+            if (this.commentsValue.length === 0) {
+                // A comment is required to commit.
+                this.commentInputHasError = true;
+                return;
+            }
+            this.commentInputHasError = false;
+            this.commiting = true;
+            selection.forEach(itemToUpdate => {
+                this.objectsStatusMap.set(itemToUpdate, "commiting");
+            });
+            const commitResult = await this.commitCallback(selection, this.commentsValue);
+            commitResult.forEach(async (objectResult) => {
+                const messages = objectResult.messages;
+                if (messages.length) {
+                    this.objectsMessagesDataMap.set(objectResult.id, objectResult.messages);
+                }
+                else {
+                    // clear messages
+                    this.objectsMessagesDataMap.delete(objectResult.id);
+                }
+                if (objectResult.result === "commited") {
+                    this.alreadyCommitedObjectsIdsSet.add(objectResult.id);
+                    this.objectsStatusMap.set(objectResult.id, "commited");
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").markRow(objectResult.id, false);
+                }
+                else {
+                    this.objectsStatusMap.set(objectResult.id, "pending");
+                }
+            });
+            this.commiting = false;
+        });
+        // handlers
+        _GxIdeTeamDevCommit_rowMarkingChangedHandler.set(this, async (event) => {
+            const markedRowsIds = event.detail.rowsId;
+            this.markedObjectsSet = new Set(markedRowsIds.filter(markedObjectId => !this.alreadyCommitedObjectsIdsSet.has(markedObjectId)));
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevCommit_rowCheckedChangedByTheUser, "f")) {
+                __classPrivateFieldGet(this, _GxIdeTeamDevCommit_updatePendingCheckedItems, "f").call(this, event);
+            }
+        });
+        _GxIdeTeamDevCommit_rowSelectionChangedHandler.set(this, async (event) => {
+            const selectedRowsIds = event.detail.rowsId;
+            const firstSelectedRowId = selectedRowsIds[0];
+            const gridSource = this.pendingIdsSet.has(firstSelectedRowId)
+                ? "pending"
+                : "ignored";
+            const filteredSelectedRowsIds = clearGridSelection(gridSource, selectedRowsIds, this.pendingIdsSet, this.ignoredIdsSet, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f"));
+            await this.selectCallback(gridSource, filteredSelectedRowsIds);
+        });
+        _GxIdeTeamDevCommit_commentsInputHandler.set(this, (event) => {
+            this.commentsValue = event.detail;
+            if (this.commentsValue.length && this.commentInputHasError) {
+                // remove error style and tooltip
+                this.commentInputHasError = false;
+            }
+        });
+        // filter related
+        _GxIdeTeamDevCommit_applyClientFilter.set(this, () => {
+            this.pendingObjectsAfterFilter = __classPrivateFieldGet(this, _GxIdeTeamDevCommit_filteredObjects, "f").call(this, this.pendingAndIgnored.pendingForCommit);
+            this.ignoredObjectsAfterFilter = __classPrivateFieldGet(this, _GxIdeTeamDevCommit_filteredObjects, "f").call(this, this.pendingAndIgnored.ignoredObjects);
+        });
+        _GxIdeTeamDevCommit_filteredObjects.set(this, (objects) => {
+            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;
+                });
+            }
+            // status
+            if (this.selectedState && this.selectedState !== ALL_VALUE) {
+                filtered = filtered.filter(object => object.state === this.selectedState);
+            }
+            return filtered;
+        });
+        _GxIdeTeamDevCommit_evaluateSecondaryFilterHasConditions.set(this, () => {
+            if (
+            // this.selectedChangeset !== ALL_VALUE ||
+            this.selectedFolder !== ALL_VALUE
+            // this.selectedCategory !== ALL_VALUE
+            ) {
+                this.filterSecondaryHasConditions = true;
+            }
+            else {
+                this.filterSecondaryHasConditions = false;
+            }
+        });
+        _GxIdeTeamDevCommit_toggleFiltersHandler.set(this, () => {
+            this.filterSecondaryIsHidden = !this.filterSecondaryIsHidden;
+        });
+        _GxIdeTeamDevCommit_searchInputHandler.set(this, (event) => {
+            this.searchValue = event.detail.trim();
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_applyClientFilter, "f").call(this);
+        });
+        _GxIdeTeamDevCommit_typeChangedHandler.set(this, (event) => {
+            this.selectedType = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_loadData, "f").call(this);
+        });
+        _GxIdeTeamDevCommit_stateChangedHandler.set(this, (event) => {
+            this.selectedState = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_applyClientFilter, "f").call(this);
+        });
+        // changeset is a WIP.
+        // #changesetChangedHandler = (event: CustomEvent<string> | InputEvent) => {
+        //   this.selectedChangeset = event.detail as string;
+        //   this.#loadData();
+        //   this.#evaluateSecondaryFilterHasConditions();
+        // };
+        _GxIdeTeamDevCommit_folderChanged.set(this, (event) => {
+            this.selectedFolder = event.detail;
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_loadData, "f").call(this);
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_evaluateSecondaryFilterHasConditions, "f").call(this);
+        });
+        // #categoryChangedHandler = (event: CustomEvent<string> | InputEvent) => {
+        //   this.selectedCategory = event.detail as string;
+        //   this.#loadData();
+        //   this.#evaluateSecondaryFilterHasConditions();
+        // };
+        _GxIdeTeamDevCommit_onRowContextMenuHandler.set(this, () => async (ev) => {
+            ev.preventDefault();
+            ev.stopPropagation();
+            const selectedRowsIds = await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").getSelectedRows();
+            const firstSelectedRowId = selectedRowsIds[0];
+            const gridSource = this.pendingIdsSet.has(firstSelectedRowId)
+                ? "pending"
+                : "ignored";
+            await this.objectsContextMenuCallback(gridSource, {
+                selection: selectedRowsIds,
+                clientX: ev.detail.clientX,
+                clientY: ev.detail.clientY
+            });
+        });
+        // other methods
+        _GxIdeTeamDevCommit_updatePendingCheckedItems.set(this, async (event) => {
+            __classPrivateFieldSet(this, _GxIdeTeamDevCommit_rowCheckedChangedByTheUser, false, "f");
+            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, _GxIdeTeamDevCommit_revertPendingCommitsCheckboxes, "f").call(this, addedRowsIds, removedRowsId);
+            }
+            else {
+                await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_togglePendingCommitsCheckboxes, "f").call(this, pendingItemCheckedResult);
+            }
+            __classPrivateFieldSet(this, _GxIdeTeamDevCommit_rowCheckedChangedByTheUser, true, "f");
+        });
+        _GxIdeTeamDevCommit_setInitialObjectsStatus.set(this, () => {
+            if (this.objectsRenderedAlready) {
+                return;
+            }
+            this.pendingAndIgnored.pendingForCommit.forEach(pendingObject => {
+                const status = "pending";
+                this.objectsStatusMap.set(pendingObject.id, status);
+            });
+            this.pendingAndIgnored.ignoredObjects.forEach(ignoredObject => {
+                const status = "ignored";
+                this.objectsStatusMap.set(ignoredObject.id, status);
+            });
+        });
+        _GxIdeTeamDevCommit_loadData.set(this, async () => {
+            this.loading = true;
+            this.pendingAndIgnored = await this.loadCallback({
+                search: this.searchValue,
+                type: this.selectedType,
+                changeset: this.selectedChangeset,
+                folder: this.selectedFolder,
+                category: this.selectedCategory
+            });
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_setInitialObjectsStatus, "f").call(this);
+            this.loading = false;
+            // Is is required to mark/check all objects after loadCallback.
+            __classPrivateFieldGet(this, _GxIdeTeamDevCommit_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.
+         **/
+        _GxIdeTeamDevCommit_markPendingObjects.set(this, () => {
+            for (const pendingId of this.pendingIdsSet) {
+                if (!this.alreadyCommitedObjectsIdsSet.has(pendingId)) {
+                    this.markedObjectsSet = new Set([...this.markedObjectsSet, pendingId]);
+                }
+            }
+        });
+        // render methods
+        _GxIdeTeamDevCommit_revertPendingCommitsCheckboxes.set(this, async (addedRowsIds, removedRowsId) => {
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f")) {
+                for (const rowId of addedRowsIds) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").markRow(rowId, false);
+                }
+                for (const rowId of removedRowsId) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").markRow(rowId, true);
+                }
+            }
+        });
+        _GxIdeTeamDevCommit_togglePendingCommitsCheckboxes.set(this, async (itemsToToggle) => {
+            if (__classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f")) {
+                const itemsToCheck = itemsToToggle.itemsToCheck;
+                const itemsToUncheck = itemsToToggle.itemsToUncheck;
+                // check
+                for (const rowId of itemsToCheck) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").markRow(rowId, true);
+                }
+                // uncheck
+                for (const rowId of itemsToUncheck) {
+                    await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, "f").markRow(rowId, false);
+                }
+            }
+        });
+        this.alreadyCommitedObjectsIdsSet = new Set([]);
+        this.ignoredIdsSet = new Set([]);
+        this.pendingIdsSet = new Set([]);
+        this.markedObjectsSet = new Set([]);
+        this.objectsStatusMap = new Map();
+        this.objectsMessagesDataMap = new Map();
+        this.atLeastOneObjectIsChecked = false;
+        this.commentInputHasError = false;
+        this.commiting = false;
+        this.filterSecondaryIsHidden = true;
+        this.filterSecondaryHasConditions = false;
+        this.loading = true;
+        this.objectsRenderedAlready = false;
+        this.changesetsComboBoxModel = undefined;
+        this.pendingObjectsAfterFilter = [];
+        this.ignoredObjectsAfterFilter = [];
+        this.typesComboBoxModel = [];
+        this.pendingAndIgnored = {
+            pendingForCommit: [],
+            ignoredObjects: []
+        };
+        this.commentsValue = "";
+        this.searchValue = "";
+        this.selectedType = undefined;
+        this.selectedState = ALL_VALUE;
+        this.selectedChangeset = undefined;
+        this.selectedFolder = undefined;
+        this.selectedCategory = undefined;
+        this.foldersComboBoxModel = undefined;
+        this.commitCallback = undefined;
+        this.objectsContextMenuCallback = undefined;
+        this.loadCallback = undefined;
+        this.openServerCallback = undefined;
+        this.pendingItemsCheckedCallback = undefined;
+        this.selectCallback = undefined;
+        this.types = undefined;
+        this.changeset = undefined;
+        this.folders = undefined;
+        this.updatePillAsButton = false;
+        this.serverDetails = undefined;
+    }
+    markedObjectsSetChanged(newMarkedObjectsSet) {
+        this.atLeastOneObjectIsChecked = newMarkedObjectsSet.size > 0;
+    }
+    objectsStatusMapChanged(newObjectsStatusMap) {
+        const someObjectIsUpdating = [...newObjectsStatusMap.entries()].find(([, state]) => state === "commiting");
+        if (!someObjectIsUpdating) {
+            this.commiting = false;
+        }
+    }
+    pendingAndIgnoredChanged() {
+        var _a, _b;
+        __classPrivateFieldGet(this, _GxIdeTeamDevCommit_applyClientFilter, "f").call(this);
+        this.pendingIdsSet.clear();
+        (_a = this.pendingAndIgnored.pendingForCommit) === null || _a === void 0 ? void 0 : _a.forEach(pending => {
+            this.pendingIdsSet.add(pending.id);
+        });
+        this.ignoredIdsSet.clear();
+        (_b = this.pendingAndIgnored.ignoredObjects) === null || _b === void 0 ? void 0 : _b.forEach(ignored => {
+            this.ignoredIdsSet.add(ignored.id);
+        });
+    }
+    typesChanged(newTypes) {
+        this.typesComboBoxModel = typesToComboBoxItemModel(newTypes);
+    }
+    changesetChanged(newChangesetOptions) {
+        this.changesetsComboBoxModel =
+            changesetToComboBoxModel(newChangesetOptions);
+    }
+    folderChanged(newFolderOptions) {
+        this.foldersComboBoxModel = foldersToComboBoxModel(newFolderOptions);
+    }
+    async componentWillLoad() {
+        __classPrivateFieldSet(this, _GxIdeTeamDevCommit_componentLocale, await Locale.getComponentStrings(this.el), "f");
+        // Initiate "actions" combo box filter
+        __classPrivateFieldSet(this, _GxIdeTeamDevCommit_localStatesComboBoxModel, [
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").states.all,
+                value: ALL_VALUE
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").states.inserted,
+                value: "inserted"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").states.modified,
+                value: "modified"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").states.conflicted,
+                value: "conflicted"
+            },
+            {
+                caption: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").states.deleted,
+                value: "deleted"
+            }
+        ], "f");
+        // intialize combo-box models
+        this.typesComboBoxModel = typesToComboBoxItemModel(this.types);
+        this.selectedType = this.typesComboBoxModel[0].value;
+        this.selectedState = __classPrivateFieldGet(this, _GxIdeTeamDevCommit_localStatesComboBoxModel, "f")[0].value;
+        this.changesetChanged(this.changeset);
+        this.selectedChangeset =
+            this.changesetsComboBoxModel.length > 0
+                ? this.changesetsComboBoxModel[0].value
+                : ALL_VALUE;
+        this.folderChanged(this.folders);
+        this.selectedFolder =
+            this.foldersComboBoxModel && this.foldersComboBoxModel.length > 0
+                ? this.foldersComboBoxModel[0].value
+                : ALL_VALUE;
+        // this.categoryChanged(this.categories);
+        // this.selectedCategory =
+        //   this.categoriesComboBoxModel.length > 0
+        //     ? this.categoriesComboBoxModel[0].value
+        //     : ALL_VALUE;
+        __classPrivateFieldGet(this, _GxIdeTeamDevCommit_evaluateSecondaryFilterHasConditions, "f").call(this);
+    }
+    async componentDidLoad() {
+        await __classPrivateFieldGet(this, _GxIdeTeamDevCommit_loadData, "f").call(this);
+    }
+    /**
+     * Used by the host to instruct the component to force a data reload in the grids.
+     */
+    async reload() {
+        __classPrivateFieldGet(this, _GxIdeTeamDevCommit_loadData, "f").call(this);
+    }
+    render() {
+        const disableControls = this.commiting || this.loading;
+        const gridIsEmpty = this.pendingObjectsAfterFilter.length === 0 &&
+            this.ignoredObjectsAfterFilter.length === 0;
+        const filterIcon = this.filterSecondaryHasConditions
+            ? ICONS.filterWithConditions
+            : ICONS.filter;
+        const commitButtonEnabled = this.atLeastOneObjectIsChecked && this.commentsValue.length > 0;
+        return (h(Host, { class: "widget" }, h("ch-theme", { model: CSS_BUNDLES }), h("section", { class: "section" }, h("header", { class: { [CLASSES.HEADER]: true } }, h("div", {
+            // header details
+            class: { [CLASSES.HEADER_DETAILS]: true }
+        }, headerTitle(__classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").commitDetail.title), 
+        // genexus server
+        headerDetail("link", __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").commitDetail.genexusServer, this.serverDetails ? this.serverDetails.serverUrl : "", this.openServerCallback, "detail__genexus-server"), 
+        // knowledge base
+        headerDetail("text", __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").commitDetail.knowledgeBase, this.serverDetails ? this.serverDetails.kbName : "", undefined, "detail__knowledge-base"), 
+        // version
+        headerDetail("text", __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").commitDetail.version, this.serverDetails ? this.serverDetails.versionName : "", undefined, "detail__version"))), h("div", { class: "filter-container spacing-body-inline" }, h("div", { class: { [CLASSES.FILTER]: true, "filter-primary": true } }, h("ch-edit", {
+            // searchch-edit
+            class: "input filter__combo", disabled: disableControls, startImgSrc: ICONS.search, accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.searchAccessibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.searchPlaceholder, type: "search", onInput: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_searchInputHandler, "f")
+        }), h("ch-combo-box-render", {
+            // types
+            class: "combo-box filter__combo", disabled: disableControls, model: this.typesComboBoxModel, value: this.selectedType, accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.typeAccesibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.typePlaceholder, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_typeChangedHandler, "f")
+        }), h("ch-combo-box-render", {
+            // local states
+            class: "combo-box filter__combo", disabled: disableControls, model: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_localStatesComboBoxModel, "f"), value: this.selectedState, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_stateChangedHandler, "f"), accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.localStateAccesibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.localStatePlaceholder
+        })), h("button", {
+            // toggle secondary filter button
+            id: FILTER_SECONDARY_BUTTON_ID, class: "button-secondary button-icon-only", disabled: disableControls, "aria-label": __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.secondaryFilterAriaLabel, "aria-expanded": this.filterSecondaryIsHidden ? "false" : "true", "aria-controls": FILTER_SECONDARY_CONTAINER_ID, onClick: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_toggleFiltersHandler, "f"), title: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.secondaryFilterAriaLabel
+        }, h("ch-image", { class: "icon-md", src: filterIcon })), h("div", { class: "buttons-spacer" }, h("button", {
+            // reload button
+            class: "button-secondary button-icon-and-text", disabled: disableControls, onClick: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_loadData, "f")
+        }, h("ch-image", { class: "icon-md", src: ICONS.refresh }), __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.reload), h("button", {
+            // commit button
+            class: "button-primary", disabled: !commitButtonEnabled || disableControls, onClick: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commitCheckedClickedHandler, "f")
+        }, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.commit)), h("div", {
+            // secondary filter
+            id: FILTER_SECONDARY_CONTAINER_ID, "aria-labelledby": FILTER_SECONDARY_BUTTON_ID, class: {
+                [CLASSES.FILTER]: true,
+                "filter-secondary": true,
+                "filter-secondary--visible": !this.filterSecondaryIsHidden
+            }, inert: this.filterSecondaryIsHidden, hidden: this.filterSecondaryIsHidden
+        }, h("div", null, h("ch-combo-box-render", {
+            // folder
+            class: "combo-box", disabled: disableControls, model: this.foldersComboBoxModel, value: this.selectedFolder, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_folderChanged, "f"), accessibleName: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.folderAccesibleName, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").filter.folderPlaceholder
+        }))), h("ch-edit", {
+            // commit comments
+            class: "input comments", multiline: true, autoGrow: true, placeholder: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").commitCommentPlaceholder, onInput: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commentsInputHandler, "f")
+        })), h("div", { class: CLASSES.MAIN }, !this.loading ? (h("ch-tabular-grid", { class: {
+                "tabular-grid": true,
+                "objects-tabular-grid": true,
+                "disabled-custom-selector": this.commiting,
+                "empty-result": gridIsEmpty
+            }, keyboardNavigationMode: "focus", rowSelectionMode: "multiple", onSelectionChanged: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_rowSelectionChangedHandler, "f"), onRowMarkingChanged: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_rowMarkingChangedHandler, "f"), onRowContextMenu: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_onRowContextMenuHandler, "f").call(this), ref: (el) => (__classPrivateFieldSet(this, _GxIdeTeamDevCommit_chGridPendingForUpdateEl, el, "f")) }, renderTabularGridColumns(["action"], gridIsEmpty, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f")), !gridIsEmpty
+            ? [
+                h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, h("ch-tabular-grid-rowset-legend", { class: "tabular-grid-rowset-legend" }, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").objects.pendingCommits), renderTabularGridRows("pending", this.pendingObjectsAfterFilter, this.ignoredObjectsAfterFilter, this.alreadyCommitedObjectsIdsSet, this.markedObjectsSet, this.objectsMessagesDataMap, this.updatePillAsButton, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commitSingleObject, "f"), this.objectsStatusMap, this.searchValue, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f"))),
+                h("ch-tabular-grid-rowset", { class: "tabular-grid-rowset" }, h("ch-tabular-grid-rowset-legend", { class: "tabular-grid-rowset-legend" }, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").objects.ignoredObjects), renderTabularGridRows("ignored", this.pendingObjectsAfterFilter, this.ignoredObjectsAfterFilter, this.alreadyCommitedObjectsIdsSet, this.markedObjectsSet, this.objectsMessagesDataMap, this.updatePillAsButton, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_commitSingleObject, "f"), this.objectsStatusMap, this.searchValue, __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f")))
+            ]
+            : 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: ICONS.filter, stateTitle: "No object matched your filter" })))))) : (h("gx-ide-loader", { cancelLabel: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").loader.cancelLabel, loaderTitle: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").loader.title, description: __classPrivateFieldGet(this, _GxIdeTeamDevCommit_componentLocale, "f").loader.description, show: true, class: "loader" }))))));
+    }
+    static get is() { return "gx-ide-team-dev-commit"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["commit.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["commit.css"]
+        };
+    }
+    static get assetsDirs() { return ["gx-ide-assets/team-dev-commit"]; }
+    static get properties() {
+        return {
+            "commitCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "CommitCallback",
+                    "resolved": "(selection: string[], commitComment: string) => Promise<CommitResultData[]>",
+                    "references": {
+                        "CommitCallback": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::CommitCallback"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Invoked when user starts the commit process"
+                }
+            },
+            "objectsContextMenuCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ContextMenuCallback",
+                    "resolved": "(source: SourceType, contextMenuInfo: ContextMenuInfo) => Promise<void>",
+                    "references": {
+                        "ContextMenuCallback": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::ContextMenuCallback"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Invoked when user activates the context menu on any of the grids."
+                }
+            },
+            "loadCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LoadCallback",
+                    "resolved": "(filters: FiltersData) => Promise<CommitData>",
+                    "references": {
+                        "LoadCallback": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::LoadCallback"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Invoked to return the list of data types loaded from file\nor url."
+                }
+            },
+            "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": "Invoked when user clicks in server url of Update From group."
+                }
+            },
+            "pendingItemsCheckedCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "PendingItemsCheckedCallback",
+                    "resolved": "(pendingItemsCheckedState: ItemsCheckedState) => Promise<ItemsCheckedResult>",
+                    "references": {
+                        "PendingItemsCheckedCallback": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::PendingItemsCheckedCallback"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Invoked to return information of a Font type of data."
+                }
+            },
+            "selectCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "SelectCallback",
+                    "resolved": "(source: SourceType, selectionIds: string[]) => {}",
+                    "references": {
+                        "SelectCallback": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::SelectCallback"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Invoked when the user selects rows from the grid"
+                }
+            },
+            "types": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ObjectType[]",
+                    "resolved": "ObjectType[]",
+                    "references": {
+                        "ObjectType": {
+                            "location": "import",
+                            "path": "../../../../common/types",
+                            "id": "src/common/types.ts::ObjectType"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\"types\" options for the filter."
+                }
+            },
+            "changeset": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "GxOption[]",
+                    "resolved": "GxOption[]",
+                    "references": {
+                        "GxOption": {
+                            "location": "import",
+                            "path": "../../../../common/types",
+                            "id": "src/common/types.ts::GxOption"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\"changeset\" options for the filter."
+                }
+            },
+            "folders": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "GxOption[]",
+                    "resolved": "GxOption[]",
+                    "references": {
+                        "GxOption": {
+                            "location": "import",
+                            "path": "../../../../common/types",
+                            "id": "src/common/types.ts::GxOption"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\"folder\" options for the filter."
+                }
+            },
+            "updatePillAsButton": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "If true, the \"Action\" column will display a button instead of a pill,\nonly when the action is"
+                },
+                "attribute": "update-pill-as-button",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "serverDetails": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ServerDetails",
+                    "resolved": "ServerDetails",
+                    "references": {
+                        "ServerDetails": {
+                            "location": "import",
+                            "path": "../common/types",
+                            "id": "src/components/team-dev/version-control/common/types.ts::ServerDetails"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Information to show in Update From group."
+                }
+            }
+        };
+    }
+    static get states() {
+        return {
+            "alreadyCommitedObjectsIdsSet": {},
+            "ignoredIdsSet": {},
+            "pendingIdsSet": {},
+            "markedObjectsSet": {},
+            "objectsStatusMap": {},
+            "objectsMessagesDataMap": {},
+            "atLeastOneObjectIsChecked": {},
+            "commentInputHasError": {},
+            "commiting": {},
+            "filterSecondaryIsHidden": {},
+            "filterSecondaryHasConditions": {},
+            "loading": {},
+            "objectsRenderedAlready": {},
+            "changesetsComboBoxModel": {},
+            "pendingObjectsAfterFilter": {},
+            "ignoredObjectsAfterFilter": {},
+            "typesComboBoxModel": {},
+            "pendingAndIgnored": {},
+            "commentsValue": {},
+            "searchValue": {},
+            "selectedType": {},
+            "selectedState": {},
+            "selectedChangeset": {},
+            "selectedFolder": {},
+            "selectedCategory": {},
+            "foldersComboBoxModel": {}
+        };
+    }
+    static get methods() {
+        return {
+            "reload": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "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"
+            }, {
+                "propName": "types",
+                "methodName": "typesChanged"
+            }, {
+                "propName": "changeset",
+                "methodName": "changesetChanged"
+            }, {
+                "propName": "folders",
+                "methodName": "folderChanged"
+            }];
+    }
+}
+_GxIdeTeamDevCommit_componentLocale = new WeakMap(), _GxIdeTeamDevCommit_localStatesComboBoxModel = new WeakMap(), _GxIdeTeamDevCommit_rowCheckedChangedByTheUser = new WeakMap(), _GxIdeTeamDevCommit_chGridPendingForUpdateEl = new WeakMap(), _GxIdeTeamDevCommit_commitCheckedClickedHandler = new WeakMap(), _GxIdeTeamDevCommit_commitSingleObject = new WeakMap(), _GxIdeTeamDevCommit_commitObjectsHandler = new WeakMap(), _GxIdeTeamDevCommit_rowMarkingChangedHandler = new WeakMap(), _GxIdeTeamDevCommit_rowSelectionChangedHandler = new WeakMap(), _GxIdeTeamDevCommit_commentsInputHandler = new WeakMap(), _GxIdeTeamDevCommit_applyClientFilter = new WeakMap(), _GxIdeTeamDevCommit_filteredObjects = new WeakMap(), _GxIdeTeamDevCommit_evaluateSecondaryFilterHasConditions = new WeakMap(), _GxIdeTeamDevCommit_toggleFiltersHandler = new WeakMap(), _GxIdeTeamDevCommit_searchInputHandler = new WeakMap(), _GxIdeTeamDevCommit_typeChangedHandler = new WeakMap(), _GxIdeTeamDevCommit_stateChangedHandler = new WeakMap(), _GxIdeTeamDevCommit_folderChanged = new WeakMap(), _GxIdeTeamDevCommit_onRowContextMenuHandler = new WeakMap(), _GxIdeTeamDevCommit_updatePendingCheckedItems = new WeakMap(), _GxIdeTeamDevCommit_setInitialObjectsStatus = new WeakMap(), _GxIdeTeamDevCommit_loadData = new WeakMap(), _GxIdeTeamDevCommit_markPendingObjects = new WeakMap(), _GxIdeTeamDevCommit_revertPendingCommitsCheckboxes = new WeakMap(), _GxIdeTeamDevCommit_togglePendingCommitsCheckboxes = new WeakMap();
+//# sourceMappingURL=commit.js.map