d5-testing-library 1.8.0-alpha.12 → 1.8.0-alpha.14

package/dist/FormEdit-6DS2QEWW.mjs

@@ -0,0 +1,7 @@
+import {
+  FormEdit
+} from "./chunk-SR3FJAYB.mjs";
+import "./chunk-I42Z72TQ.mjs";
+export {
+  FormEdit as default
+};

package/dist/ListForm-MS7U6ME7.mjs

@@ -0,0 +1,7 @@
+import {
+  ListForm
+} from "./chunk-JLEBXO5Q.mjs";
+import "./chunk-I42Z72TQ.mjs";
+export {
+  ListForm as default
+};

package/dist/TreeView-DGKYMM67.mjs

@@ -0,0 +1,8 @@
+import {
+  TreeView
+} from "./chunk-WYLPCDA5.mjs";
+import "./chunk-JLEBXO5Q.mjs";
+import "./chunk-I42Z72TQ.mjs";
+export {
+  TreeView as default
+};

package/dist/{chunk-NAFA4MCF.mjs → chunk-I42Z72TQ.mjs}

@@ -150,6 +150,14 @@ var click = async (webElement, driver) => {
   const actions = driver.actions({ async: true });
   await actions.move({ origin: webElement }).click().perform();
 };
+var contextMenu = 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 }).contextClick().perform();
+};
 
 // src/utils/locators.ts
 import { By as By2 } from "selenium-webdriver";
@@ -548,37 +556,44 @@ var BaseDateEditor = class extends AbstractDXEditorWithInput {
     super(parentCssSelector, elementCssSelector, driver);
     this.setClearStrategy(new InputClearStrategy());
   }
-  async setDateValue(value) {
+  async setArrayValue(value) {
     const actions = this.driver.actions({ async: true });
     const dateField = await this.driver.findElement(By8.css(`${this.getFullCssSelector()}`));
+    const dateInputEl = await this.getInputElement();
     const dateFieldDataTestID = await this.getDataTestId();
-    const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
+    const formattedDates = value.map(formatDMYDate);
+    const button = await dateField.findElement(By8.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+    await click(button, this.driver);
+    const calendarPopoverElement = await this.driver.findElement(By8.css(byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`)));
+    const dateFromInput = await calendarPopoverElement.findElement(
+      By8.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`)
+    );
+    const dateToInput = await calendarPopoverElement.findElement(
+      By8.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`)
+    );
+    await click(dateFromInput, this.driver);
+    await dateFromInput.sendKeys(formattedDates[0]);
+    await click(dateToInput, this.driver);
+    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(By8.css(`.${BTN_SAVE_SELECTOR}`));
+    await click(btnOk, this.driver);
+  }
+  async setSingleValue(value) {
+    const actions = this.driver.actions({ async: true });
+    const formattedDate = formatDMYDate(value);
     const dateInputEl = await this.getInputElement();
-    await dateInputEl.clear();
+    await click(dateInputEl, this.driver);
+    await actions.move({ origin: dateInputEl }).sendKeys(Key3.HOME).perform();
+    await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, Key3.ENTER).perform();
+  }
+  async setDateValue(value) {
+    await this.clear();
     if (Array.isArray(value)) {
-      const formattedDates = value.map(formatDMYDate);
-      const button = await dateField.findElement(By8.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
-      await button.click();
-      const calendarPopoverElement = await this.driver.findElement(By8.css(calendarPopoverSelector));
-      const dateFromInput = await calendarPopoverElement.findElement(
-        By8.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`)
-      );
-      const dateToInput = await calendarPopoverElement.findElement(
-        By8.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(By8.css(`.${BTN_SAVE_SELECTOR}`));
-      await btnOk.click();
+      await this.setArrayValue(value);
     } 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();
+      await this.setSingleValue(value);
     }
   }
 };
@@ -641,15 +656,14 @@ var DateRangeEditor = class extends BaseDateEditor {
 // 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 init() {
+    if (this.editorInstance) {
+      return this.editorInstance;
+    }
+    await this.setEditorInstance();
   }
-  async updateEditorInstance(parentCssSelector, elementCssSelector, driver) {
+  async setEditorInstance() {
+    const { parentCssSelector, elementCssSelector, driver } = this;
     const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
     const classString = await elementInstance.getClasses();
     switch (true) {
@@ -663,25 +677,14 @@ var DateEditor = class extends AbstractDXEditorWithInput {
         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.");
+    await this.init();
+    await this.editorInstance.setValue(value);
+    await this.setEditorInstance();
   }
   async getValue() {
-    await this.ensureInitialized();
-    if (this.editorInstance) {
-      return this.editorInstance.getValue();
-    }
-    throw new Error("Editor instance is not initialized.");
+    await this.init();
+    return this.editorInstance.getValue();
   }
 };
 
@@ -841,17 +844,19 @@ function createEditorButtonTestId(itemName) {
 
 // src/utils/waitElementIsClickable.ts
 async function waitElementIsClickable({
-  element,
   timeout,
   errorMessage,
-  driver
+  driver,
+  ...rest
 }) {
   driver = driver ?? config().driver;
   await wait(async () => {
-    const isDisabled = await element.getCssValue("pointer-events") === "none";
-    return await element.isDisplayed() && !isDisabled;
+    const searchedElement = "by" in rest ? await fixElementStaleError(rest.by, driver) : rest.element;
+    const isDisabled = await searchedElement.getCssValue("pointer-events") === "none";
+    return await searchedElement.isDisplayed() && !isDisabled;
   }, driver, errorMessage, timeout ?? config().timeout);
 }
+var waitElementIsClickable_default = waitElementIsClickable;
 
 // src/pageObjects/elements/EditorButton.ts
 var EditorButton = class extends AbstractElementWithParent {
@@ -865,7 +870,7 @@ var EditorButton = class extends AbstractElementWithParent {
   }
   async click() {
     const button = await this.getElement();
-    await waitElementIsClickable({
+    await waitElementIsClickable_default({
       element: button,
       errorMessage: this.buttonNotDisplayedError(),
       driver: this.driver
@@ -969,14 +974,14 @@ var FormField = class extends AbstractEditor {
 // src/pageObjects/elements/Forms/Form.ts
 import { By as By15 } from "selenium-webdriver";
 
-// src/pageObjects/elements/TableToolbar/AbstractButton.ts
+// src/pageObjects/elements/AbstractButton.ts
 var AbstractButton = class extends AbstractElementWithParent {
   constructor(parentCssSelector, elementCssSelector, driver) {
     super(parentCssSelector, elementCssSelector, driver);
   }
   async click() {
     const button = await this.getElement();
-    await waitElementIsClickable({
+    await waitElementIsClickable_default({
       element: button,
       errorMessage: this.buttonNotDisplayedError(),
       driver: this.driver
@@ -1259,15 +1264,15 @@ async function classDependencyInjector(formType) {
   let SubFormFactoryClass;
   switch (formType) {
     case "1" /* LIST */:
-      SubFormFactoryClass = (await import("./ListForm-3HJGPSX3.mjs")).default;
+      SubFormFactoryClass = (await import("./ListForm-MS7U6ME7.mjs")).default;
       break;
     case "3" /* TREE */:
-      SubFormFactoryClass = (await import("./TreeView-NDBZ6ZAP.mjs")).default;
+      SubFormFactoryClass = (await import("./TreeView-DGKYMM67.mjs")).default;
       break;
     case "2" /* EDIT */:
     case "99" /* FREE_FORM */:
     case "4" /* REPORT */:
-      SubFormFactoryClass = (await import("./FormEdit-WIXYJKA7.mjs")).default;
+      SubFormFactoryClass = (await import("./FormEdit-6DS2QEWW.mjs")).default;
       break;
     default:
       throw new Error(`Unsupported form type ${formType}`);
@@ -1349,6 +1354,7 @@ export {
   wait,
   waitElementIsVisible,
   click,
+  contextMenu,
   byTestIdCssSelector,
   byTestId,
   readonlyLocator,
@@ -1363,7 +1369,7 @@ export {
   createLayoutFilterTestId,
   createTableId,
   createSubSystemTestId,
-  waitElementIsClickable,
+  waitElementIsClickable_default,
   AbstractButton,
   AbstractEditor,
   FormField,

package/dist/{chunk-HPGRT5LR.mjs → chunk-JLEBXO5Q.mjs}

@@ -8,18 +8,19 @@ import {
   byTestId,
   byTestIdCssSelector,
   click,
+  contextMenu,
   createDocFilterTestId,
   createHeaderFilterTestId,
   createLayoutFilterTestId,
   createTableId,
   fixElementStaleError,
   wait,
-  waitElementIsClickable,
+  waitElementIsClickable_default,
   waitElementIsVisible
-} from "./chunk-NAFA4MCF.mjs";
+} from "./chunk-I42Z72TQ.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";
@@ -124,6 +125,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;
@@ -265,16 +273,141 @@ var Column = class extends AbstractElementWithParent {
   }
 };
 
+// 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/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 clickItemByPath(path, getBy) {
+    let pathList = isString(path) ? [path] : path;
+    for (let text of pathList) {
+      await this.clickItemBy(this.buttonNotDisplayedError(text), getBy(text));
+    }
+  }
+  clickButton(name) {
+    return this.clickItemByPath(name, this.getButtonNameBy.bind(this));
+  }
+  clickButtonByTitle(title) {
+    return this.clickItemByPath(title, this.getButtonTitleBy.bind(this));
+  }
+  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({
+        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;
   }
@@ -284,10 +417,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,
@@ -310,12 +451,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(
@@ -331,7 +476,7 @@ var Table = class extends AbstractElementWithParent {
   }
   async getColumns() {
     const columns = await this.driver.findElements(
-      By5.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
+      By6.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
     );
     const result = [];
     columns.forEach((_, index) => {
@@ -357,6 +502,50 @@ 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
@@ -384,76 +573,57 @@ var ToolbarButton = class extends AbstractButton {
   }
 };
 
-// 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";
-};
-var isString = function(object) {
-  return typeof object === "string";
+// 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);
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
 var SPINDOWN_CLASS = ".dx-icon-spindown";
-var CONTEXT_MENU_CLASS = "dx-context-menu";
 var buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
 var getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
-var buttonByTextXpath = (text) => `//div[contains(@class, '${CONTEXT_MENU_CLASS}')]//span[contains(@class, 'dx-menu-item-text') and 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();
     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));
-    }
+    await super.clickButton(name);
   }
   async clickButtonByTitle(title) {
-    await this.openDropdownMenu();
     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)));
-    }
+    await super.clickButtonByTitle(title);
   }
 };
 
@@ -542,7 +712,7 @@ 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
@@ -1051,16 +1221,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;
   }
   /**
    * Находит таблицу
@@ -1071,12 +1244,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
+      }
     );
   }
   /**