@umbraco/playwright-testhelpers 17.1.0-beta.5 → 17.1.0-beta.7

package/dist/lib/helpers/FormsUiHelper.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormsUiHelper = void 0;
 const UiBaseLocators_1 = require("./UiBaseLocators");
-const ConstantHelper_1 = require("./ConstantHelper");
+const test_1 = require("@playwright/test");
 class FormsUiHelper extends UiBaseLocators_1.UiBaseLocators {
     quickCreateNewBtn;
     createNewFormModalBtn;
@@ -135,310 +135,350 @@ class FormsUiHelper extends UiBaseLocators_1.UiBaseLocators {
      * Methods for Forms.
      */
     async clickQuickCreateFormButton() {
-        await this.hoverAndClick(this.formMenuItemForForm, this.formMenuItemForForm.locator(this.quickCreateNewBtn));
+        await this.formMenuItemForForm.hover();
+        await this.formMenuItemForForm.locator(this.quickCreateNewBtn).click();
     }
     async clickNewFormButton() {
-        await this.click(this.createNewFormModalBtn);
+        await (0, test_1.expect)(this.createNewFormModalBtn).toBeVisible();
+        await this.createNewFormModalBtn.click();
     }
     async clickSaveFormButton() {
-        await this.click(this.saveFormBtn);
+        await this.saveFormBtn.click();
     }
     async fillFormName(name) {
-        await this.enterText(this.formNameTxt, name);
+        await (0, test_1.expect)(this.formNameTxt).toBeVisible();
+        await this.formNameTxt.fill(name);
     }
     async fillFormPageName(position, name) {
         const nameInput = this.formPageNametxt.nth(position);
-        await this.enterText(nameInput, name);
+        await (0, test_1.expect)(nameInput).toBeVisible();
+        await nameInput.fill(name);
     }
     async fillFormGroupName(position, name) {
         const groupInput = this.formGroupNameTxt.nth(position);
-        await this.enterText(groupInput, name);
+        await (0, test_1.expect)(groupInput).toBeVisible();
+        await groupInput.fill(name);
     }
     async fillFormFieldName(name) {
         await this.formEditFieldModal.locator(this.formFieldNameTxt).fill(name);
     }
     async clickAddNewPageButton() {
-        await this.click(this.formAddNewPageBtn);
+        await this.formAddNewPageBtn.click();
     }
     async clickAddNewGroupButton() {
-        await this.click(this.formAddNewGroupBtn);
+        await this.formAddNewGroupBtn.click();
     }
     async clickAddQuestionButton(index = 0) {
         const button = this.formPage.nth(index).locator(this.formAddQuestionBtn);
-        await this.click(button);
+        await button.click();
     }
     async chooseFormFieldType(type) {
-        await this.click(this.formFieldType.filter({ hasText: type }).nth(0));
+        await this.formFieldType.filter({ hasText: type }).nth(0).click();
     }
     async clickExpandFormsTreeButton() {
-        await this.click(this.formExpandBtn);
+        await this.formExpandBtn.click();
     }
     async doesFormTreeHaveFormName(name) {
-        await this.containsText(this.formTree, name);
+        await (0, test_1.expect)(this.formTree).toContainText(name);
     }
     async goToFormWithName(name) {
-        await this.click(this.formTree.getByText(name, { exact: true }));
+        await this.formTree.getByText(name, { exact: true }).click();
     }
     async clickFormFieldTypeSubmitModal() {
-        await this.click(this.formSubmitButtonModal);
+        await this.formSubmitButtonModal.click();
     }
     async clickActionMenuOnFormMenuItem(name) {
-        await this.click(this.menuItem.locator(`[label="${name}"] uui-button[label="Open actions menu"]`));
+        await this.menuItem.locator('[label="' + name + '"] uui-button[label="Open actions menu"]').click();
     }
     async clickDeleteFormButton() {
-        await this.click(this.formActionModal.locator(this.formDeleteThreeDotBtn));
-        await this.click(this.deleteExactBtn);
+        await this.formActionModal.locator(this.formDeleteThreeDotBtn).click();
+        await this.deleteExactBtn.click();
     }
     async goToFormSetting() {
-        await this.click(this.formWorkspaceEditor.locator(this.formSettingIcon));
+        await this.formWorkspaceEditor.locator(this.formSettingIcon).click();
     }
     async setFormStoreRecordsSetting() {
-        await this.waitForVisible(this.formSettingStoreRecordBtn);
+        await (0, test_1.expect)(this.formSettingStoreRecordBtn).toBeVisible();
         const toggle = this.formSettingStoreRecordBtn.locator(this.formToggleSlider);
-        await this.waitForVisible(toggle);
+        await (0, test_1.expect)(toggle).toBeVisible();
         await toggle.check();
     }
     async setFormCaptionsSetting() {
-        await this.waitForVisible(this.formSettingCaptionsContainer);
+        await (0, test_1.expect)(this.formSettingCaptionsContainer).toBeVisible();
         for (let i = 0; i < 3; i++) {
             const captionInput = this.formSettingCaptions.locator(this.formInputTxt).nth(i);
-            await this.enterText(captionInput, `Test Caption ${i + 1}`);
+            await (0, test_1.expect)(captionInput).toBeVisible();
+            await captionInput.fill("Test Caption " + (i + 1));
         }
     }
     async setFormStylingSetting() {
-        await this.waitForVisible(this.formSettingStylingContainer);
+        await (0, test_1.expect)(this.formSettingStylingContainer).toBeVisible();
         const cssClassInput = this.formSettingStyling.locator(this.formInputTxt);
-        await this.enterText(cssClassInput, "custom-css-class");
+        await (0, test_1.expect)(cssClassInput).toBeVisible();
+        await cssClassInput.fill("custom-css-class");
         const disableDefaultStylesheetInput = this.formSettingStyling.locator(this.formToggleSlider);
-        await this.click(disableDefaultStylesheetInput);
+        await (0, test_1.expect)(disableDefaultStylesheetInput).toBeVisible();
+        await disableDefaultStylesheetInput.click();
     }
     async setFormValidationSetting() {
-        await this.waitForVisible(this.formSettingValidationContainer);
+        await (0, test_1.expect)(this.formSettingValidationContainer).toBeVisible();
         const requiredErrorMessageInput = this.formSettingValidation.locator(this.formInputTxt).nth(0);
-        await this.enterText(requiredErrorMessageInput, "Required error message");
+        await (0, test_1.expect)(requiredErrorMessageInput).toBeVisible();
+        await requiredErrorMessageInput.fill("Required error message");
         const invalidErrorMessageInput = this.formSettingValidation.locator(this.formInputTxt).nth(1);
-        await this.enterText(invalidErrorMessageInput, "Invalid error message");
+        await (0, test_1.expect)(invalidErrorMessageInput).toBeVisible();
+        await invalidErrorMessageInput.fill("Invalid error message");
         const showValidationSummaryInput = this.formSettingValidation.locator(this.formToggleSlider).nth(0);
-        await this.click(showValidationSummaryInput);
+        await (0, test_1.expect)(showValidationSummaryInput).toBeVisible();
+        await showValidationSummaryInput.click();
         const hideFieldValidationInput = this.formSettingValidation.locator(this.formToggleSlider).nth(1);
-        await this.click(hideFieldValidationInput);
+        await (0, test_1.expect)(hideFieldValidationInput).toBeVisible();
+        await hideFieldValidationInput.click();
         const markMandatoryFieldRadioInput = this.formSettingValidation.locator("uui-radio[value = 'MarkMandatoryFields']");
-        await this.click(markMandatoryFieldRadioInput);
+        await (0, test_1.expect)(markMandatoryFieldRadioInput).toBeVisible();
+        await markMandatoryFieldRadioInput.click();
         const indicatorInput = this.formSettingValidation.locator(this.formInputTxt).nth(2);
-        await this.enterText(indicatorInput, "+");
+        await (0, test_1.expect)(indicatorInput).toBeVisible();
+        await indicatorInput.fill("+");
     }
     async setFormAutocompleteSetting() {
-        await this.waitForVisible(this.formSettingAutocompleteContainer);
+        await (0, test_1.expect)(this.formSettingAutocompleteContainer).toBeVisible();
         const autocompleteAttributeRadioInput = this.formSettingAutocomplete.locator('uui-radio[value = "On"]');
-        await this.click(autocompleteAttributeRadioInput);
+        await (0, test_1.expect)(autocompleteAttributeRadioInput).toBeVisible();
+        await autocompleteAttributeRadioInput.click();
     }
     async setFormModerationSetting() {
-        await this.waitForVisible(this.formSettingModerationContainer);
+        await (0, test_1.expect)(this.formSettingModerationContainer).toBeVisible();
         const enablePostModerationAttributeToggleInput = this.formSettingModeration.locator(this.formToggleSlider);
-        await this.click(enablePostModerationAttributeToggleInput);
+        await (0, test_1.expect)(enablePostModerationAttributeToggleInput).toBeVisible();
+        await enablePostModerationAttributeToggleInput.click();
     }
     async setFormFieldsDisplayedSetting() {
-        await this.waitForVisible(this.formSettingFieldsDisplayedContainer);
+        await (0, test_1.expect)(this.formSettingFieldsDisplayedContainer).toBeVisible();
         const displayDefaultFieldsToggleInput = this.formSettingFieldsDisplayed.locator(this.formToggleSlider);
-        await this.click(displayDefaultFieldsToggleInput);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal); // short pause required here otherwise revealed elements are not found
+        await (0, test_1.expect)(displayDefaultFieldsToggleInput).toBeVisible();
+        await displayDefaultFieldsToggleInput.click();
+        await this.page.waitForTimeout(100); // short pause required here otherwise revealed elements are not found
         const displayFieldsSelect = this.formSettingFieldsDisplayed.locator("select");
-        await this.selectByValue(displayFieldsSelect, '_system_state');
+        await (0, test_1.expect)(displayFieldsSelect).toBeVisible();
+        await displayFieldsSelect.selectOption({ value: '_system_state' });
         const displayFieldsAddButton = this.formSettingFieldsDisplayed.locator("button[id='button']");
-        await this.click(displayFieldsAddButton);
+        await (0, test_1.expect)(displayFieldsAddButton).toBeVisible();
+        await displayFieldsAddButton.click();
     }
     async setFormDataRetentionSetting(recordNumber) {
-        await this.waitForVisible(this.formSettingDataRetentionContainer);
+        await (0, test_1.expect)(this.formSettingDataRetentionContainer).toBeVisible();
         const retainSubmittedRecordsToggleInput = this.formSettingDataRetention.locator(this.formToggleSlider).nth(0);
-        await this.click(retainSubmittedRecordsToggleInput);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.minimal); // short pause required here otherwise revealed elements are not found
+        await (0, test_1.expect)(retainSubmittedRecordsToggleInput).toBeVisible();
+        await retainSubmittedRecordsToggleInput.click();
+        await this.page.waitForTimeout(100); // short pause required here otherwise revealed elements are not found
         const retainSubmittedRecordsNumberInput = this.formSettingDataRetention.locator(this.formInputNumber).nth(0);
-        await this.enterText(retainSubmittedRecordsNumberInput, recordNumber);
+        await (0, test_1.expect)(retainSubmittedRecordsNumberInput).toBeVisible();
+        await retainSubmittedRecordsNumberInput.fill(recordNumber);
     }
     async toggleFieldSetting(settingAlias) {
-        const settingFieldLocator = this.page.locator(`umb-property-layout[alias="${settingAlias}"] #toggle`);
-        await this.click(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property-layout[alias="' + settingAlias + '"] #toggle');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
+        await settingFieldLocator.click();
     }
     async applyFieldSettingViaTextInput(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"] input`);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"] input');
         await settingFieldLocator.fill(settingValue);
     }
     async applyFieldSettingViaDropDown(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"] select`);
-        await this.selectByValue(settingFieldLocator, settingValue);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"] select');
+        await settingFieldLocator.selectOption({ value: settingValue });
     }
     async applyFieldSettingViaSlider(settingAlias) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"] #toggle`);
-        await this.click(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"] #toggle');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
+        await settingFieldLocator.click();
     }
     async applyFieldFileUploadSettings(settingAlias, allowedProvidedExtensions, allowedCustomExtensions, allowMultiple) {
-        const settingFieldLocator = this.page.locator(`umb-property-layout[alias="${settingAlias}"]`);
+        const settingFieldLocator = this.page.locator('umb-property-layout[alias="' + settingAlias + '"]');
         for (var i = 0; i < allowedProvidedExtensions.length; i++) {
             const checkBoxLocator = settingFieldLocator.locator('uui-toggle', { hasText: allowedProvidedExtensions[i].toUpperCase() }).locator('#toggle');
-            await this.click(checkBoxLocator);
+            await (0, test_1.expect)(checkBoxLocator).toBeVisible();
+            await checkBoxLocator.click();
         }
         const addNewExtensionLocator = settingFieldLocator.locator('input[placeholder = "Add new allowed file type"]');
-        await this.waitForVisible(addNewExtensionLocator);
+        await (0, test_1.expect)(addNewExtensionLocator).toBeVisible();
         const buttonLocator = settingFieldLocator.locator('form svg');
-        await this.waitForVisible(buttonLocator);
+        await (0, test_1.expect)(buttonLocator).toBeVisible();
         for (var i = 0; i < allowedCustomExtensions.length; i++) {
             await addNewExtensionLocator.fill(allowedCustomExtensions[i]);
-            await this.click(buttonLocator);
+            await buttonLocator.click();
         }
         if (allowMultiple) {
             const alias = "allowMultipleFileUploads";
-            const multipleUploadLocator = this.page.locator(`umb-property-layout[alias="${alias}"] #toggle`);
-            await this.click(multipleUploadLocator);
+            const multipleUploadLocator = this.page.locator('umb-property-layout[alias="' + alias + '"] #toggle');
+            await (0, test_1.expect)(multipleUploadLocator).toBeVisible();
+            await multipleUploadLocator.click();
         }
     }
     async applyFieldPrevalues(settingAlias, prevalues) {
-        const settingFieldLocator = this.page.locator(`umb-property-layout[alias="${settingAlias}"]`);
+        const settingFieldLocator = this.page.locator('umb-property-layout[alias="' + settingAlias + '"]');
         for (var i = 0; i < prevalues.length; i++) {
             const valueFieldLocator = settingFieldLocator.locator("input[placeholder = 'New value']");
-            await this.waitForVisible(valueFieldLocator);
+            await (0, test_1.expect)(valueFieldLocator).toBeVisible();
             await valueFieldLocator.fill(prevalues[i].value);
             const captionFieldLocator = settingFieldLocator.locator("input[placeholder = 'New caption']");
-            await this.enterText(captionFieldLocator, prevalues[i].caption);
+            await (0, test_1.expect)(captionFieldLocator).toBeVisible();
+            await captionFieldLocator.fill(prevalues[i].caption);
             const buttonLocator = settingFieldLocator.locator('uui-button[label="add"]');
-            await this.click(buttonLocator);
+            await (0, test_1.expect)(buttonLocator).toBeVisible();
+            await buttonLocator.click();
         }
     }
     async applyFieldSettingViaTextArea(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"] textarea`);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"] textarea');
         await settingFieldLocator.fill(settingValue);
     }
     async applyFieldSettingViaRichTextInput(settingAlias, settingValue) {
-        const richTextAreaTxt = this.page.locator(`umb-property[alias="${settingAlias}"] umb-property-editor-ui-tiptap`).locator('#editor .tiptap');
-        await this.waitForVisible(richTextAreaTxt);
+        const richTextAreaTxt = this.page.locator('umb-property[alias="' + settingAlias + '"] umb-property-editor-ui-tiptap').locator('#editor .tiptap');
+        await (0, test_1.expect)(richTextAreaTxt).toBeVisible();
         await richTextAreaTxt.fill(settingValue);
     }
     async applyFieldSettingViaRange(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"]`);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"]');
         await settingFieldLocator.locator('input[type="range"]').fill(settingValue);
     }
     async applyFieldSettingViaFieldMappingInput(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"]`);
-        await this.waitForVisible(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"]');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
         for (let i = 0; i < settingValue.length; i++) {
             const buttonLocator = settingFieldLocator.locator('uui-button[label="add"]');
-            await this.click(buttonLocator);
+            await (0, test_1.expect)(buttonLocator).toBeVisible();
+            await buttonLocator.click();
             const aliasInputLocator = settingFieldLocator.locator("input[placeholder = 'Alias']").nth(i);
-            await this.waitForVisible(aliasInputLocator);
+            await (0, test_1.expect)(aliasInputLocator).toBeVisible();
             await aliasInputLocator.fill(settingValue[i].alias);
             const staticValueInputLocator = settingFieldLocator.locator("input[placeholder = 'Static value']").nth(i);
-            await this.waitForVisible(staticValueInputLocator);
+            await (0, test_1.expect)(staticValueInputLocator).toBeVisible();
             await staticValueInputLocator.fill(settingValue[i].staticValue);
         }
     }
     async applyFieldSettingViaDocumentMapper(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"]`);
-        await this.waitForVisible(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"]');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
         const selectLocator = settingFieldLocator.locator("forms-document-mapper-property-editor select");
-        await this.selectByValue(selectLocator, settingValue.doctype);
+        await selectLocator.selectOption({ value: settingValue.doctype });
         const inputLocator = settingFieldLocator.locator('forms-document-mapper-property-editor input[type = "text"]');
-        await this.waitForVisible(inputLocator.first());
+        await (0, test_1.expect)(inputLocator.first()).toBeVisible();
         const inputLocatorCount = await inputLocator.count();
         for (let i = 0; i < inputLocatorCount; i++) {
-            await this.waitForVisible(inputLocator.nth(i));
+            await (0, test_1.expect)(inputLocator.nth(i)).toBeVisible();
             await inputLocator.nth(i).fill(settingValue.nameStaticValue);
         }
     }
     async applyFieldSettingViaEmailTemplatePicker(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"]`);
-        await this.waitForVisible(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"]');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
         const buttonLocator = settingFieldLocator.locator("#caret-button");
-        await this.click(buttonLocator);
+        await buttonLocator.click();
         const templateLocator = this.page.locator("#label-button", { hasText: settingValue });
-        await this.click(templateLocator);
+        await (0, test_1.expect)(templateLocator).toBeVisible();
+        await templateLocator.click();
     }
     async applyFieldSettingViaStandardFieldMappingInput(settingAlias, settingValue) {
-        const settingFieldLocator = this.page.locator(`umb-property[alias="${settingAlias}"]`);
-        await this.waitForVisible(settingFieldLocator);
+        const settingFieldLocator = this.page.locator('umb-property[alias="' + settingAlias + '"]');
+        await (0, test_1.expect)(settingFieldLocator).toBeVisible();
         for (let i = 0; i < settingValue.length; i++) {
             if (settingValue[i].include) {
-                const includeButtonLocator = settingFieldLocator.locator(`div[data-umb-standard-field-mapping-include="${settingValue[i].alias}"] #toggle`);
-                await this.click(includeButtonLocator);
+                const includeButtonLocator = settingFieldLocator.locator('div[data-umb-standard-field-mapping-include="' + settingValue[i].alias + '"] #toggle');
+                await includeButtonLocator.click();
             }
-            const keyNameButtonLocator = settingFieldLocator.locator(`div[data-umb-standard-field-mapping-key-name="${settingValue[i].alias}"] input[type="text"]`);
+            const keyNameButtonLocator = settingFieldLocator.locator('div[data-umb-standard-field-mapping-key-name="' + settingValue[i].alias + '"] input[type="text"]');
             await keyNameButtonLocator.fill(settingValue[0].keyName);
         }
     }
     async setFieldMandatory(message) {
-        await this.click(this.formFieldMandatory.locator("#toggle"));
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.medium);
+        await (0, test_1.expect)(this.formFieldMandatory).toBeVisible();
+        await this.formFieldMandatory.locator("#toggle").click();
+        await this.page.waitForTimeout(1000);
         const inputLocator = this.formFieldMandatory.locator(this.formInputTxt);
-        await this.enterText(inputLocator, message);
+        await (0, test_1.expect)(inputLocator).toBeVisible();
+        await inputLocator.fill(message);
     }
     async setFieldValidation(label, message) {
-        await this.waitForVisible(this.formFieldRegex);
+        await (0, test_1.expect)(this.formFieldRegex).toBeVisible();
         const selectLocator = this.formFieldRegex.locator("select");
-        await this.selectByText(selectLocator, label);
-        await this.page.waitForTimeout(ConstantHelper_1.ConstantHelper.wait.medium);
+        await selectLocator.selectOption({ label: label });
+        await this.page.waitForTimeout(1000);
         const inputLocator = this.formFieldRegex.locator("input");
-        await this.enterText(inputLocator, message);
+        await (0, test_1.expect)(inputLocator).toBeVisible();
+        await inputLocator.fill(message);
     }
     async clickFormWorkflowConfigureButton() {
-        await this.click(this.formWorkflowConfigureBtn);
+        await this.formWorkflowConfigureBtn.click();
     }
     async clickFormWorkflowEditSubmitButton() {
-        await this.click(this.formEditWorkflowModal.locator(this.formSubmitButtonModal));
+        await this.formEditWorkflowModal.locator(this.formSubmitButtonModal).click();
     }
     async clickFormWorkflowConfigureSubmitButton() {
-        await this.click(this.formConfigureWorkflowModal.locator(this.formSubmitButtonModal));
+        await this.formConfigureWorkflowModal.locator(this.formSubmitButtonModal).click();
     }
     async clickFormWorkflowAddButton() {
-        await this.click(this.formWorkflowOnSubmitStage.locator(this.formWorkflowAddButtonModal), { force: true });
+        await this.formWorkflowOnSubmitStage.locator(this.formWorkflowAddButtonModal).click({ force: true });
     }
     async selectWorkflowType(workflowType) {
-        await this.click(this.page.locator(`umb-ref-item[title="${workflowType}"]`));
+        this.page.locator('umb-ref-item[title="' + workflowType + '"]').click();
     }
     async fillWorkflowName(workflowName) {
-        await this.enterText(this.formWorkflowNameTxt, workflowName);
+        await (0, test_1.expect)(this.formWorkflowNameTxt).toBeVisible();
+        await this.formWorkflowNameTxt.fill(workflowName);
     }
     /*
      * Methods for Prevalue Source.
      */
     async clickQuickCreatePrevalueSourceButton() {
-        await this.hoverAndClick(this.formMenuItemForPrevalueSource, this.formMenuItemForPrevalueSource.locator(this.quickCreateNewBtn));
+        await (0, test_1.expect)(this.formMenuItemForPrevalueSource).toBeVisible();
+        await this.formMenuItemForPrevalueSource.hover();
+        await this.formMenuItemForPrevalueSource.locator(this.quickCreateNewBtn).click();
     }
     async clickPrevalueSourceTypeButton(type) {
         const button = this.createNewPrevaluesourceModalBtn.locator("#name", { hasText: type });
-        await this.click(button);
+        await (0, test_1.expect)(button).toBeVisible();
+        await button.click();
     }
     async clickExpandPrevalueSourceTreeButton() {
-        await this.click(this.prevalueSourceExpandBtn);
+        await this.prevalueSourceExpandBtn.click();
     }
     async goToPrevalueSourceWithName(name) {
-        await this.click(this.prevalueSourceTree.locator(`uui-menu-item[label="${name}"]`));
+        await this.prevalueSourceTree.locator('uui-menu-item[label="' + name + '"]').click();
     }
     async clickDeletePrevalueSourceButton(name) {
-        const prevalueSource = this.prevalueSourceTree.locator(`uui-menu-item[label="${name}"]`);
-        await this.click(prevalueSource.locator(this.prevalueSourceDeleteBtn));
-        await this.click(this.deleteExactBtn);
+        const prevalueSource = await this.prevalueSourceTree.locator('uui-menu-item[label="' + name + '"]');
+        await prevalueSource.locator(this.prevalueSourceDeleteBtn).click();
+        await this.deleteExactBtn.click();
     }
     async applyCacheOptions(option, timeValue = 0, timeUnit = "") {
-        await this.waitForVisible(this.prevalueSourceCacheContainer);
-        const optionSelect = this.prevalueSourceCacheContainer.locator(`uui-radio[value = "${option}"]`);
-        await this.click(optionSelect);
+        await (0, test_1.expect)(this.prevalueSourceCacheContainer).toBeVisible();
+        const optionSelect = this.prevalueSourceCacheContainer.locator('uui-radio[value = "' + option + '"]');
+        await (0, test_1.expect)(optionSelect).toBeVisible();
+        await optionSelect.click();
         if (option === "time") {
             const numberInput = this.prevalueSourceCacheContainer.locator("input[type='number']");
-            await this.waitForVisible(numberInput);
+            await (0, test_1.expect)(numberInput).toBeVisible();
             await numberInput.fill(timeValue.toString());
             const unitSelect = this.prevalueSourceCacheContainer.locator("select");
-            await this.selectByValue(unitSelect, timeUnit);
+            await (0, test_1.expect)(unitSelect).toBeVisible();
+            await unitSelect.selectOption({ value: timeUnit });
         }
     }
     async applyPrevalueSourceSettingViaNodeSelector(labelText, settingValue) {
-        const container = this.page.locator(`umb-property[alias="${labelText}"]`);
-        await this.waitForVisible(container);
+        const container = this.page.locator('umb-property[alias="' + labelText + '"]');
+        await (0, test_1.expect)(container).toBeVisible();
         const rootNode = container.locator('uui-button[label="Specify root node"]');
-        await this.click(rootNode);
-        await this.waitForVisible(this.prevalueSourceOriginModal);
-        const value = this.prevalueSourceOriginModal.locator(`umb-ref-item[name="${settingValue}"]`);
-        await this.click(value);
+        await (0, test_1.expect)(rootNode).toBeVisible();
+        await rootNode.click();
+        await (0, test_1.expect)(this.prevalueSourceOriginModal).toBeVisible();
+        const value = this.prevalueSourceOriginModal.locator('umb-ref-item[name="' + settingValue + '"]');
+        await (0, test_1.expect)(value).toBeVisible();
+        await value.click();
     }
     async checkPrevalueSourceTypeLabel() {
-        await this.waitForVisible(this.prevalueSourceTypeLabel);
+        await (0, test_1.expect)(this.prevalueSourceTypeLabel).toBeVisible();
     }
 }
 exports.FormsUiHelper = FormsUiHelper;