d5-testing-library 1.3.0 → 1.4.0

package/dist/d5-testing-library.mjs

@@ -73,6 +73,9 @@ var AbstractElement = class {
   getFullCssSelector() {
     return this.elementCssSelector;
   }
+  joinRelativeCssSelectors(selectors) {
+    return selectors.join(" ");
+  }
   async getElement() {
     return this.driver.findElement(By.css(this.getFullCssSelector()));
   }
@@ -125,6 +128,9 @@ var AbstractPage = class extends AbstractElement {
 // src/utils/actions.ts
 var click = async (webElement, driver) => {
   driver = driver ?? config().driver;
+  if (!await webElement.isDisplayed()) {
+    await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
+  }
   const actions = driver.actions({ async: true });
   await actions.move({ origin: webElement }).click().perform();
 };
@@ -137,6 +143,7 @@ var byTestIdCssSelector = (testId, element = "div") => {
 var byTestId = (testId, element = "div") => {
   return By2.css(byTestIdCssSelector(testId, element));
 };
+var readonlyLocator = "readonly";
 
 // src/pageObjects/pages/LoginPage.ts
 var LOGIN_PATH = "/login";
@@ -219,6 +226,11 @@ var AbstractElementWithParent = class extends AbstractElement {
     }
     return `${this.parentCssSelector} ${this.elementCssSelector}`;
   }
+  async isReadonly() {
+    const fieldEl = await this.getElement();
+    const classSting = await fieldEl.getAttribute("class");
+    return classSting.includes(readonlyLocator);
+  }
 };
 
 // src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
@@ -244,7 +256,95 @@ var SubsystemsPanel = class extends AbstractElement {
 };
 
 // src/pageObjects/elements/Forms/AbstractForm.ts
+import { By as By6 } from "selenium-webdriver";
+
+// src/utils/createDataTestId.ts
+function createDataTestId(formName, itemType, itemName) {
+  return `${formName}-${itemType}-${itemName}`;
+}
+function createFieldTestId(formName, itemName) {
+  return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
+}
+function createGroupTestId(formName, itemName) {
+  return createDataTestId(formName, "group" /* GROUP */, itemName);
+}
+function createFilterTestId(formName, itemName, layout) {
+  return createDataTestId(formName, "filter" /* FILTER */, itemName) + `-${layout}`;
+}
+function createDocFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
+}
+function createLayoutFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
+}
+function createTableId(formName) {
+  return `${"table" /* TABLE */}-${formName}`;
+}
+function createFormButtonTestId(formName, itemName) {
+  return createDataTestId(formName, "button" /* BUTTON */, itemName);
+}
+
+// src/utils/waitElementIsClickable.ts
+async function waitElementIsClickable({
+  element,
+  timeout,
+  errorMessage,
+  driver
+}) {
+  driver = driver ?? config().driver;
+  await wait(async () => {
+    const isDisabled = await element.getCssValue("pointer-events") === "none";
+    return await element.isDisplayed() && !isDisabled;
+  }, driver, errorMessage, timeout ?? config().timeout);
+}
+
+// src/pageObjects/elements/TableToolbar/AbstractButton.ts
+var AbstractButton = class extends AbstractElementWithParent {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  async click() {
+    const button = await this.getElement();
+    await waitElementIsClickable({
+      element: button,
+      errorMessage: this.buttonNotDisplayedError(),
+      driver: this.driver
+    });
+    await click(button, this.driver);
+  }
+  async isDisabled() {
+    const button = await this.getElement();
+    return await button.getCssValue("pointer-events") === "none";
+  }
+};
+
+// src/pageObjects/elements/DXComponents/DXButton.ts
 import { By as By5 } from "selenium-webdriver";
+var DXButton = class extends AbstractButton {
+  async getText() {
+    const classes = await this.getClasses();
+    if (!classes.includes("dx-button-has-text")) {
+      return null;
+    }
+    const el = await this.getElement();
+    const textEl = el.findElement(By5.className("dx-button-text"));
+    return await textEl.getText();
+  }
+};
+
+// src/pageObjects/elements/FormButton.ts
+var FormButton = class extends DXButton {
+  name;
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), driver);
+    this.name = name;
+  }
+  buttonNotDisplayedError() {
+    return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+};
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
 var AbstractForm = class extends AbstractPage {
   containerCssSelector = "";
   containerBy;
@@ -291,42 +391,22 @@ var AbstractForm = class extends AbstractPage {
    */
   async getTitleText() {
     if (await this.isModal()) {
-      const titleEl2 = await this.driver.findElement(By5.css(`${this.popupContainerCssSelector} .popup-title`));
+      const titleEl2 = await this.driver.findElement(By6.css(`${this.popupContainerCssSelector} .popup-title`));
       return titleEl2.getText();
     }
-    let titleEl = await this.driver.findElement(By5.className("main-toolbar-form-title"));
+    let titleEl = await this.driver.findElement(By6.className("main-toolbar-form-title"));
     return titleEl.getText();
   }
+  button(name) {
+    return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
+  }
 };
 
 // src/pageObjects/elements/Forms/FormEdit.ts
-import { By as By12 } from "selenium-webdriver";
-
-// src/utils/createDataTestId.ts
-function createDataTestId(formName, itemType, itemName) {
-  return `${formName}-${itemType}-${itemName}`;
-}
-function createFieldTestId(formName, itemName) {
-  return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
-}
-function createGroupTestId(formName, itemName) {
-  return createDataTestId(formName, "group" /* GROUP */, itemName);
-}
-function createFilterTestId(formName, itemName, layout) {
-  return createDataTestId(formName, "filter" /* FILTER */, itemName) + `-${layout}`;
-}
-function createDocFilterTestId(formName, itemName) {
-  return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
-}
-function createLayoutFilterTestId(formName, itemName) {
-  return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
-}
-function createTableId(formName) {
-  return `${"table" /* TABLE */}-${formName}`;
-}
+import { By as By15 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Editors/AbstractEditor.ts
-import { By as By6, Key } from "selenium-webdriver";
+import { By as By7, Key } from "selenium-webdriver";
 
 // src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
 var InputClearStrategy = class {
@@ -346,7 +426,7 @@ var AbstractDXEditorWithInput = class extends AbstractElementWithParent {
     return `${this.getFullCssSelector()} .dx-texteditor-input`;
   }
   async getInputElement() {
-    return this.driver.findElement(By6.css(this.getInputCssSelector()));
+    return this.driver.findElement(By7.css(this.getInputCssSelector()));
   }
   async getInputValue() {
     const inputEl = await this.getInputElement();
@@ -391,6 +471,22 @@ var NumberEditor = class extends AbstractDXEditorWithInput {
   }
 };
 
+// src/pageObjects/elements/Editors/types.ts
+var ControlClass = /* @__PURE__ */ ((ControlClass2) => {
+  ControlClass2["Text"] = "text-control";
+  ControlClass2["TextArea"] = "text-area-control";
+  ControlClass2["Number"] = "number-control";
+  ControlClass2["CheckBox"] = "check-box";
+  ControlClass2["Multiselect"] = "multi-select-control";
+  ControlClass2["Select"] = "select-control";
+  ControlClass2["Switch"] = "switch-control";
+  ControlClass2["Date"] = "date-control";
+  ControlClass2["SingleDateRange"] = "single-date-range-control";
+  ControlClass2["BooleanSelector"] = "buttons-group";
+  ControlClass2["ButtonGroup"] = "button-group-field";
+  return ControlClass2;
+})(ControlClass || {});
+
 // src/pageObjects/AbstractFormElement.ts
 var AbstractFormElement = class extends AbstractElementWithParent {
   constructor(parentCssSelector, elementCssSelector, driver) {
@@ -418,20 +514,17 @@ var CheckBox = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
-import { By as By8, Key as Key2 } from "selenium-webdriver";
+import { By as By9, Key as Key2 } from "selenium-webdriver";
 
 // src/utils/xpathHelper.ts
 var XPathHelper = class {
-  static getRoleXpath(role) {
-    return `//div[@role='${role}']`;
-  }
   static getClassAndValueXpath(cssClass, value) {
-    return `//div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+    return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
   }
 };
 
 // src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
-import { By as By7 } from "selenium-webdriver";
+import { By as By8 } from "selenium-webdriver";
 var DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
 var DX_CLEAR_BUTTON_AREA = "dx-clear-button-area";
 var ClearButtonStrategy = class {
@@ -442,7 +535,7 @@ var ClearButtonStrategy = class {
     this._driver = driver;
   }
   async isEmptyEditorField() {
-    const editorContainer = await this._driver.findElement(By7.css(this.editorContainerClass));
+    const editorContainer = await this._driver.findElement(By8.css(this.editorContainerClass));
     const classAttribute = await editorContainer.getAttribute("class");
     return classAttribute.includes(DX_TEXTEDITOR_EMPTY);
   }
@@ -451,18 +544,31 @@ var ClearButtonStrategy = class {
       throw new Error("This field is already empty");
     }
     const clearBtnSelector = `${this.editorContainerClass} .${DX_CLEAR_BUTTON_AREA}`;
-    const clearBtn = await this._driver.findElement(By7.css(clearBtnSelector));
+    const clearBtn = await this._driver.findElement(By8.css(clearBtnSelector));
     await click(clearBtn, this._driver);
   }
 };
 
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
 var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
-var SELECT_BOX_ELEMENT_ROLE = "option";
-var combinedValueXpath = (value) => `${XPathHelper.getRoleXpath(SELECT_BOX_ELEMENT_ROLE)}${XPathHelper.getClassAndValueXpath(
-  SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS,
-  value
-)}`;
+var combinedValueXpath = (value) => `//body/div[@id="root"]/div[contains(@class, "dx-overlay-wrapper")]//${XPathHelper.getClassAndValueXpath(SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, value)}`;
+var dropDownOptionClick = async (optionValue, driver, delay = true) => {
+  const { implicit } = await driver.manage().getTimeouts();
+  let optElement = null;
+  const timeout = delay ? implicit : 200;
+  let err = null;
+  try {
+    await driver.manage().setTimeouts({ implicit: timeout });
+    optElement = await driver.findElement(By9.xpath(combinedValueXpath(optionValue)));
+    await click(optElement, driver);
+  } catch (e) {
+    err = new Error(`Item not found: "${optionValue}"`);
+  } finally {
+    await driver.manage().setTimeouts({ implicit });
+  }
+  if (err)
+    throw err;
+};
 var SelectBoxEditor = class extends AbstractDXEditorWithInput {
   constructor(parentCssSelector, elementCssSelector, driver) {
     super(parentCssSelector, elementCssSelector, driver);
@@ -471,9 +577,12 @@ var SelectBoxEditor = class extends AbstractDXEditorWithInput {
   async setSelectInputValue(value) {
     const inputEl = await this.getInputElement();
     await click(inputEl, this.driver);
-    await inputEl.sendKeys(value, Key2.ENTER);
-    const optElement = await inputEl.findElement(By8.xpath(combinedValueXpath(value)));
-    await click(optElement, this.driver);
+    try {
+      await dropDownOptionClick(value, this.driver, false);
+    } catch {
+      await inputEl.sendKeys(value, Key2.ENTER);
+      await dropDownOptionClick(value, this.driver);
+    }
   }
   async getValue() {
     const value = await super.getInputValue();
@@ -512,7 +621,7 @@ var SwitchEditor = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Editors/TagBox.ts
-import { By as By9 } from "selenium-webdriver";
+import { By as By10 } from "selenium-webdriver";
 var TAGS_SELECTOR = ".dx-tag .tag-text";
 var DX_TAG_CONTAINER = "dx-tag-container";
 var DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
@@ -533,31 +642,35 @@ var TagBox = class extends AbstractDXEditorWithInput {
     await this.confirmSelection();
   }
   async waitOptionSelection() {
-    const option = await this.driver.findElement(By9.css(TAG_BOX_LIST_ITEM_SELECTOR));
+    const option = await this.driver.findElement(By10.css(TAG_BOX_LIST_ITEM_SELECTOR));
     await wait(() => option.isDisplayed(), this.driver);
   }
   async selectOption(inputEl, value, lastElement) {
-    await inputEl.sendKeys(value);
-    const optElement = await inputEl.findElement(By9.xpath(combinedValueXpath(value)));
-    await click(optElement, this.driver);
+    try {
+      await dropDownOptionClick(value, this.driver, false);
+    } catch {
+      await inputEl.sendKeys(value);
+      await dropDownOptionClick(value, this.driver);
+    }
     await this.waitOptionSelection();
     if (value !== lastElement) {
       await inputEl.clear();
     }
   }
   async confirmSelection() {
-    const btnOk = await this.driver.findElement(By9.css(BTN_OK_SELECTOR));
+    const btnOk = await this.driver.findElement(By10.css(BTN_OK_SELECTOR));
     await click(btnOk, this.driver);
   }
   async getTagBoxInputValue() {
     if (await this.isTagBoxEmpty()) {
       return [];
     }
-    const tags = await this.driver.findElements(By9.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`));
+    const tags = await this.driver.findElements(
+      By10.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`)
+    );
     const values = [];
     for (const tag of tags) {
-      const text = await tag.getText();
-      values.push(text);
+      values.push(await tag.getAttribute("textContent"));
     }
     return values;
   }
@@ -582,24 +695,26 @@ var TagBox = class extends AbstractDXEditorWithInput {
       throw new Error(`The tag with the text: ${itemText} was not found`);
     }
     const clearBtnTestId = byTestIdCssSelector(`clear-button-${itemText}`);
-    const clearBtn = await this.driver.findElement(By9.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`));
+    const clearBtn = await this.driver.findElement(
+      By10.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
+    );
     await click(clearBtn, this.driver);
   }
 };
 
 // src/pageObjects/elements/Editors/ButtonGroup.ts
-import { By as By10 } from "selenium-webdriver";
+import { By as By11 } from "selenium-webdriver";
 var ITEM_CLASS = "dx-buttongroup-item";
 var SELECTED_CLASS = "dx-state-selected";
 var ButtonGroup = class extends AbstractElementWithParent {
   getItems() {
-    return this.driver.findElements(By10.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
+    return this.driver.findElements(By11.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
   }
   getDataValue(el) {
     return el.getAttribute("data-value");
   }
   async getValue() {
-    const selectedEl = await this.driver.findElement(By10.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
+    const selectedEl = await this.driver.findElement(By11.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
     return this.getDataValue(selectedEl);
   }
   async setValue(value) {
@@ -632,26 +747,67 @@ var BooleanSelector = class extends ButtonGroup {
   }
 };
 
-// src/pageObjects/elements/Editors/DateEditor.ts
-import { By as By11, Key as Key3 } from "selenium-webdriver";
-var DateEditor = class extends AbstractDXEditorWithInput {
+// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
+import { By as By13 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
+import { By as By12, Key as Key3 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/Date/utils.ts
+var formatDMYDate = (date) => {
+  const [year, month, day] = date.toJSON().split("T")[0].split("-");
+  return `${day}${month}${year}`;
+};
+
+// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
+var BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
+var BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
+var BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR = "DateRange__inputs-item--dateTo";
+var BTN_SAVE_SELECTOR = "DateRange__button-save";
+var BaseDateEditor = class extends AbstractDXEditorWithInput {
   constructor(parentCssSelector, elementCssSelector, driver) {
     super(parentCssSelector, elementCssSelector, driver);
     this.setClearStrategy(new InputClearStrategy());
   }
-  async getDateElement() {
-    return this.driver.findElement(By11.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
-  }
   async setDateValue(value) {
-    const dateEl = await this.getInputElement();
-    const stringDate = value.toJSON().split("T")[0];
-    const dateArr = stringDate.split("-");
-    const [year, month, day] = dateArr;
-    const keys = day + month + year;
-    await click(dateEl, this.driver);
     const actions = this.driver.actions({ async: true });
-    await actions.move({ origin: dateEl }).sendKeys(Key3.HOME).perform();
-    await actions.move({ origin: dateEl }).sendKeys(keys, Key3.ENTER).perform();
+    const dateField = await this.driver.findElement(By12.css(`${this.getFullCssSelector()}`));
+    const dateFieldDataTestID = await this.getDataTestId();
+    const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
+    const dateInputEl = await this.getInputElement();
+    await dateInputEl.clear();
+    if (Array.isArray(value)) {
+      const formattedDates = value.map(formatDMYDate);
+      const button = await dateField.findElement(By12.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+      await button.click();
+      const calendarPopoverElement = await this.driver.findElement(By12.css(calendarPopoverSelector));
+      const dateFromInput = await calendarPopoverElement.findElement(By12.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
+      const dateToInput = await calendarPopoverElement.findElement(By12.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`));
+      await dateFromInput.click();
+      await dateFromInput.sendKeys(formattedDates[0]);
+      await dateToInput.click();
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.HOME).perform();
+      await dateToInput.sendKeys(formattedDates[1]);
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.ENTER).perform();
+      const btnOk = await this.driver.findElement(By12.css(`.${BTN_SAVE_SELECTOR}`));
+      await btnOk.click();
+    } else {
+      const formattedDate = formatDMYDate(value);
+      await click(dateInputEl, this.driver);
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.HOME).perform();
+      await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, Key3.ENTER).perform();
+    }
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
+var SingleDateEditor = class extends BaseDateEditor {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getDateElement() {
+    return this.driver.findElement(By13.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
   }
   async getDateValue() {
     const inputEl = await this.getDateElement();
@@ -669,27 +825,105 @@ var DateEditor = class extends AbstractDXEditorWithInput {
   }
 };
 
+// src/pageObjects/elements/Editors/Date/DateRangeEditor.ts
+import { By as By14 } from "selenium-webdriver";
+var DateRangeEditor = class extends BaseDateEditor {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getDateElement() {
+    return this.driver.findElement(By14.css(this.getFullCssSelector() + " .dx-texteditor-input"));
+  }
+  async getDateValue() {
+    const inputEl = await this.getDateElement();
+    const dateFromStr = await inputEl.getAttribute("datefrom");
+    const dateToStr = await inputEl.getAttribute("dateto");
+    const dateFrom = new Date(dateFromStr);
+    const dateTo = new Date(dateToStr);
+    return [dateFrom, dateTo];
+  }
+  async getValue() {
+    const values = await this.getDateValue();
+    return !values.length ? null : values;
+  }
+  setValue(value) {
+    if (typeof value === "object") {
+      return this.setDateValue(value);
+    }
+    throw new Error(`Value is incorrect. It should be Object`);
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/DateEditor.ts
+var DateEditor = class extends AbstractDXEditorWithInput {
+  editorInstance = null;
+  initPromise;
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.initPromise = this.init(parentCssSelector, elementCssSelector, driver);
+  }
+  async init(parentCssSelector, elementCssSelector, driver) {
+    await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
+  }
+  async updateEditorInstance(parentCssSelector, elementCssSelector, driver) {
+    const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+    const classString = await elementInstance.getClasses();
+    switch (true) {
+      case classString.includes("date-control" /* Date */):
+        this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+        break;
+      case classString.includes("single-date-range-control" /* SingleDateRange */):
+        this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, driver);
+        break;
+      default:
+        this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+    }
+  }
+  async ensureInitialized() {
+    if (!this.editorInstance) {
+      await this.initPromise;
+    }
+  }
+  async setValue(value) {
+    await this.ensureInitialized();
+    if (this.editorInstance) {
+      await this.editorInstance.setValue(value);
+      return await this.updateEditorInstance(this.parentCssSelector, this.elementCssSelector, this.driver);
+    }
+    throw new Error("Editor instance is not initialized.");
+  }
+  async getValue() {
+    await this.ensureInitialized();
+    if (this.editorInstance) {
+      return this.editorInstance.getValue();
+    }
+    throw new Error("Editor instance is not initialized.");
+  }
+};
+
 // src/pageObjects/elements/Editors/editorFactory.ts
 var editorFactory = async (parentCssSelector, elementCssSelector, driver) => {
   const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
   const classSting = await elementInstance.getClasses();
-  if (classSting.includes("text-control"))
+  if ((classSting.includes("text-control" /* Text */) || classSting.includes("text-area-control" /* TextArea */)) && !classSting.includes("single-date-range-control" /* SingleDateRange */))
     return new TextEditor(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("number-control"))
+  if (classSting.includes("number-control" /* Number */))
     return new NumberEditor(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("check-box"))
+  if (classSting.includes("check-box" /* CheckBox */))
     return new CheckBox(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("multi-select-control"))
+  if (classSting.includes("multi-select-control" /* Multiselect */))
     return new TagBox(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("select-control"))
+  if (classSting.includes("select-control" /* Select */))
     return new SelectBoxEditor(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("switch-control"))
+  if (classSting.includes("switch-control" /* Switch */))
     return new SwitchEditor(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("date-control"))
+  if (classSting.includes("date-control" /* Date */) || classSting.includes("single-date-range-control" /* SingleDateRange */)) {
     return new DateEditor(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("buttons-group"))
+  }
+  if (classSting.includes("buttons-group" /* BooleanSelector */))
     return new BooleanSelector(parentCssSelector, elementCssSelector, driver);
-  if (classSting.includes("button-group-field"))
+  if (classSting.includes("button-group-field" /* ButtonGroup */))
     return new ButtonGroup(parentCssSelector, elementCssSelector, driver);
   throw new Error("Unknown type of editor. Please write ticket to the support");
 };
@@ -749,6 +983,16 @@ var AbstractEditor = class extends AbstractElementWithParent {
     }
     return this.editor.remove(itemText);
   }
+  /**
+   * Возвращает значение true|false в зависимости readOnly поле или нет
+   * @example
+   * expect(await formEdit.field('NumberFld').isReadonly()).toBe(true);
+   * expect(await formEdit.field('TextFld').isReadonly()).toBe(false);
+   */
+  async isReadonly() {
+    await this.initEditor();
+    return this.editor.isReadonly();
+  }
 };
 
 // src/pageObjects/elements/FormField.ts
@@ -807,7 +1051,8 @@ var FormGroup = class extends AbstractElementWithParent {
 
 // src/pageObjects/elements/Forms/FormEdit.ts
 var FormEdit = class extends AbstractForm {
-  saveButtonBy = By12.id("button-save");
+  saveButtonBy = By15.id("button-save");
+  closeButtonBy = By15.id("button-cancel");
   constructor(driver) {
     super(driver);
     this.popupContainerCssSelector = `.popup .form-edit-${this.formName}`;
@@ -856,19 +1101,30 @@ var FormEdit = class extends AbstractForm {
     await wait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
     await click(saveButton, this.driver);
   }
+  /**
+   * Нажатие на кнопку Закрить
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * await formEdit.closeButtonClick();
+   */
+  async closeButtonClick() {
+    const closeButton = await this.driver.findElement(this.closeButtonBy);
+    await click(closeButton, this.driver);
+  }
 };
 
 // src/pageObjects/elements/Table/Table.ts
-import { By as By17 } from "selenium-webdriver";
+import { By as By20 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Row.ts
-import { By as By15 } from "selenium-webdriver";
+import { By as By18 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Cell.ts
-import { By as By14 } from "selenium-webdriver";
+import { By as By17 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/utils.ts
-import { By as By13 } from "selenium-webdriver";
+import { By as By16 } from "selenium-webdriver";
 function getCssRowByIndexSelector(index) {
   return `tr[aria-rowindex="${transformInputIndex(index)}"]`;
 }
@@ -895,9 +1151,18 @@ var Cell = class extends AbstractElementWithParent {
     this.elementCssSelector = getCssCellByIndexSelector(index);
   }
   async getBooleanValue(cellEl) {
-    const booleanEl = await cellEl.findElement(By14.className("boolean-widget"));
+    const booleanEl = await cellEl.findElement(By17.className("boolean-widget"));
     return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
   }
+  async getTagsValue(cellEl) {
+    const tagsCssSelector = ".multiselect-container .multiselect-cell";
+    const tags = await cellEl.findElements(By17.css(tagsCssSelector));
+    const values = [];
+    for (const tag of tags) {
+      values.push(await tag.getAttribute("textContent"));
+    }
+    return values;
+  }
   async getElement() {
     if (this._index == null) {
       this.index = await this.getCellIndex();
@@ -907,9 +1172,10 @@ var Cell = class extends AbstractElementWithParent {
   async getValue() {
     const cellEl = await this.getElement();
     const cellElClass = await cellEl.getAttribute("class");
-    if (cellElClass.includes("boolean-column")) {
+    if (cellElClass.includes("boolean-column" /* Boolean */))
       return this.getBooleanValue(cellEl);
-    }
+    if (cellElClass.includes("tags-column" /* Tags */))
+      return this.getTagsValue(cellEl);
     return cellEl.getText();
   }
   getIndex() {
@@ -930,9 +1196,14 @@ var Row = class extends AbstractElementWithParent {
     this.getColumnBy = getColumnBy;
   }
   _getCell({ index, name, title }) {
-    return new Cell(this.getFullCssSelector(), () => {
-      return this.getColumnBy({ title, name }).getIndex();
-    }, index, this.driver);
+    return new Cell(
+      this.getFullCssSelector(),
+      () => {
+        return this.getColumnBy({ title, name }).getIndex();
+      },
+      index,
+      this.driver
+    );
   }
   getCellByIndex(index) {
     return this._getCell({ index });
@@ -946,10 +1217,14 @@ var Row = class extends AbstractElementWithParent {
   async select() {
     const rowEl = await this.getElement();
     await click(rowEl, this.driver);
-    await wait(async () => {
-      const classes = await this.getClasses();
-      return classes.includes(DX_SELECTION_CLASS);
-    }, this.driver, "Cannot select row");
+    await wait(
+      async () => {
+        const classes = await this.getClasses();
+        return classes.includes(DX_SELECTION_CLASS);
+      },
+      this.driver,
+      "Cannot select row"
+    );
   }
   async isSelected() {
     const result = await this.getAttribute("aria-selected");
@@ -959,7 +1234,7 @@ var Row = class extends AbstractElementWithParent {
     return this.index;
   }
   async getCells() {
-    const cells = await this.driver.findElements(By15.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
+    const cells = await this.driver.findElements(By18.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
     const result = [];
     cells.forEach((_, index) => {
       const newCell = this.getCellByIndex(index);
@@ -969,14 +1244,22 @@ var Row = class extends AbstractElementWithParent {
   }
   async clickInlineButton(buttonClass) {
     const FIXED_TABLE_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
-    const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(this.index)}"] .${buttonClass}`;
-    const button = await this.driver.findElement(By15.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`));
+    const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
+      this.index
+    )}"] .${buttonClass}`;
+    const button = await this.driver.findElement(
+      By18.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`)
+    );
     return click(button, this.driver);
   }
   async checkEditingMode(isEditing, msg) {
-    await wait(async () => {
-      return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
-    }, this.driver, msg);
+    await wait(
+      async () => {
+        return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
+      },
+      this.driver,
+      msg
+    );
   }
   async edit() {
     await this.clickInlineButton("edit");
@@ -993,19 +1276,18 @@ var Row = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Table/elements/Column.ts
-import { By as By16 } from "selenium-webdriver";
-var getHeaderCssSelector = () => {
-  return ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
-};
+import { By as By19 } from "selenium-webdriver";
 var Column = class extends AbstractElementWithParent {
   _index;
   _caption;
   _name;
-  constructor({ parentCssSelector, name, caption, index, driver }) {
+  headerCssSelector;
+  constructor({ parentCssSelector, headerCssSelector, name, caption, index, driver }) {
     super(parentCssSelector, "", driver);
     this._name = name;
     this.index = index;
     this._caption = caption;
+    this.headerCssSelector = headerCssSelector;
   }
   set index(index) {
     this._index = index;
@@ -1019,7 +1301,9 @@ var Column = class extends AbstractElementWithParent {
     return super.getElement();
   }
   async getColumnHeaderIndexBy(cssSelector) {
-    const column = await this.driver.findElement(By16.css(`${this.parentCssSelector} ${getHeaderCssSelector()} ${cssSelector}`));
+    const column = await this.driver.findElement(
+      By19.css(`${this.parentCssSelector} ${this.headerCssSelector} ${cssSelector}`)
+    );
     return transformOutputIndex(await column.getAttribute("aria-colindex"));
   }
   async getIndexByCaption() {
@@ -1051,9 +1335,11 @@ var Column = class extends AbstractElementWithParent {
 // src/pageObjects/elements/Table/Table.ts
 var Table = class extends AbstractElementWithParent {
   formName;
-  constructor(parentCssSelector, formName, driver) {
+  headerCssSelector;
+  constructor(parentCssSelector, headerCssSelector, formName, driver) {
     super(parentCssSelector, `#${createTableId(formName)}`, driver);
     this.formName = formName;
+    this.headerCssSelector = headerCssSelector;
   }
   getColumnBy = (args) => {
     if (args.title) {
@@ -1074,6 +1360,7 @@ var Table = class extends AbstractElementWithParent {
   getColumnByTitle = (title) => {
     return new Column({
       parentCssSelector: this.getFullCssSelector(),
+      headerCssSelector: this.headerCssSelector,
       caption: title,
       driver: this.driver
     });
@@ -1081,6 +1368,7 @@ var Table = class extends AbstractElementWithParent {
   getColumnByName = (name) => {
     return new Column({
       parentCssSelector: this.getFullCssSelector(),
+      headerCssSelector: this.headerCssSelector,
       name,
       driver: this.driver
     });
@@ -1089,7 +1377,7 @@ var Table = class extends AbstractElementWithParent {
     return this.getRowByIndex(index).select();
   }
   async getRows() {
-    const rows = await this.driver.findElements(By17.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
+    const rows = await this.driver.findElements(By20.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
     const result = [];
     rows.forEach((_, index) => {
       const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
@@ -1098,7 +1386,9 @@ var Table = class extends AbstractElementWithParent {
     return result;
   }
   async getColumns() {
-    const columns = await this.driver.findElements(By17.css(`${this.getFullCssSelector()} ${getHeaderCssSelector()} td[role="columnheader"]`));
+    const columns = await this.driver.findElements(
+      By20.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+    );
     const result = [];
     columns.forEach((_, index) => {
       const newCol = new Column({
@@ -1125,24 +1415,6 @@ var Table = class extends AbstractElementWithParent {
   }
 };
 
-// src/pageObjects/elements/TableToolbar/AbstractButton.ts
-var AbstractButton = class extends AbstractElementWithParent {
-  constructor(parentCssSelector, elementCssSelector, driver) {
-    super(parentCssSelector, elementCssSelector, driver);
-  }
-  async click() {
-    const button = await this.getElement();
-    await wait(async () => {
-      return await button.isDisplayed() && !await this.isDisabled();
-    }, this.driver, this.buttonNotDisplayedError());
-    await click(button, this.driver);
-  }
-  async isDisabled() {
-    const button = await this.getElement();
-    return await button.getCssValue("pointer-events") === "none";
-  }
-};
-
 // src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
 var ToolbarGroupButton = class extends AbstractButton {
   name;
@@ -1168,16 +1440,97 @@ var ToolbarButton = class extends AbstractButton {
   }
 };
 
+// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
+import { By as By21 } from "selenium-webdriver";
+
+// src/utils/typesUtil.ts
+var types = {
+  "[object Array]": "array",
+  "[object Date]": "date",
+  "[object Object]": "object",
+  "[object String]": "string",
+  "[object Null]": "null"
+};
+var type = function(object) {
+  const typeOfObject = Object.prototype.toString.call(object);
+  return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
+};
+var isArray = function(value) {
+  return type(value) === "array";
+};
+var isString = function(object) {
+  return typeof object === "string";
+};
+
+// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
+var SPINDOWN_CLASS = ".dx-icon-spindown";
+var buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
+var getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
+var buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
+var ToolbarMenu = class extends AbstractElementWithParent {
+  _formName;
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, getFullCssSelector(formName, name), driver);
+    this._formName = formName;
+  }
+  async toggle() {
+    const dropdown = await this.getElement();
+    await click(dropdown, this.driver);
+  }
+  getCssSelectorToButton(name) {
+    return byTestId(`ftb-${this._formName}-${name}`);
+  }
+  buttonNotDisplayedError(name) {
+    return `Toolbar menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+  async goToButton(name, selector) {
+    const toolbarMenuItem = this.driver.findElement(selector);
+    await waitElementIsClickable({
+      element: toolbarMenuItem,
+      errorMessage: this.buttonNotDisplayedError(name),
+      driver: this.driver
+    });
+    await click(toolbarMenuItem, this.driver);
+  }
+  async clickButton(name) {
+    await this.toggle();
+    if (isString(name)) {
+      const selector = this.getCssSelectorToButton(name);
+      await this.goToButton(name, selector);
+    }
+    if (isArray(name)) {
+      for (let n of name) {
+        const selector = this.getCssSelectorToButton(n);
+        await this.goToButton(n, selector);
+      }
+    }
+  }
+  async clickButtonByTitle(title) {
+    await this.toggle();
+    if (isString(title)) {
+      const selector = By21.xpath(buttonByTextXpath(title));
+      await this.goToButton(title, selector);
+    }
+    if (isArray(title)) {
+      for (let t of title) {
+        const selector = By21.xpath(buttonByTextXpath(t));
+        await this.goToButton(t, selector);
+      }
+    }
+  }
+};
+
 // src/pageObjects/elements/TableToolbar/ToolbarItem.ts
 var GROUP_BUTTON_CLASS = "toolbar-group-button";
 var toolbarItemSelector = (form, name) => byTestIdCssSelector(`ftb-${form}-${name}`);
 var ToolbarItem = class extends AbstractElementWithParent {
   _button;
-  // private _formName: string;
+  _formName;
   _itemName;
   constructor(parentCssSelector, formName, itemName, driver) {
     super(parentCssSelector, toolbarItemSelector(formName, itemName), driver);
     this._itemName = itemName;
+    this._formName = formName;
   }
   async init() {
     if (this._button)
@@ -1197,6 +1550,9 @@ var ToolbarItem = class extends AbstractElementWithParent {
     await this.init();
     return await this._button.isDisabled();
   }
+  get menu() {
+    return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/FormToolbar.ts
@@ -1254,7 +1610,7 @@ var FormFilterField = class extends AbstractEditor {
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-import { By as By18 } from "selenium-webdriver";
+import { By as By22 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Filters/PanelFilterField.ts
 var PanelFilterField = class extends AbstractEditor {
@@ -1309,7 +1665,7 @@ var FilterPanel = class extends AbstractElement {
   async filterPanelButtons() {
     const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
     const el = await this.getElement();
-    return el.findElements(By18.css(selector));
+    return el.findElements(By22.css(selector));
   }
   constructor(formName, driver) {
     super(driver, drawerSelector(formName));
@@ -1342,16 +1698,19 @@ var FilterPanel = class extends AbstractElement {
     await this.driver.sleep(300);
   }
   async close() {
-    const btn = await this.driver.findElement(By18.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+    const btn = await this.driver.findElement(By22.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
     await click(btn, this.driver);
   }
 };
 
 // src/pageObjects/elements/Forms/ListForm.ts
+var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
 var ListForm = class extends AbstractForm {
+  headerCssSelector;
   constructor(driver) {
     super(driver);
     this.popupContainerCssSelector = `.popup .form-inline-${this.formName}`;
+    this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
   }
   /**
    * Находит таблицу
@@ -1361,7 +1720,7 @@ var ListForm = class extends AbstractForm {
    * expect(listForm.table());
    */
   table() {
-    return new Table(this.containerCssSelector, this.formName, this.driver);
+    return new Table(this.containerCssSelector, this.headerCssSelector, this.formName, this.driver);
   }
   /**
    * Находит группу на лист форме по имени
@@ -1406,8 +1765,67 @@ var ListForm = class extends AbstractForm {
     return new FilterPanel(this.formName, this.driver);
   }
 };
+
+// src/pageObjects/elements/Forms/TreeView.ts
+var TREELIST_HEADER_CSS_SELECTOR = ".dx-treelist-headers .dx-treelist-content:not(.dx-datagrid-content-fixed)";
+var TreeView = class extends ListForm {
+  constructor(driver) {
+    super(driver);
+    this.popupContainerCssSelector = `.popup .wrapper-tree-view-${this.formName}`;
+    this.headerCssSelector = TREELIST_HEADER_CSS_SELECTOR;
+  }
+};
+
+// src/pageObjects/elements/Dialog.ts
+import { By as By23 } from "selenium-webdriver";
+var DIALOG_CLASS = ".d5-dialog";
+var DIALOG_TITLE_CLASS = ".dialog__title";
+var DIALOG_TEXT_CLASS = ".dialog__text";
+var DIALOG_BUTTONS_PANEL_CLASS = ".dialog__buttons-panel";
+var buttonByTextXpath2 = (text) => `.//span[contains(@class, "dx-button-text") and contains(text(), "${text}")]`;
+var DialogButton = class extends AbstractButton {
+  text;
+  constructor(parentCssSelector, text, driver) {
+    super(parentCssSelector, "", driver);
+    this.text = text;
+  }
+  async getElement() {
+    const panel = await super.getElement();
+    return panel.findElement(By23.xpath(buttonByTextXpath2(this.text)));
+  }
+  buttonNotDisplayedError() {
+    return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
+  }
+};
+var Dialog = class extends AbstractElement {
+  constructor(driver) {
+    super(driver, DIALOG_CLASS);
+  }
+  get titleSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TITLE_CLASS]);
+  }
+  get textSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TEXT_CLASS]);
+  }
+  get buttonsSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
+  }
+  async title() {
+    const el = await this.driver.findElement(By23.css(this.titleSelector));
+    return await el.getText();
+  }
+  async text() {
+    const el = await this.driver.findElement(By23.css(this.textSelector));
+    return await el.getText();
+  }
+  button(text) {
+    return new DialogButton(this.buttonsSelector, text, this.driver);
+  }
+};
 export {
   AbstractPage,
+  ControlClass,
+  Dialog,
   FilterPanel,
   FormEdit,
   FormField,
@@ -1418,6 +1836,7 @@ export {
   PanelFilterField,
   SubsystemsPanel,
   TextEditor,
+  TreeView,
   byTestId,
   byTestIdCssSelector,
   click,
@@ -1425,6 +1844,7 @@ export {
   createDriver,
   editorFactory,
   elementIsNotPresent,
+  readonlyLocator,
   signIn,
   wait,
   waitElementIsVisible