d5-testing-library 1.2.0 → 1.3.1

package/dist/d5-testing-library.legacy-esm.js

@@ -38,11 +38,61 @@ function config(cfg) {
   return configInstance.config(cfg);
 }
 
+// src/pageObjects/AbstractElement.ts
+import { By } from "selenium-webdriver";
+
+// src/utils/waitElementIsVisible.ts
+import { until } from "selenium-webdriver";
+
+// src/utils/wait.ts
+async function wait(condition, driver, errorMessage, timeout) {
+  driver = driver ?? config().driver;
+  await driver.wait(condition, timeout ?? config().timeout, errorMessage);
+}
+
+// src/utils/waitElementIsVisible.ts
+async function waitElementIsVisible({
+  element,
+  timeout,
+  errorMessage,
+  driver
+}) {
+  driver = driver ?? config().driver;
+  const condition = until.elementIsVisible(element);
+  await wait(condition.fn, driver, errorMessage ?? condition.description(), timeout ?? config().timeout);
+}
+
 // src/pageObjects/AbstractElement.ts
 var AbstractElement = class {
   driver;
-  constructor(driver) {
+  elementCssSelector;
+  constructor(driver, elementCssSelector) {
     this.driver = driver || config().driver;
+    this.elementCssSelector = elementCssSelector;
+  }
+  getFullCssSelector() {
+    return this.elementCssSelector;
+  }
+  joinRelativeCssSelectors(selectors) {
+    return selectors.join(" ");
+  }
+  async getElement() {
+    return this.driver.findElement(By.css(this.getFullCssSelector()));
+  }
+  async getAttribute(attr) {
+    const element = await this.getElement();
+    await waitElementIsVisible({
+      element,
+      driver: this.driver,
+      errorMessage: `Element not found: ${this.getFullCssSelector()}`
+    });
+    return await element.getAttribute(attr);
+  }
+  async getClasses() {
+    return await this.getAttribute("class");
+  }
+  async getDataTestId() {
+    return await this.getAttribute("data-testid");
   }
 };
 
@@ -75,13 +125,57 @@ var AbstractPage = class extends AbstractElement {
   }
 };
 
+// src/utils/actions.ts
+var click = async (webElement, driver) => {
+  driver = driver ?? config().driver;
+  const actions = driver.actions({ async: true });
+  await actions.move({ origin: webElement }).click().perform();
+};
+
 // src/utils/locators.ts
-import { By } from "selenium-webdriver";
+import { By as By2 } from "selenium-webdriver";
 var byTestIdCssSelector = (testId, element = "div") => {
   return `${element}[data-testid="${testId}"]`;
 };
 var byTestId = (testId, element = "div") => {
-  return By.css(byTestIdCssSelector(testId, element));
+  return By2.css(byTestIdCssSelector(testId, element));
+};
+var readonlyLocator = "readonly";
+
+// src/pageObjects/pages/LoginPage.ts
+var LOGIN_PATH = "/login";
+var LoginPage = class extends AbstractPage {
+  usernameField = byTestId("loginField", "input");
+  passwordField = byTestId("passwordField", "input");
+  loginButton = byTestId("loginButton");
+  async locate() {
+    await super.locate();
+    const login = await this.driver.findElement(this.usernameField);
+    await waitElementIsVisible({
+      element: login,
+      driver: this.driver
+    });
+  }
+  get path() {
+    return LOGIN_PATH;
+  }
+  async enterUsername(username) {
+    await this.driver.findElement(this.usernameField).sendKeys(username);
+  }
+  async enterPassword(password) {
+    await this.driver.findElement(this.passwordField).sendKeys(password);
+  }
+  async clickLoginButton() {
+    await click(await this.driver.findElement(this.loginButton), this.driver);
+  }
+  async loginWith(username, password) {
+    await this.enterUsername(username);
+    await this.enterPassword(password);
+    await this.clickLoginButton();
+  }
+  async authorize() {
+    await this.loginWith(config().auth.login, config().auth.password);
+  }
 };
 
 // src/utils/createDriver.ts
@@ -103,36 +197,22 @@ var elementIsNotPresent = function elementIsNotPresent2(locator) {
   });
 };
 
-// src/utils/waitElementIsVisible.ts
-import { until } from "selenium-webdriver";
-
-// src/utils/wait.ts
-async function wait(condition, driver, errorMessage, timeout) {
-  driver = driver ?? config().driver;
-  await driver.wait(condition, timeout ?? config().timeout, errorMessage);
-}
-
-// src/utils/waitElementIsVisible.ts
-async function waitElementIsVisible({
-  element,
-  timeout,
-  errorMessage,
-  driver
-}) {
-  driver = driver ?? config().driver;
-  const condition = until.elementIsVisible(element);
-  await wait(condition.fn, driver, errorMessage ?? condition.description(), timeout ?? config().timeout);
+// src/utils/signIn.ts
+async function signIn(driver) {
+  const webDriver = driver ?? await createDriver();
+  config().driver = webDriver;
+  const loginPage = new LoginPage(webDriver);
+  await loginPage.locate();
+  await loginPage.authorize();
+  return webDriver;
 }
 
 // src/pageObjects/AbstractElementWithParent.ts
-import { By as By3 } from "selenium-webdriver";
 var AbstractElementWithParent = class extends AbstractElement {
-  elementCssSelector;
   parentCssSelector;
   constructor(parentCssSelector, elementCssSelector, driver) {
-    super(driver);
+    super(driver, elementCssSelector);
     this.parentCssSelector = parentCssSelector;
-    this.elementCssSelector = elementCssSelector;
   }
   getFullCssSelector() {
     if (!this.elementCssSelector) {
@@ -143,20 +223,10 @@ var AbstractElementWithParent = class extends AbstractElement {
     }
     return `${this.parentCssSelector} ${this.elementCssSelector}`;
   }
-  async getElement() {
-    return this.driver.findElement(By3.css(this.getFullCssSelector()));
-  }
-  async getAttribute(attr) {
-    const element = await this.getElement();
-    await waitElementIsVisible({
-      element,
-      driver: this.driver,
-      errorMessage: `Element not found: ${this.getFullCssSelector()}`
-    });
-    return await element.getAttribute(attr);
-  }
-  async getClasses() {
-    return await this.getAttribute("class");
+  async isReadonly() {
+    const fieldEl = await this.getElement();
+    const classSting = await fieldEl.getAttribute("class");
+    return classSting.includes(readonlyLocator);
   }
 };
 
@@ -175,8 +245,10 @@ var SubsystemsPanel = class extends AbstractElement {
     super(driver);
     this.header = new SubsystemsPanelHeader("#aside", byTestIdCssSelector("subsystems-panel-title", "span"), this.driver);
   }
-  headerTitle() {
-    return this.header.title().then((el) => el.getText());
+  async headerTitle() {
+    const title = await this.header.title();
+    await wait(async () => await title.getText() != "", this.driver);
+    return title.getText();
   }
 };
 
@@ -213,10 +285,10 @@ var AbstractForm = class extends AbstractPage {
    */
   async exists() {
     try {
-      await wait(elementIsNotPresent(this.containerBy), this.driver);
+      let elements = await this.driver.findElements(this.containerBy);
+      return elements.length > 0;
+    } catch (error) {
       return false;
-    } catch {
-      return true;
     }
   }
   /**
@@ -231,7 +303,7 @@ var AbstractForm = class extends AbstractPage {
       const titleEl2 = await this.driver.findElement(By5.css(`${this.popupContainerCssSelector} .popup-title`));
       return titleEl2.getText();
     }
-    let titleEl = await this.driver.findElement(By5.css(`${this.containerCssSelector} .form-toolbar-name-container`));
+    let titleEl = await this.driver.findElement(By5.className("main-toolbar-form-title"));
     return titleEl.getText();
   }
 };
@@ -239,6 +311,29 @@ var AbstractForm = class extends AbstractPage {
 // 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}`;
+}
+
 // src/pageObjects/elements/Editors/AbstractEditor.ts
 import { By as By6, Key } from "selenium-webdriver";
 
@@ -431,6 +526,7 @@ var TAGS_SELECTOR = ".dx-tag .tag-text";
 var DX_TAG_CONTAINER = "dx-tag-container";
 var DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
 var BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
+var TAG_BOX_LIST_ITEM_SELECTOR = '.dx-tagbox-popup-wrapper .dx-list-item[aria-selected="true"]';
 var TagBox = class extends AbstractDXEditorWithInput {
   constructor(parentCssSelector, elementCssSelector, driver) {
     super(parentCssSelector, elementCssSelector, driver);
@@ -445,21 +541,21 @@ var TagBox = class extends AbstractDXEditorWithInput {
     }
     await this.confirmSelection();
   }
+  async waitOptionSelection() {
+    const option = await this.driver.findElement(By9.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);
+    await this.waitOptionSelection();
     if (value !== lastElement) {
       await inputEl.clear();
     }
   }
   async confirmSelection() {
-    const inputEl = await this.getInputElement();
-    const option = await inputEl.findElement(By9.xpath(XPathHelper.getRoleXpath(SELECT_BOX_ELEMENT_ROLE)));
     const btnOk = await this.driver.findElement(By9.css(BTN_OK_SELECTOR));
-    await wait(async () => {
-      return await option.getAttribute("aria-selected") === "true";
-    }, this.driver);
     await click(btnOk, this.driver);
   }
   async getTagBoxInputValue() {
@@ -469,8 +565,7 @@ var TagBox = class extends AbstractDXEditorWithInput {
     const tags = await this.driver.findElements(By9.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;
   }
@@ -607,25 +702,11 @@ var editorFactory = async (parentCssSelector, elementCssSelector, driver) => {
   throw new Error("Unknown type of editor. Please write ticket to the support");
 };
 
-// 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 createTableId(formName) {
-  return `${"table" /* TABLE */}-${formName}`;
-}
-
-// src/pageObjects/elements/FormField.ts
-var FormField = class extends AbstractElementWithParent {
+// src/pageObjects/elements/AbstractEditor.ts
+var AbstractEditor = class extends AbstractElementWithParent {
   editor;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), driver);
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
   }
   async initEditor() {
     if (!this.editor) {
@@ -676,6 +757,23 @@ var FormField = 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
+var FormField = class extends AbstractEditor {
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), driver);
+  }
 };
 
 // src/pageObjects/elements/Groups/AbstractGroup.ts
@@ -728,6 +826,7 @@ var FormGroup = class extends AbstractElementWithParent {
 // src/pageObjects/elements/Forms/FormEdit.ts
 var FormEdit = class extends AbstractForm {
   saveButtonBy = By12.id("button-save");
+  closeButtonBy = By12.id("button-cancel");
   constructor(driver) {
     super(driver);
     this.popupContainerCssSelector = `.popup .form-edit-${this.formName}`;
@@ -776,12 +875,26 @@ 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 By16 } from "selenium-webdriver";
+import { By as By17 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Row.ts
+import { By as By15 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Table/elements/Cell.ts
 import { By as By14 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/utils.ts
@@ -791,6 +904,7 @@ function getCssRowByIndexSelector(index) {
 }
 var getColumnByIndexCssSelector = (columnIndex) => `td[aria-colindex="${transformInputIndex(columnIndex)}"]`;
 var getColumnByCaptionCssSelector = (caption) => `td[role="columnheader"][aria-label="Column ${caption}"]`;
+var getColumnByNameCssSelector = (name) => `td[role="columnheader"][data-fieldname="${name}"]`;
 function getCssCellByIndexSelector(index) {
   return `td[role="gridcell"][aria-colindex="${transformInputIndex(index)}"]`;
 }
@@ -810,6 +924,10 @@ var Cell = class extends AbstractElementWithParent {
     this._index = index;
     this.elementCssSelector = getCssCellByIndexSelector(index);
   }
+  async getBooleanValue(cellEl) {
+    const booleanEl = await cellEl.findElement(By14.className("boolean-widget"));
+    return await booleanEl.getAttribute("aria-checked") === "true" ? 1 : 0;
+  }
   async getElement() {
     if (this._index == null) {
       this.index = await this.getCellIndex();
@@ -818,6 +936,10 @@ var Cell = class extends AbstractElementWithParent {
   }
   async getValue() {
     const cellEl = await this.getElement();
+    const cellElClass = await cellEl.getAttribute("class");
+    if (cellElClass.includes("boolean-column")) {
+      return this.getBooleanValue(cellEl);
+    }
     return cellEl.getText();
   }
   getIndex() {
@@ -831,22 +953,25 @@ var DX_ROW_EDIT_CLASS = "dx-edit-row";
 var DX_DATA_ROW_CLASS = "dx-data-row";
 var Row = class extends AbstractElementWithParent {
   index;
-  getColumnByCaption;
-  constructor(parentCssSelector, index, driver, getColumnByCaption) {
+  getColumnBy;
+  constructor(parentCssSelector, index, driver, getColumnBy) {
     super(parentCssSelector, getCssRowByIndexSelector(index), driver);
     this.index = index;
-    this.getColumnByCaption = getColumnByCaption;
+    this.getColumnBy = getColumnBy;
   }
-  _getCell(index, caption) {
+  _getCell({ index, name, title }) {
     return new Cell(this.getFullCssSelector(), () => {
-      return this.getColumnByCaption(caption).getIndex();
+      return this.getColumnBy({ title, name }).getIndex();
     }, index, this.driver);
   }
   getCellByIndex(index) {
-    return this._getCell(index);
+    return this._getCell({ index });
   }
-  getCell(caption) {
-    return this._getCell(void 0, caption);
+  getCell(name) {
+    return this._getCell({ name });
+  }
+  getCellByTitle(title) {
+    return this._getCell({ title });
   }
   async select() {
     const rowEl = await this.getElement();
@@ -864,7 +989,7 @@ var Row = class extends AbstractElementWithParent {
     return this.index;
   }
   async getCells() {
-    const cells = await this.driver.findElements(By14.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
+    const cells = await this.driver.findElements(By15.css(`${this.getFullCssSelector()} td[role="gridcell"]`));
     const result = [];
     cells.forEach((_, index) => {
       const newCell = this.getCellByIndex(index);
@@ -875,7 +1000,7 @@ 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(By14.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`));
+    const button = await this.driver.findElement(By15.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`));
     return click(button, this.driver);
   }
   async checkEditingMode(isEditing, msg) {
@@ -898,15 +1023,17 @@ var Row = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Table/elements/Column.ts
-import { By as By15 } from "selenium-webdriver";
+import { By as By16 } from "selenium-webdriver";
 var getHeaderCssSelector = () => {
   return ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
 };
 var Column = class extends AbstractElementWithParent {
   _index;
   _caption;
-  constructor(parentCssSelector, caption, index, driver) {
+  _name;
+  constructor({ parentCssSelector, name, caption, index, driver }) {
     super(parentCssSelector, "", driver);
+    this._name = name;
     this.index = index;
     this._caption = caption;
   }
@@ -921,19 +1048,33 @@ var Column = class extends AbstractElementWithParent {
     await this.getIndex();
     return super.getElement();
   }
-  async getIndexByCaption() {
-    const column = await this.driver.findElement(By15.css(`${this.parentCssSelector} ${getHeaderCssSelector()} ${getColumnByCaptionCssSelector(this._caption)}`));
+  async getColumnHeaderIndexBy(cssSelector) {
+    const column = await this.driver.findElement(By16.css(`${this.parentCssSelector} ${getHeaderCssSelector()} ${cssSelector}`));
     return transformOutputIndex(await column.getAttribute("aria-colindex"));
   }
+  async getIndexByCaption() {
+    return this.getColumnHeaderIndexBy(getColumnByCaptionCssSelector(this._caption));
+  }
+  async getIndexByName() {
+    return this.getColumnHeaderIndexBy(getColumnByNameCssSelector(this._name));
+  }
   async caption() {
     const el = await this.getElement();
     return el.getText();
   }
   async getIndex() {
-    if (this.index == null) {
+    if (this.index != null) {
+      return this.index;
+    }
+    if (this._caption != null) {
       this.index = await this.getIndexByCaption();
+      return this.index;
     }
-    return this.index;
+    if (this._name != null) {
+      this.index = await this.getIndexByName();
+      return this.index;
+    }
+    throw new Error("Cant get the index in the column");
   }
 };
 
@@ -944,32 +1085,57 @@ var Table = class extends AbstractElementWithParent {
     super(parentCssSelector, `#${createTableId(formName)}`, driver);
     this.formName = formName;
   }
+  getColumnBy = (args) => {
+    if (args.title) {
+      return this.getColumnByTitle(args.title);
+    }
+    return this.getColumnByName(args.name);
+  };
   getRowByIndex(index) {
-    return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnByCaption.bind(this));
+    return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
   }
   getColumnByIndex(index) {
-    return new Column(this.getFullCssSelector(), void 0, index, this.driver);
+    return new Column({
+      parentCssSelector: this.getFullCssSelector(),
+      driver: this.driver,
+      index
+    });
   }
-  getColumnByCaption = (caption) => {
-    return new Column(this.getFullCssSelector(), caption, void 0, this.driver);
+  getColumnByTitle = (title) => {
+    return new Column({
+      parentCssSelector: this.getFullCssSelector(),
+      caption: title,
+      driver: this.driver
+    });
+  };
+  getColumnByName = (name) => {
+    return new Column({
+      parentCssSelector: this.getFullCssSelector(),
+      name,
+      driver: this.driver
+    });
   };
   selectRowByIndex(index) {
     return this.getRowByIndex(index).select();
   }
   async getRows() {
-    const rows = await this.driver.findElements(By16.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
+    const rows = await this.driver.findElements(By17.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
     const result = [];
     rows.forEach((_, index) => {
-      const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnByCaption);
+      const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
       result.push(newRow);
     });
     return result;
   }
   async getColumns() {
-    const columns = await this.driver.findElements(By16.css(`${this.getFullCssSelector()} ${getHeaderCssSelector()} td[role="columnheader"]`));
+    const columns = await this.driver.findElements(By17.css(`${this.getFullCssSelector()} ${getHeaderCssSelector()} td[role="columnheader"]`));
     const result = [];
     columns.forEach((_, index) => {
-      const newCol = new Column(this.getFullCssSelector(), void 0, index, this.driver);
+      const newCol = new Column({
+        parentCssSelector: this.getFullCssSelector(),
+        index,
+        driver: this.driver
+      });
       result.push(newCol);
     });
     return result;
@@ -989,19 +1155,16 @@ var Table = class extends AbstractElementWithParent {
   }
 };
 
-// src/pageObjects/elements/TableToolbar/TableToolbarButton.ts
-var TOOLBAR_BUTTON_CLASS = "toolbar-button";
-var TableToolbarButton = class extends AbstractElementWithParent {
-  name;
-  constructor(parentCssSelector, name, driver) {
-    super(parentCssSelector, `#${TOOLBAR_BUTTON_CLASS}-${name}`, driver);
-    this.name = name;
+// 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, `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`);
+    }, this.driver, this.buttonNotDisplayedError());
     await click(button, this.driver);
   }
   async isDisabled() {
@@ -1010,14 +1173,289 @@ var TableToolbarButton = class extends AbstractElementWithParent {
   }
 };
 
-// src/pageObjects/elements/TableToolbar/TableToolbar.ts
+// src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
+var ToolbarGroupButton = class extends AbstractButton {
+  name;
+  constructor(parentCssSelector, name, driver) {
+    super(parentCssSelector, ``, driver);
+    this.name = name;
+  }
+  buttonNotDisplayedError() {
+    return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+};
+
+// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
+var TOOLBAR_BUTTON_CLASS = "toolbar-button";
+var ToolbarButton = class extends AbstractButton {
+  name;
+  constructor(parentCssSelector, name, driver) {
+    super(parentCssSelector, `#${TOOLBAR_BUTTON_CLASS}-${name}`, driver);
+    this.name = name;
+  }
+  buttonNotDisplayedError() {
+    return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+};
+
+// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
+import { By as By18 } 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 dropdown.click();
+  }
+  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 wait(async () => {
+      return await toolbarMenuItem.isDisplayed();
+    }, this.driver, this.buttonNotDisplayedError(name));
+    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 = By18.xpath(buttonByTextXpath(title));
+      await this.goToButton(title, selector);
+    }
+    if (isArray(title)) {
+      for (let t of title) {
+        const selector = By18.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;
+  _formName;
+  _itemName;
+  constructor(parentCssSelector, formName, itemName, driver) {
+    super(parentCssSelector, toolbarItemSelector(formName, itemName), driver);
+    this._itemName = itemName;
+    this._formName = formName;
+  }
+  async init() {
+    if (this._button)
+      return this._button;
+    const classNames = await this.getClasses();
+    if (classNames.includes(GROUP_BUTTON_CLASS)) {
+      this._button = new ToolbarGroupButton(this.getFullCssSelector(), this._itemName, this.driver);
+      return;
+    }
+    this._button = new ToolbarButton(this.parentCssSelector, this._itemName, this.driver);
+  }
+  async click() {
+    await this.init();
+    await this._button.click();
+  }
+  async isDisabled() {
+    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
 var TABLE_TOOLBAR_CLASS = "d5-table-toolbar";
-var TableToolbar = class extends AbstractElementWithParent {
+var FormToolbar = class extends AbstractElementWithParent {
+  formName;
   constructor(parentCssSelector, formName, driver) {
     super(parentCssSelector, `#${TABLE_TOOLBAR_CLASS}-${formName}`, driver);
+    this.formName = formName;
   }
   button(name) {
-    return new TableToolbarButton(this.getFullCssSelector(), name, this.driver);
+    return new ToolbarItem(this.getFullCssSelector(), this.formName, name, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Filters/FormFilterField.ts
+var FormFilterField = class extends AbstractEditor {
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), driver);
+  }
+  /**
+   * Возвращает значение в поле
+   * @example
+   * expect(await form.formFilter('NumberFld').getValue()).toBe(10);
+   * expect(await form.formFilter('TextFld').getValue()).toBe('TestValue');
+   */
+  async getValue() {
+    return super.getValue();
+  }
+  /**
+   * Устанавливает значение в поле
+   * @example
+   * await form.formFilter('NumberFld').setValue(123);
+   * await form.formFilter('TextFld').setValue('TestValue');
+   */
+  async setValue(value) {
+    return super.setValue(value);
+  }
+  /**
+   * Очищает значение в поле
+   * @example
+   * await form.formFilter('NumberFld').clear();
+   */
+  async clear() {
+    return super.clear();
+  }
+  /**
+   * Удаляет тег по переданному тексту
+   * @example
+   * await form.formFilter('TagBox').remove('test');
+   */
+  async remove(itemText) {
+    return super.remove(itemText);
+  }
+};
+
+// src/pageObjects/elements/Filters/FilterPanel.ts
+import { By as By19 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Filters/PanelFilterField.ts
+var PanelFilterField = class extends AbstractEditor {
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), driver);
+  }
+  /**
+   * Возвращает значение в поле
+   * @example
+   * expect(await form.filterPanel.filterField('NumberFld').getValue()).toBe(10);
+   * expect(await form.filterPanel.filterField('TextFld').getValue()).toBe('TestValue');
+   */
+  async getValue() {
+    return super.getValue();
+  }
+  /**
+   * Устанавливает значение в поле
+   * @example
+   * await form.filterPanel.filterField('NumberFld').setValue(123);
+   * await form.filterPanel.filterField('TextFld').setValue('TestValue');
+   */
+  async setValue(value) {
+    return super.setValue(value);
+  }
+  /**
+   * Очищает значение в поле
+   * @example
+   * await form.filterPanel.filterField('NumberFld').clear();
+   */
+  async clear() {
+    return super.clear();
+  }
+  /**
+   * Удаляет тег по переданному тексту
+   * @example
+   * await form.filterPanel.filterField('TagBox').remove('test');
+   */
+  async remove(itemText) {
+    return super.remove(itemText);
+  }
+};
+
+// src/pageObjects/elements/Filters/FilterPanel.ts
+var drawerSelector = (formName) => `.secondary-drawer-side-panel.form-${formName}`;
+var FILTER_PANEL_SELECTOR = ".filter-panel";
+var CLOSE_SELECTOR = ".button-close";
+var FilterPanel = class extends AbstractElement {
+  _formName;
+  get filterPanelSelector() {
+    return `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR}`;
+  }
+  async filterPanelButtons() {
+    const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
+    const el = await this.getElement();
+    return el.findElements(By19.css(selector));
+  }
+  constructor(formName, driver) {
+    super(driver, drawerSelector(formName));
+    this._formName = formName;
+  }
+  /**
+   * Возвращает фильтр на панели фильтрации
+   * @returns {PanelFilterField}
+   * @example
+   * await form.filterPanel.filterField('NumberFld');
+   */
+  filterField(name) {
+    return new PanelFilterField(this.filterPanelSelector, this._formName, name, this.driver);
+  }
+  async apply() {
+    const btn = await this.findButtonByTitle("\u0417\u0430\u0441\u0442\u043E\u0441\u0443\u0432\u0430\u0442\u0438");
+    await click(btn, this.driver);
+  }
+  async findButtonByTitle(title) {
+    const buttons = await this.filterPanelButtons();
+    for (const btn of buttons) {
+      if (await btn.getText() === title) {
+        return btn;
+      }
+    }
+  }
+  async clearAll() {
+    const btn = await this.findButtonByTitle("\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u0438");
+    await click(btn, this.driver);
+    await this.driver.sleep(300);
+  }
+  async close() {
+    const btn = await this.driver.findElement(By19.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+    await click(btn, this.driver);
   }
 };
 
@@ -1055,70 +1493,89 @@ var ListForm = class extends AbstractForm {
    * expect(listForm.toolbarButton());
    */
   toolbarButton(name) {
-    const toolbar = new TableToolbar(this.containerCssSelector, this.formName, this.driver);
+    const toolbar = new FormToolbar(this.containerCssSelector, this.formName, this.driver);
     return toolbar.button(name);
   }
+  /**
+   * Фильтр который расположен на форме
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(listForm.formFilter());
+   */
+  formFilter(name) {
+    return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
+  }
+  /**
+   * Модель панели фильтрации
+   * @returns {FilterPanel}
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(listForm.filterPanel());
+   */
+  get filterPanel() {
+    return new FilterPanel(this.formName, this.driver);
+  }
 };
 
-// src/utils/signIn.ts
-async function signIn(driver) {
-  const webDriver = driver ?? await createDriver();
-  config().driver = webDriver;
-  const loginPage = new LoginPage(webDriver);
-  await loginPage.locate();
-  await loginPage.authorize();
-  return webDriver;
-}
-
-// src/utils/actions.ts
-var click = async (webElement, driver) => {
-  driver = driver ?? config().driver;
-  const actions = driver.actions({ async: true });
-  await actions.move({ origin: webElement }).click().perform();
+// src/pageObjects/elements/Dialog.ts
+import { By as By20 } 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(By20.xpath(buttonByTextXpath2(this.text)));
+  }
+  buttonNotDisplayedError() {
+    return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
+  }
 };
-
-// src/pageObjects/pages/LoginPage.ts
-var LOGIN_PATH = "/login";
-var LoginPage = class extends AbstractPage {
-  usernameField = byTestId("loginField", "input");
-  passwordField = byTestId("passwordField", "input");
-  loginButton = byTestId("loginButton");
-  async locate() {
-    await super.locate();
-    const login = await this.driver.findElement(this.usernameField);
-    await waitElementIsVisible({
-      element: login,
-      driver: this.driver
-    });
+var Dialog = class extends AbstractElement {
+  constructor(driver) {
+    super(driver, DIALOG_CLASS);
   }
-  get path() {
-    return LOGIN_PATH;
+  get titleSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TITLE_CLASS]);
   }
-  async enterUsername(username) {
-    await this.driver.findElement(this.usernameField).sendKeys(username);
+  get textSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_TEXT_CLASS]);
   }
-  async enterPassword(password) {
-    await this.driver.findElement(this.passwordField).sendKeys(password);
+  get buttonsSelector() {
+    return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
   }
-  async clickLoginButton() {
-    await click(await this.driver.findElement(this.loginButton), this.driver);
+  async title() {
+    const el = await this.driver.findElement(By20.css(this.titleSelector));
+    return await el.getText();
   }
-  async loginWith(username, password) {
-    await this.enterUsername(username);
-    await this.enterPassword(password);
-    await this.clickLoginButton();
+  async text() {
+    const el = await this.driver.findElement(By20.css(this.textSelector));
+    return await el.getText();
   }
-  async authorize() {
-    await this.loginWith(config().auth.login, config().auth.password);
+  button(text) {
+    return new DialogButton(this.buttonsSelector, text, this.driver);
   }
 };
 export {
   AbstractPage,
+  Dialog,
+  FilterPanel,
   FormEdit,
   FormField,
+  FormFilterField,
   ListForm,
   LoginPage,
   NumberEditor,
+  PanelFilterField,
   SubsystemsPanel,
   TextEditor,
   byTestId,
@@ -1128,6 +1585,7 @@ export {
   createDriver,
   editorFactory,
   elementIsNotPresent,
+  readonlyLocator,
   signIn,
   wait,
   waitElementIsVisible