d5-testing-library 1.8.0-alpha.9 → 1.8.0

package/dist/{chunk-4JWY3XDX.mjs → chunk-S62QEWWA.mjs}

@@ -8,18 +8,20 @@ import {
   byTestId,
   byTestIdCssSelector,
   click,
+  contextMenu,
   createDocFilterTestId,
   createHeaderFilterTestId,
   createLayoutFilterTestId,
   createTableId,
   fixElementStaleError,
-  wait,
-  waitElementIsClickable,
-  waitElementIsVisible
-} from "./chunk-R3BWDLN3.mjs";
+  safeWait,
+  staleElementAction,
+  waitElementIsClickable_default,
+  waitElementIsVisible_default
+} from "./chunk-32KSAOFJ.mjs";
 
 // src/pageObjects/elements/Table/Table.ts
-import { By as By5 } from "selenium-webdriver";
+import { By as By6 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Row.ts
 import { By as By3 } from "selenium-webdriver";
@@ -45,7 +47,7 @@ var transformOutputIndex = (index) => +index - 1;
 var Cell = class extends AbstractElementWithParent {
   _index;
   getCellIndex;
-  constructor(parentCssSelector, getCellIndex, index, driver) {
+  constructor(parentCssSelector, getCellIndex, driver, index) {
     super(parentCssSelector, getCssCellByIndexSelector(index), driver);
     this.getCellIndex = getCellIndex;
     this._index = index;
@@ -65,7 +67,30 @@ var Cell = class extends AbstractElementWithParent {
     for (const tag of tags) {
       values.push(await tag.getAttribute("textContent"));
     }
-    return values;
+    return values.length ? values : null;
+  }
+  async getNumberValue(cellEl) {
+    const value = (await cellEl.getText()).trim();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  async getDateValue(cellEl, cellElClass) {
+    const value = (await cellEl.getText()).trim();
+    if (value === "") return null;
+    const isWithTime = cellElClass.includes("with-time");
+    try {
+      if (isWithTime) {
+        const [datePart, timePart] = value.split(", ");
+        const [day, month, year] = datePart.split(".").map(Number);
+        const [hours, minutes] = timePart.split(":").map(Number);
+        return new Date(Date.UTC(year, month - 1, day, hours, minutes));
+      } else {
+        const [day, month, year] = value.split(".").map(Number);
+        return new Date(Date.UTC(year, month - 1, day));
+      }
+    } catch (error) {
+      console.error(`Error parsing date value "${value}":`, error);
+      return null;
+    }
   }
   async getElement() {
     if (this._index == null) {
@@ -76,11 +101,12 @@ var Cell = class extends AbstractElementWithParent {
   async getValue() {
     const cellEl = await this.getElement();
     const cellElClass = await cellEl.getAttribute("class");
-    if (cellElClass.includes("boolean-column" /* Boolean */))
-      return this.getBooleanValue(cellEl);
-    if (cellElClass.includes("tags-column" /* Tags */))
-      return this.getTagsValue(cellEl);
-    return cellEl.getText();
+    if (cellElClass.includes("boolean-column" /* Boolean */)) return this.getBooleanValue(cellEl);
+    if (cellElClass.includes("tags-column" /* Tags */)) return this.getTagsValue(cellEl);
+    if (cellElClass.includes("number-column" /* Number */)) return this.getNumberValue(cellEl);
+    if (cellElClass.includes("date-column" /* Date */)) return this.getDateValue(cellEl, cellElClass);
+    const cellText = await cellEl.getText();
+    return cellText == "" ? null : cellText;
   }
   getIndex() {
     return this._index;
@@ -95,6 +121,13 @@ var Row = class extends AbstractElementWithParent {
   index;
   getColumnBy;
   fixedTableContentCssSelector;
+  /**
+   * @param parentCssSelector
+   * @param fixedTableContentCssSelector
+   * @param index починається з 0 (в getCssRowByIndexSelector додається +1)
+   * @param driver
+   * @param getColumnBy
+   */
   constructor(parentCssSelector, fixedTableContentCssSelector, index, driver, getColumnBy) {
     super(parentCssSelector, getCssRowByIndexSelector(index), driver);
     this.index = index;
@@ -107,8 +140,8 @@ var Row = class extends AbstractElementWithParent {
       () => {
         return this.getColumnBy({ title, name }).getIndex();
       },
-      index,
-      this.driver
+      this.driver,
+      index
     );
   }
   getCellByIndex(index) {
@@ -121,9 +154,11 @@ var Row = class extends AbstractElementWithParent {
     return this._getCell({ title });
   }
   async select() {
-    const rowEl = await this.getElement();
-    await click(rowEl, this.driver);
-    await wait(
+    await staleElementAction(async () => {
+      const rowEl = await this.getElement();
+      await click(rowEl, this.driver);
+    });
+    await safeWait(
       async () => {
         const classes = await this.getClasses();
         return classes.includes(DX_SELECTION_CLASS);
@@ -152,14 +187,14 @@ var Row = class extends AbstractElementWithParent {
     const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
       this.index
     )}"] .${buttonClass}`;
-    const button = await fixElementStaleError(
-      By3.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`),
-      this.driver
-    );
-    return click(button, this.driver);
+    const by = By3.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`);
+    await staleElementAction(async () => {
+      const button = await fixElementStaleError(by, this.driver);
+      await click(button, this.driver);
+    });
   }
   async checkEditingMode(isEditing, msg) {
-    await wait(
+    await safeWait(
       async () => {
         return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
       },
@@ -236,16 +271,156 @@ var Column = class extends AbstractElementWithParent {
   }
 };
 
+// src/utils/typesUtil.ts
+import { isObject } from "selenium-webdriver/lib/util";
+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/AbstractDropDownMenuList.ts
+var AbstractDropDownMenuList = class extends AbstractElementWithParent {
+  buttonNotDisplayedError(name) {
+    return `Menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+  async clickItemBy(errorMessage, by) {
+    await waitElementIsClickable_default({
+      errorMessage,
+      driver: this.driver,
+      by
+    });
+    const menuItemElement = await fixElementStaleError(by, this.driver);
+    await click(menuItemElement, this.driver);
+  }
+  async getElementByPath(path, getBy, returnLastElement = false) {
+    let pathList = isString(path) ? [path] : path;
+    let result = null;
+    let index = 1;
+    for (let text of pathList) {
+      if (!returnLastElement || index < pathList.length) {
+        await this.clickItemBy(this.buttonNotDisplayedError(text), getBy(text));
+      } else {
+        result = await fixElementStaleError(getBy(text), this.driver);
+      }
+      index++;
+    }
+    return result;
+  }
+  async clickButton(name) {
+    await this.getElementByPath(name, this.getButtonNameBy.bind(this));
+  }
+  async clickButtonByTitle(title) {
+    await this.getElementByPath(title, this.getButtonTitleBy.bind(this));
+  }
+  getMenuItemElementByTitle(title) {
+    return this.getElementByPath(title, this.getButtonTitleBy.bind(this), true);
+  }
+  getMenuItemElementByName(name) {
+    return this.getElementByPath(name, this.getButtonNameBy.bind(this), true);
+  }
+  isVisible() {
+    return Promise.resolve(true);
+  }
+};
+
+// src/pageObjects/elements/DXContextMenuList.ts
+import { By as By5 } from "selenium-webdriver";
+
+// src/utils/cssToXPath.ts
+function cssClassesToXPath(classNames) {
+  const classNamesList = classNames.split(".").filter((className) => !!className);
+  const chained = classNamesList.map((className) => `contains(@class, "${className}")`).join(" and ");
+  return `[${chained}]`;
+}
+
+// src/pageObjects/elements/DXContextMenuList.ts
+var CONTEXT_MENU_CLASS = "dx-context-menu";
+var CONTEXT_MENU_ITEM_TEXT_CLASS = "dx-menu-item-text";
+var DXContextMenuList = class extends AbstractDropDownMenuList {
+  /**
+   * @param parentCssSelector
+   * @param classNames - Список класів. Починається з крапки
+   * @param driver
+   */
+  constructor(parentCssSelector, classNames, driver) {
+    super(parentCssSelector, `.${CONTEXT_MENU_CLASS}${classNames}`, driver);
+  }
+  getButtonTitleBy(title) {
+    const buttonByTextXpath = (text) => `//span[contains(@class, "${CONTEXT_MENU_ITEM_TEXT_CLASS}") and contains(text(), "${text}")]`;
+    const xpath = "//div" + cssClassesToXPath(this.elementCssSelector) + buttonByTextXpath(title);
+    return By5.xpath(xpath);
+  }
+  async isVisible() {
+    try {
+      await waitElementIsVisible_default({
+        element: await this.driver.findElement(By5.css(`.dx-overlay-wrapper .dx-contextmenu`)),
+        driver: this.driver,
+        errorMessage: "Cannot find dropdown element"
+      });
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/pageObjects/elements/Table/elements/ContextMenu.ts
+var ContextMenu = class extends DXContextMenuList {
+  _formName;
+  _initFn;
+  constructor(cssClass, formName, driver) {
+    super("", cssClass, driver);
+    this._formName = formName;
+  }
+  setInit(cb) {
+    this._initFn = cb;
+    return this;
+  }
+  getButtonNameBy(name) {
+    return byTestId(`cm-${this._formName}-${name}`);
+  }
+  async clickButtonByTitle(title) {
+    await this._initFn?.();
+    await super.clickButtonByTitle(title);
+  }
+  async clickButton(name) {
+    await this._initFn?.();
+    await super.clickButton(name);
+  }
+};
+
 // src/pageObjects/elements/Table/Table.ts
 var Table = class extends AbstractElementWithParent {
   formName;
   headerCssSelector;
+  contextMenuCssSelector;
   fixedTableContentCssSelector;
   tableContentCssSelector;
-  constructor(parentCssSelector, headerCssSelector, tableContentCssSelector, fixedTableContentCssSelector, formName, driver) {
+  constructor({
+    parentCssSelector,
+    contextMenuCssSelector,
+    tableContentCssSelector,
+    headerCssSelector,
+    fixedTableContentCssSelector,
+    formName,
+    driver
+  }) {
     super(parentCssSelector, `#${createTableId(formName)}`, driver);
     this.formName = formName;
     this.headerCssSelector = headerCssSelector;
+    this.contextMenuCssSelector = contextMenuCssSelector;
     this.fixedTableContentCssSelector = fixedTableContentCssSelector;
     this.tableContentCssSelector = tableContentCssSelector;
   }
@@ -255,10 +430,18 @@ var Table = class extends AbstractElementWithParent {
     }
     return this.getColumnByName(args.name);
   };
+  /**
+   * Отримати рядок по індексу.
+   * @param index починається з 0
+   */
   getRowByIndex(index) {
     return new Row(this.getFullCssSelector(), this.fixedTableContentCssSelector, index, this.driver, this.getColumnBy);
   }
+  /**
+   * @param index починається з 0
+   */
   getColumnByIndex(index) {
+    this.getRowByIndex(index);
     return new Column({
       parentCssSelector: this.getFullCssSelector(),
       driver: this.driver,
@@ -281,12 +464,16 @@ var Table = class extends AbstractElementWithParent {
       driver: this.driver
     });
   };
+  /**
+   * Вибрати рядок по індексу.
+   * @param index починається з 0
+   */
   selectRowByIndex(index) {
     return this.getRowByIndex(index).select();
   }
   async getRows() {
     const rowsFullCssSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
-    const rows = await this.driver.findElements(By5.css(rowsFullCssSelector));
+    const rows = await this.driver.findElements(By6.css(rowsFullCssSelector));
     const result = [];
     rows.forEach((_, index) => {
       const newRow = new Row(
@@ -302,7 +489,7 @@ var Table = class extends AbstractElementWithParent {
   }
   async getColumns() {
     const columns = await this.driver.findElements(
-      By5.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+      By6.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
     );
     const result = [];
     columns.forEach((_, index) => {
@@ -328,102 +515,227 @@ var Table = class extends AbstractElementWithParent {
   field(name) {
     return new FormField(this.getFullCssSelector(), this.formName, name, this.driver);
   }
+  /**
+   * Возвращает список строк которые выделены
+   * @returns Row[]
+   * @example
+   * const form = new MyForm();
+   * //...
+   * await form.getSelectedRows();
+   */
+  async getSelectedRows() {
+    const rows = await this.getRows();
+    let result = [];
+    for (const row of rows) {
+      if (await row.isSelected()) {
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  /**
+   * Вызывает контекстное меню в области с данными.
+   * @param fieldName - имя поля
+   * @param [rowIndex] - индекс строки. Если значение не передано, то по умолчанию контекстное меню будет вызвано на первой выделенной строке.
+   * @throws {Error} Если нет выделенных строк, то выбросит исключение.
+   * @example
+   * const form = new MyForm();
+   * //...
+   * await form.contextMenu('FieldName').clickButton('OpenFormButton');
+   * // or
+   * await form.contextMenu('FieldName', 3).clickButton(['Group', 'ButtonInGroup']);
+   */
+  contextMenu(fieldName, rowIndex) {
+    return new ContextMenu(this.contextMenuCssSelector, this.formName, this.driver).setInit(async () => {
+      let row;
+      if (rowIndex != null) {
+        row = this.getRowByIndex(rowIndex);
+      } else {
+        [row] = await this.getSelectedRows();
+      }
+      if (!row)
+        throw new Error("No row available row for context menu");
+      const cellElement = await row.getCell(fieldName).getElement();
+      await contextMenu(cellElement, this.driver);
+    });
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
-var ToolbarGroupButton = class extends AbstractButton {
+import { By as By8 } from "selenium-webdriver";
+
+// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
+import { By as By7 } from "selenium-webdriver";
+var TOOLBAR_BUTTON_CLASS = "toolbar-button";
+var TOOLBAR_BUTTON_TEXT_CLASS = "dx-button-text";
+var getToolbarButtonSelector = (name) => `#${TOOLBAR_BUTTON_CLASS}-${name}`;
+var getToolbarButtonTextSelector = (name) => `${getToolbarButtonSelector(name)} .${TOOLBAR_BUTTON_TEXT_CLASS}`;
+var ToolbarButton = class extends AbstractButton {
   name;
   constructor(parentCssSelector, name, driver) {
-    super(parentCssSelector, ``, driver);
+    super(parentCssSelector, getToolbarButtonSelector(name), driver);
     this.name = name;
   }
   buttonNotDisplayedError() {
     return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
   }
+  async getTitle() {
+    try {
+      const buttonTextContainer = await this.driver.findElement(By7.css(getToolbarButtonTextSelector(this.name)));
+      return await buttonTextContainer.getText();
+    } catch (_) {
+      return null;
+    }
+  }
 };
 
-// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
-var TOOLBAR_BUTTON_CLASS = "toolbar-button";
-var ToolbarButton = class extends AbstractButton {
+// src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
+var ToolbarGroupButton = class extends AbstractButton {
   name;
   constructor(parentCssSelector, name, driver) {
-    super(parentCssSelector, `#${TOOLBAR_BUTTON_CLASS}-${name}`, driver);
+    super(parentCssSelector, ``, driver);
     this.name = name;
   }
   buttonNotDisplayedError() {
     return `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
   }
+  async getTitle() {
+    try {
+      const buttonTextContainer = await this.driver.findElement(By8.css(getToolbarButtonTextSelector(this.name)));
+      return await buttonTextContainer.getText();
+    } catch (_) {
+      return null;
+    }
+  }
 };
 
-// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
-import { By as By6 } 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";
+// src/pageObjects/elements/AbstractDropDownMenuButton.ts
+var AbstractDropDownMenuButton = class extends AbstractElementWithParent {
+  _list;
+  constructor(parentCssSelector, elementCssSelector, list, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this._list = list;
+  }
+  async openDropdownMenu() {
+    const dropdown = await this.getElement();
+    await click(dropdown, this.driver);
+    await this._list.isVisible();
+  }
+  async clickButton(name) {
+    await this.openDropdownMenu();
+    await this._list.clickButton(name);
+  }
+  async clickButtonByTitle(title) {
+    await this.openDropdownMenu();
+    await this._list.clickButtonByTitle(title);
+  }
+  async getMenuItemElementByTitle(title) {
+    await this.openDropdownMenu();
+    return await this._list.getMenuItemElementByTitle(title);
+  }
+  async getMenuItemElementByName(name) {
+    await this.openDropdownMenu();
+    return await this._list.getMenuItemElementByName(name);
+  }
 };
-var isString = function(object) {
-  return typeof object === "string";
+
+// src/pageObjects/elements/TableToolbar/ToolbarMenuItem.ts
+var ToolbarMenuItem = class {
+  getMenuItem;
+  name;
+  constructor(getMenuItem, name) {
+    this.getMenuItem = getMenuItem;
+    this.name = name;
+  }
+  async click() {
+    const menuItemElement = await this.getMenuItem(this.name);
+    await menuItemElement.click();
+  }
+  async getTitle() {
+    try {
+      const menuItemElement = await this.getMenuItem(this.name);
+      return await menuItemElement.getText();
+    } catch (_) {
+      return null;
+    }
+  }
+  async isDisabled() {
+    const menuItemElement = await this.getMenuItem(this.name);
+    return await menuItemElement.getCssValue("pointer-events") === "none";
+  }
+  async isDisplayed() {
+    try {
+      const menuItemElement = await this.getMenuItem(this.name);
+      return await menuItemElement.isDisplayed();
+    } catch (_) {
+      return false;
+    }
+  }
 };
 
 // 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 {
+var ToolbarMenuList = class extends DXContextMenuList {
   _formName;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, getFullCssSelector(formName, name), driver);
+  constructor(parentCssSelector, elementCssSelector, formName, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
     this._formName = formName;
   }
-  async openDropdownMenu() {
-    const dropdown = await this.getElement();
-    await click(dropdown, this.driver);
-  }
-  getCssSelectorToButton(name) {
+  getButtonNameBy(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, by) {
-    const toolbarMenuItem = await fixElementStaleError(by, this.driver);
-    await waitElementIsClickable({
-      element: toolbarMenuItem,
-      errorMessage: this.buttonNotDisplayedError(name),
-      driver: this.driver
-    });
-    await click(toolbarMenuItem, this.driver);
+};
+var ToolbarMenu = class extends AbstractDropDownMenuButton {
+  constructor(parentCssSelector, formName, name, driver) {
+    const fullSelector = getFullCssSelector(formName, name);
+    const list = new ToolbarMenuList(parentCssSelector, ".toolbar-dropdown-context-menu", formName, driver);
+    super(parentCssSelector, fullSelector, list, driver);
   }
-  async clickButton(name) {
-    await this.openDropdownMenu();
+  checkNameValue(name) {
     if (!isString(name) && !isArray(name))
       throw new Error(`"name" must be a string or array of string`);
-    let lName = isString(name) ? [name] : name;
-    for (let n of lName) {
-      await this.goToButton(n, this.getCssSelectorToButton(n));
-    }
   }
-  async clickButtonByTitle(title) {
-    await this.openDropdownMenu();
+  checkTitleValue(title) {
     if (!isString(title) && !isArray(title))
       throw new Error(`"title" must be a string or array of string`);
-    let lTitle = isString(title) ? [title] : title;
-    for (let t of lTitle) {
-      await this.goToButton(t, By6.xpath(buttonByTextXpath(t)));
-    }
+  }
+  buttonByName(name) {
+    this.checkNameValue(name);
+    return new ToolbarMenuItem(this.getMenuItemElementByName.bind(this), name);
+  }
+  buttonByTitle(title) {
+    this.checkTitleValue(title);
+    return new ToolbarMenuItem(this.getMenuItemElementByTitle.bind(this), title);
+  }
+  async buttonIsDisplayed(name) {
+    const button = this.buttonByName(name);
+    return await button.isDisplayed();
+  }
+  async buttonByTitleIsDisplayed(title) {
+    const button = this.buttonByTitle(title);
+    return await button.isDisplayed();
+  }
+  async buttonTitle(name) {
+    const button = this.buttonByName(name);
+    return await button.getTitle();
+  }
+  async buttonIsDisabled(name) {
+    const button = this.buttonByName(name);
+    return await button.isDisabled();
+  }
+  async buttonByTitleIsDisabled(title) {
+    const button = this.buttonByTitle(title);
+    return await button.isDisabled();
+  }
+  async clickButton(name) {
+    const button = this.buttonByName(name);
+    await button.click();
+  }
+  async clickButtonByTitle(title) {
+    const button = this.buttonByTitle(title);
+    await button.click();
   }
 };
 
@@ -440,8 +752,7 @@ var ToolbarItem = class extends AbstractElementWithParent {
     this._formName = formName;
   }
   async init() {
-    if (this._button)
-      return this._button;
+    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);
@@ -465,6 +776,10 @@ var ToolbarItem = class extends AbstractElementWithParent {
       return false;
     }
   }
+  async getTitle() {
+    await this.init();
+    return await this._button.getTitle();
+  }
   get menu() {
     return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
   }
@@ -484,7 +799,7 @@ var FormToolbar = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Filters/FilterOperation.ts
-import { By as By7 } from "selenium-webdriver";
+import { By as By9 } from "selenium-webdriver";
 var FILTER_OPERATIONS = [
   "=",
   "<>",
@@ -512,16 +827,16 @@ var FilterOperation = class extends AbstractElementWithParent {
   }
   async initOperationWidget() {
     const widgetButtonEl = await this.getElement();
-    await waitElementIsClickable({
+    await waitElementIsClickable_default({
       element: widgetButtonEl,
       errorMessage: "Widget operation is not clickable",
       driver: this.driver
     });
-    const clickableElement = await widgetButtonEl.findElement(By7.className("dx-icon"));
+    const clickableElement = await widgetButtonEl.findElement(By9.className("dx-icon"));
     await click(clickableElement, this.driver);
     try {
-      const widgetPopupEl = await this.driver.findElement(By7.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
-      await waitElementIsVisible({
+      const widgetPopupEl = await this.driver.findElement(By9.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
+      await waitElementIsVisible_default({
         element: widgetPopupEl,
         errorMessage: `Operation widget popup is not visible`,
         driver: this.driver
@@ -535,13 +850,12 @@ var FilterOperation = class extends AbstractElementWithParent {
       throw new Error(`Operation with name "${operationName}" is not correct.`);
     }
     await this.initOperationWidget();
-    const operationEl = await fixElementStaleError(By7.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)} ${getWidgetInPopupSelector(operationName)}`), this.driver);
+    const operationEl = await fixElementStaleError(By9.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)} ${getWidgetInPopupSelector(operationName)}`), this.driver);
     await click(operationEl, this.driver);
-    await wait(
+    await safeWait(
       async () => {
         const currOperationName = await this.getAttribute("data-operation");
-        if (operationName === "isblank")
-          return true;
+        if (operationName === "isblank") return true;
         return currOperationName === operationName;
       },
       this.driver,
@@ -550,15 +864,14 @@ var FilterOperation = class extends AbstractElementWithParent {
   }
   async getOperation() {
     const result = await this.getAttribute("data-operation");
-    if (!result)
-      throw new Error("Operation not found");
+    if (!result) throw new Error("Operation not found");
     return result;
   }
   async setIsBlank(value) {
     const currValue = await this.getIsBlank();
     if (currValue !== value) {
       await this.setOperation("isblank");
-      await wait(
+      await safeWait(
         async () => {
           const currIsBlank = await this.getIsBlank();
           return currIsBlank === value;
@@ -630,7 +943,8 @@ var FormFilterField = class extends AbstractEditor {
   async initOperation() {
     return new FilterOperation({
       parentCssSelector: this.parentCssSelector,
-      filterTestID: createLayoutFilterTestId(this.formName, this.name)
+      filterTestID: createLayoutFilterTestId(this.formName, this.name),
+      driver: this.driver
     });
   }
   /**
@@ -672,7 +986,7 @@ var FormFilterField = class extends AbstractEditor {
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-import { By as By8 } from "selenium-webdriver";
+import { By as By10 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Filters/PanelFilterField.ts
 var PanelFilterField = class extends AbstractEditor {
@@ -730,7 +1044,8 @@ var PanelFilterField = class extends AbstractEditor {
   async initOperation() {
     return new FilterOperation({
       parentCssSelector: this.parentCssSelector,
-      filterTestID: createDocFilterTestId(this.formName, this.name)
+      filterTestID: createDocFilterTestId(this.formName, this.name),
+      driver: this.driver
     });
   }
   /**
@@ -783,7 +1098,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(By8.css(selector));
+    return el.findElements(By10.css(selector));
   }
   constructor(formName, driver) {
     super(driver, drawerSelector(formName));
@@ -816,13 +1131,13 @@ var FilterPanel = class extends AbstractElement {
     await this.driver.sleep(300);
   }
   async close() {
-    const btn = await this.driver.findElement(By8.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+    const btn = await this.driver.findElement(By10.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
     await click(btn, this.driver);
   }
 };
 
 // src/pageObjects/elements/Filters/ColumnFilter.ts
-import { By as By9 } from "selenium-webdriver";
+import { By as By11 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Filters/HeaderFilterField.ts
 var HeaderFilterField = class extends AbstractEditor {
@@ -862,11 +1177,11 @@ var ColumnFilter = class extends AbstractElement {
   }
   async getApplyButton() {
     const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
-    return this.driver.findElement(By9.css(selector));
+    return this.driver.findElement(By11.css(selector));
   }
   async getCancelButton() {
     const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
-    return this.driver.findElement(By9.css(selector));
+    return this.driver.findElement(By11.css(selector));
   }
   async apply() {
     const btn = await this.getApplyButton();
@@ -880,9 +1195,9 @@ var ColumnFilter = class extends AbstractElement {
     const columnEl = await this._column.getElement();
     const actions = this.driver.actions({ async: true });
     await actions.move({ origin: columnEl }).perform();
-    const elements = await columnEl.findElements(By9.css(HEADER_FILTER_ICON));
+    const elements = await columnEl.findElements(By11.css(HEADER_FILTER_ICON));
     let headerFilterIcon = null;
-    await wait(
+    await safeWait(
       async () => {
         let result = false;
         for (let element of elements) {
@@ -897,12 +1212,11 @@ var ColumnFilter = class extends AbstractElement {
       this.driver,
       `HeaderFilter "${this._name}" is not visible`
     );
-    if (!headerFilterIcon)
-      throw new Error(`HeaderFilter "${this._name}" is not visible`);
-    await headerFilterIcon.click();
+    if (!headerFilterIcon) throw new Error(`HeaderFilter "${this._name}" is not visible`);
+    await click(headerFilterIcon, this.driver);
     const filter = new HeaderFilterField("", this._formName, this._name, this.driver);
     const filterEl = await filter.getElement();
-    await waitElementIsVisible({
+    await waitElementIsVisible_default({
       element: filterEl,
       driver: this.driver,
       errorMessage: `Header filter is not visible`
@@ -930,16 +1244,18 @@ var ColumnFilter = class extends AbstractElement {
    */
   async setValue(value, operation, isBlank) {
     const filter = await this.initFilter();
-    const inputEl = await filter.getElement();
-    await inputEl.click();
     const filterOperation = new FilterOperation({
       parentCssSelector: HEADER_FILTER_CONTAINER,
-      filterTestID: createHeaderFilterTestId(this._formName, this._name)
+      filterTestID: createHeaderFilterTestId(this._formName, this._name),
+      driver: this.driver
     });
+    const inputEl = await filter.getElement();
     if (typeof operation === "string") {
+      await inputEl.click();
       await filterOperation.setOperation(operation);
     }
     if (typeof isBlank === "boolean") {
+      await inputEl.click();
       await filterOperation.setIsBlank(isBlank);
     }
     await filter.setValue(value);
@@ -974,7 +1290,8 @@ var ColumnFilter = class extends AbstractElement {
     await inputEl.click();
     return new FilterOperation({
       parentCssSelector: HEADER_FILTER_CONTAINER,
-      filterTestID: createHeaderFilterTestId(this._formName, this._name)
+      filterTestID: createHeaderFilterTestId(this._formName, this._name),
+      driver: this.driver
     });
   }
   /**
@@ -1021,16 +1338,19 @@ var ColumnFilter = class extends AbstractElement {
 var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
 var DATAGRID_CONTENT_CSS_SELECTOR = ".dx-datagrid-content:not(.dx-datagrid-content-fixed)";
 var FIXED_DATAGRID_CONTENT_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
+var CONTEXT_MENU_CSS_SELECTOR = ".dx-datagrid";
 var ListForm = class extends Form {
   headerCssSelector;
   fixedTableContentCssSelector;
   tableContentCssSelector;
+  contextMenuCssSelector;
   constructor(driver) {
     super(driver);
     this.popupContainerCssSelector = `.popup.form-inline-${this.formName}`;
     this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
     this.fixedTableContentCssSelector = FIXED_DATAGRID_CONTENT_CSS_SELECTOR;
     this.tableContentCssSelector = DATAGRID_CONTENT_CSS_SELECTOR;
+    this.contextMenuCssSelector = CONTEXT_MENU_CSS_SELECTOR;
   }
   /**
    * Находит таблицу
@@ -1041,12 +1361,15 @@ var ListForm = class extends Form {
    */
   table() {
     return new Table(
-      this.containerCssSelector,
-      this.headerCssSelector,
-      this.tableContentCssSelector,
-      this.fixedTableContentCssSelector,
-      this.formName,
-      this.driver
+      {
+        parentCssSelector: this.containerCssSelector,
+        headerCssSelector: this.headerCssSelector,
+        fixedTableContentCssSelector: this.fixedTableContentCssSelector,
+        formName: this.formName,
+        driver: this.driver,
+        contextMenuCssSelector: this.contextMenuCssSelector,
+        tableContentCssSelector: this.tableContentCssSelector
+      }
     );
   }
   /**