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

package/dist/cjs/d5-testing-library.cjs

@@ -34,29 +34,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 function config(cfg) {
   return configInstance.config(cfg);
 }
-var process, driversMap, createConfigProxy, Config, configInstance;
+var Config, configInstance;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
-    process = __toESM(require("process"));
-    driversMap = /* @__PURE__ */ new Map();
-    createConfigProxy = (config2) => {
-      return new Proxy(config2, {
-        get(_target, prop) {
-          if (prop === "driver") {
-            return driversMap.get(process.pid);
-          }
-          return Reflect.get(...arguments);
-        },
-        set(_target, prop, value) {
-          if (prop === "driver") {
-            driversMap.set(process.pid, value);
-            return true;
-          }
-          return Reflect.set(...arguments);
-        }
-      });
-    };
     Config = class _Config {
       static instance;
       appConfig;
@@ -67,8 +48,7 @@ var init_config = __esm({
         return _Config.instance;
       }
       config = (cfg) => {
-        if (!cfg)
-          return createConfigProxy(this.appConfig);
+        if (!cfg) return this.appConfig;
         this.appConfig = cfg;
       };
     };
@@ -80,23 +60,38 @@ var init_config = __esm({
 function fixElementStaleError(by, driver) {
   const maxCount = 3;
   let err;
-  const call = async (times = 0) => {
-    if (times > maxCount)
-      throw err;
+  const call = async (times) => {
+    if (times > maxCount) throw err;
     try {
       let el = await driver.findElement(by);
       await el.getAttribute("class");
       return el;
     } catch (e) {
       err = e;
-      if (e instanceof Error && e.name === "StaleElementReferenceError") {
-        return call(++times);
+      if (e instanceof Error && e.message.toLowerCase().includes("stale element")) {
+        return call(times + 1);
+      }
+    }
+    if (err) throw err;
+  };
+  return call(0);
+}
+async function staleElementAction(action) {
+  const maxCount = 3;
+  let err;
+  const call = async (times) => {
+    if (times > maxCount) throw err;
+    try {
+      await action();
+    } catch (e) {
+      err = e;
+      if (e instanceof Error && e.message.toLowerCase().includes("stale element")) {
+        await call(times + 1);
       }
     }
-    if (err)
-      throw err;
+    if (err) throw err;
   };
-  return call();
+  await call(0);
 }
 var init_fixElementStaleError = __esm({
   "src/utils/fixElementStaleError.ts"() {
@@ -110,13 +105,12 @@ var init_AbstractElement = __esm({
   "src/pageObjects/AbstractElement.ts"() {
     "use strict";
     import_selenium_webdriver = require("selenium-webdriver");
-    init_config();
     init_fixElementStaleError();
     AbstractElement = class {
       driver;
       elementCssSelector;
       constructor(driver, elementCssSelector) {
-        this.driver = driver || config().driver;
+        this.driver = driver;
         this.elementCssSelector = elementCssSelector;
       }
       getFullCssSelector() {
@@ -181,9 +175,17 @@ var init_AbstractPage = __esm({
 
 // src/utils/wait.ts
 async function wait(condition, driver, errorMessage, timeout) {
-  driver = driver ?? config().driver;
   await driver.wait(condition, timeout ?? config().timeout, errorMessage);
 }
+function safeWait(condition, driver, errorMessage, timeout) {
+  return wait(async () => {
+    try {
+      return await condition(driver);
+    } catch {
+      return false;
+    }
+  }, driver, errorMessage, timeout);
+}
 var init_wait = __esm({
   "src/utils/wait.ts"() {
     "use strict";
@@ -193,58 +195,89 @@ var init_wait = __esm({
 
 // src/utils/waitElementIsVisible.ts
 async function waitElementIsVisible({
-  element,
   timeout,
   errorMessage,
-  driver
+  driver,
+  ...rest
 }) {
-  driver = driver ?? config().driver;
-  const condition = import_selenium_webdriver2.until.elementIsVisible(element);
-  await wait(condition.fn, driver, errorMessage ?? condition.description(), timeout ?? config().timeout);
+  await safeWait(async () => {
+    const searchedElement = "by" in rest ? await fixElementStaleError(rest.by, driver) : rest.element;
+    return await searchedElement.isDisplayed();
+  }, driver, errorMessage ?? "Element is not visible", timeout ?? config().timeout);
 }
-var import_selenium_webdriver2;
+var waitElementIsVisible_default;
 var init_waitElementIsVisible = __esm({
   "src/utils/waitElementIsVisible.ts"() {
     "use strict";
-    import_selenium_webdriver2 = require("selenium-webdriver");
     init_config();
     init_wait();
+    init_fixElementStaleError();
+    waitElementIsVisible_default = waitElementIsVisible;
   }
 });
 
 // src/utils/actions.ts
-var click;
+var click, contextMenu;
 var init_actions = __esm({
   "src/utils/actions.ts"() {
     "use strict";
-    init_config();
     click = async (webElement, driver) => {
-      driver = driver ?? config().driver;
       if (!await webElement.isDisplayed()) {
         await driver.executeScript("arguments[0].scrollIntoView(true);", webElement);
       }
       const actions = driver.actions({ async: true });
       await actions.move({ origin: webElement }).click().perform();
     };
+    contextMenu = async (webElement, 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
-var import_selenium_webdriver3, byTestIdCssSelector, byTestId, readonlyLocator;
+var import_selenium_webdriver2, byTestIdCssSelector, byTestId, readonlyLocator;
 var init_locators = __esm({
   "src/utils/locators.ts"() {
     "use strict";
-    import_selenium_webdriver3 = require("selenium-webdriver");
+    import_selenium_webdriver2 = require("selenium-webdriver");
     byTestIdCssSelector = (testId, element = "div") => {
       return `${element}[data-testid="${testId}"]`;
     };
     byTestId = (testId, element = "div") => {
-      return import_selenium_webdriver3.By.css(byTestIdCssSelector(testId, element));
+      return import_selenium_webdriver2.By.css(byTestIdCssSelector(testId, element));
     };
     readonlyLocator = "readonly";
   }
 });
 
+// src/utils/waitElementIsClickable.ts
+async function waitElementIsClickable({
+  timeout,
+  errorMessage,
+  driver,
+  ...rest
+}) {
+  await safeWait(async () => {
+    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;
+var init_waitElementIsClickable = __esm({
+  "src/utils/waitElementIsClickable.ts"() {
+    "use strict";
+    init_config();
+    init_wait();
+    init_fixElementStaleError();
+    waitElementIsClickable_default = waitElementIsClickable;
+  }
+});
+
 // src/pageObjects/AbstractElementWithParent.ts
 var AbstractElementWithParent;
 var init_AbstractElementWithParent = __esm({
@@ -337,8 +370,9 @@ var init_TextEditor = __esm({
         super(parentCssSelector, elementCssSelector, driver);
         this.setClearStrategy(new InputClearStrategy());
       }
-      getValue() {
-        return this.getInputValue();
+      async getValue() {
+        const value = await super.getInputValue();
+        return value == "" ? null : value;
       }
       setValue(value) {
         return this.setInputValue(value);
@@ -417,10 +451,8 @@ var init_CheckBox = __esm({
     CheckBox = class extends AbstractElementWithParent {
       async getValue() {
         const result = await this.getAttribute("aria-checked");
-        if (result === "true")
-          return 1;
-        if (result === "false")
-          return 0;
+        if (result === "true") return 1;
+        if (result === "false") return 0;
         return null;
       }
       async setValue(value) {
@@ -546,10 +578,8 @@ var init_SwitchEditor = __esm({
     SwitchEditor = class extends AbstractElementWithParent {
       async getValue() {
         const result = await this.getAttribute("aria-label");
-        if (result === "ON")
-          return 1;
-        if (result === "OFF")
-          return 0;
+        if (result === "ON") return 1;
+        if (result === "OFF") return 0;
         return null;
       }
       async setValue(value) {
@@ -562,7 +592,7 @@ var init_SwitchEditor = __esm({
           return;
         }
         await click(inputEl, this.driver);
-        await wait(async () => {
+        await safeWait(async () => {
           const updatedValue = await this.getValue();
           return updatedValue !== currentValue;
         }, this.driver);
@@ -583,6 +613,7 @@ var init_TagBox = __esm({
     init_SelectBoxEditor();
     init_ClearButtonStrategy();
     init_fixElementStaleError();
+    init_wait();
     TAGS_SELECTOR = ".dx-tag .tag-text";
     DX_TAG_CONTAINER = "dx-tag-container";
     DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
@@ -603,7 +634,8 @@ var init_TagBox = __esm({
         await this.confirmSelection();
       }
       async waitOptionSelection() {
-        await fixElementStaleError(import_selenium_webdriver10.By.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
+        const option = await fixElementStaleError(import_selenium_webdriver10.By.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
+        await safeWait(() => option.isDisplayed(), this.driver);
       }
       async selectOption(inputEl, value, lastElement) {
         try {
@@ -695,8 +727,7 @@ var init_ButtonGroup = __esm({
             break;
           }
         }
-        if (!buttonEl)
-          throw new Error(`Cannot find item in button group with text: ${value}`);
+        if (!buttonEl) throw new Error(`Cannot find item in button group with text: ${value}`);
         await click(buttonEl, this.driver);
       }
     };
@@ -756,33 +787,35 @@ var init_BaseDateEditor = __esm({
         super(parentCssSelector, elementCssSelector, driver);
         this.setClearStrategy(new InputClearStrategy());
       }
-      async setDateValue(value) {
-        const actions = this.driver.actions({ async: true });
+      async setArrayValue(value) {
         const dateField = await this.driver.findElement(import_selenium_webdriver12.By.css(`${this.getFullCssSelector()}`));
         const dateFieldDataTestID = await this.getDataTestId();
-        const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
-        const dateInputEl = await this.getInputElement();
-        await dateInputEl.clear();
+        const button = await dateField.findElement(import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+        await click(button, this.driver);
+        const calendarPopoverElement = await this.driver.findElement(import_selenium_webdriver12.By.css(byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`)));
+        const dateFromInput = await calendarPopoverElement.findElement(
+          import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`)
+        );
+        const dateToInput = await calendarPopoverElement.findElement(
+          import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`)
+        );
+        await this.setSingleValue(value[0], dateFromInput);
+        await this.setSingleValue(value[1], dateToInput);
+        const btnOk = await this.driver.findElement(import_selenium_webdriver12.By.css(`.${BTN_SAVE_SELECTOR}`));
+        await click(btnOk, this.driver);
+      }
+      async setSingleValue(value, inputEl) {
+        const actions = this.driver.actions({ async: true });
+        const formattedDate = formatDMYDate(value);
+        await click(inputEl, this.driver);
+        await actions.move({ origin: inputEl }).sendKeys(import_selenium_webdriver12.Key.HOME).perform();
+        await actions.move({ origin: inputEl }).sendKeys(formattedDate, import_selenium_webdriver12.Key.ENTER).perform();
+      }
+      async setDateValue(value) {
         if (Array.isArray(value)) {
-          const formattedDates = value.map(formatDMYDate);
-          const button = await dateField.findElement(import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
-          await button.click();
-          const calendarPopoverElement = await this.driver.findElement(import_selenium_webdriver12.By.css(calendarPopoverSelector));
-          const dateFromInput = await calendarPopoverElement.findElement(import_selenium_webdriver12.By.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
-          const dateToInput = await calendarPopoverElement.findElement(import_selenium_webdriver12.By.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(import_selenium_webdriver12.Key.HOME).perform();
-          await dateToInput.sendKeys(formattedDates[1]);
-          await actions.move({ origin: dateInputEl }).sendKeys(import_selenium_webdriver12.Key.ENTER).perform();
-          const btnOk = await this.driver.findElement(import_selenium_webdriver12.By.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(import_selenium_webdriver12.Key.HOME).perform();
-          await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, import_selenium_webdriver12.Key.ENTER).perform();
+          await this.setSingleValue(value, await this.getInputElement());
         }
       }
     };
@@ -873,15 +906,14 @@ var init_DateEditor = __esm({
     init_types();
     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) {
@@ -895,25 +927,14 @@ var init_DateEditor = __esm({
             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();
       }
     };
   }
@@ -1043,16 +1064,12 @@ var init_editorFactory = __esm({
       const classSting = await elementInstance.getClasses();
       if ((classSting.includes("text-control" /* Text */) || classSting.includes("text-area-control" /* TextArea */)) && !classSting.includes("single-date-range-control" /* SingleDateRange */))
         return new TextEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("number-control" /* Number */))
-        return new NumberEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("check-box" /* CheckBox */))
-        return new CheckBox(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("multi-select-control" /* Multiselect */))
-        return new TagBox(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("number-control" /* Number */)) return new NumberEditor(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("check-box" /* CheckBox */)) return new CheckBox(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("multi-select-control" /* Multiselect */)) return new TagBox(parentCssSelector, elementCssSelector, driver);
       if (classSting.includes("select-control" /* Select */))
         return new SelectBoxEditor(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("switch-control" /* Switch */))
-        return new SwitchEditor(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("switch-control" /* Switch */)) return new SwitchEditor(parentCssSelector, elementCssSelector, driver);
       if (classSting.includes("date-control" /* Date */) || classSting.includes("single-date-range-control" /* SingleDateRange */)) {
         return new DateEditor(parentCssSelector, elementCssSelector, driver);
       }
@@ -1118,42 +1135,21 @@ var init_createDataTestId = __esm({
   }
 });
 
-// src/utils/waitElementIsClickable.ts
-async function waitElementIsClickable({
-  element,
-  timeout,
-  errorMessage,
-  driver
-}) {
-  driver = driver ?? config().driver;
-  await wait(async () => {
-    const isDisabled = await element.getCssValue("pointer-events") === "none";
-    return await element.isDisplayed() && !isDisabled;
-  }, driver, errorMessage, timeout ?? config().timeout);
-}
-var init_waitElementIsClickable = __esm({
-  "src/utils/waitElementIsClickable.ts"() {
-    "use strict";
-    init_config();
-    init_wait();
-  }
-});
-
-// src/pageObjects/elements/TableToolbar/AbstractButton.ts
+// src/pageObjects/elements/AbstractButton.ts
 var AbstractButton;
 var init_AbstractButton = __esm({
-  "src/pageObjects/elements/TableToolbar/AbstractButton.ts"() {
+  "src/pageObjects/elements/AbstractButton.ts"() {
     "use strict";
+    init_AbstractElementWithParent();
     init_actions();
     init_waitElementIsClickable();
-    init_AbstractElementWithParent();
     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
@@ -1165,8 +1161,12 @@ var init_AbstractButton = __esm({
         return await button.getCssValue("pointer-events") === "none";
       }
       async isDisplayed() {
-        const button = await this.getElement();
-        return await button.isDisplayed();
+        try {
+          const button = await this.getElement();
+          return await button.isDisplayed();
+        } catch {
+          return false;
+        }
       }
     };
   }
@@ -1210,6 +1210,9 @@ var init_FormButton = __esm({
       buttonNotDisplayedError() {
         return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
       }
+      async getTitle() {
+        return await this.getText();
+      }
     };
   }
 });
@@ -1353,16 +1356,11 @@ var init_groupFactory = __esm({
     groupFactory = async (parentCssSelector, elementCssSelector, driver) => {
       const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
       const classSting = await elementInstance.getClasses();
-      if (classSting.includes("tab-panel-group"))
-        return new TabPanel(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("tab-panel-item"))
-        return new TabPanelItem(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("panel-group"))
-        return new Panel(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("accordion-group"))
-        return new Accordion(parentCssSelector, elementCssSelector, driver);
-      if (classSting.includes("d5-accordion-item"))
-        return new AccordionItem(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("tab-panel-group")) return new TabPanel(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("tab-panel-item")) return new TabPanelItem(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("panel-group")) return new Panel(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("accordion-group")) return new Accordion(parentCssSelector, elementCssSelector, driver);
+      if (classSting.includes("d5-accordion-item")) return new AccordionItem(parentCssSelector, elementCssSelector, driver);
       throw new Error("Unknown type of group. Please write ticket to the support");
     };
   }
@@ -1561,7 +1559,7 @@ var init_Cell = __esm({
     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;
@@ -1581,7 +1579,30 @@ var init_Cell = __esm({
         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) {
@@ -1592,11 +1613,12 @@ var init_Cell = __esm({
       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;
@@ -1624,6 +1646,13 @@ var init_Row = __esm({
       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;
@@ -1636,8 +1665,8 @@ var init_Row = __esm({
           () => {
             return this.getColumnBy({ title, name }).getIndex();
           },
-          index,
-          this.driver
+          this.driver,
+          index
         );
       }
       getCellByIndex(index) {
@@ -1650,9 +1679,11 @@ var init_Row = __esm({
         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);
@@ -1681,14 +1712,14 @@ var init_Row = __esm({
         const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
           this.index
         )}"] .${buttonClass}`;
-        const button = await fixElementStaleError(
-          import_selenium_webdriver22.By.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`),
-          this.driver
-        );
-        return click(button, this.driver);
+        const by = import_selenium_webdriver22.By.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;
           },
@@ -1797,7 +1828,7 @@ var init_EditorButton = __esm({
       }
       async click() {
         const button = await this.getElement();
-        await waitElementIsClickable({
+        await waitElementIsClickable_default({
           element: button,
           errorMessage: this.buttonNotDisplayedError(),
           driver: this.driver
@@ -1888,6 +1919,21 @@ var init_AbstractEditor2 = __esm({
         await this.initEditor();
         return this.editor.isReadonly();
       }
+      /**
+       * Возвращает значение true|false в зависимости isDisplayed поле или нет
+       * @example
+       * expect(await formEdit.field('NumberFld').isDisplayed()).toBe(true);
+       * expect(await formEdit.field('TextFld').isDisplayed()).toBe(false);
+       */
+      async isDisplayed() {
+        try {
+          await this.initEditor();
+          const element = await this.getElement();
+          return await element.isDisplayed();
+        } catch {
+          return false;
+        }
+      }
       /**
        * Находит кнопку на поле по имени
        * @example
@@ -1918,26 +1964,205 @@ var init_FormField = __esm({
   }
 });
 
+// src/utils/typesUtil.ts
+var import_util, types, type, isArray, isString;
+var init_typesUtil = __esm({
+  "src/utils/typesUtil.ts"() {
+    "use strict";
+    import_util = require("selenium-webdriver/lib/util");
+    types = {
+      "[object Array]": "array",
+      "[object Date]": "date",
+      "[object Object]": "object",
+      "[object String]": "string",
+      "[object Null]": "null"
+    };
+    type = function(object) {
+      const typeOfObject = Object.prototype.toString.call(object);
+      return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
+    };
+    isArray = function(value) {
+      return type(value) === "array";
+    };
+    isString = function(object) {
+      return typeof object === "string";
+    };
+  }
+});
+
+// src/pageObjects/elements/AbstractDropDownMenuList.ts
+var AbstractDropDownMenuList;
+var init_AbstractDropDownMenuList = __esm({
+  "src/pageObjects/elements/AbstractDropDownMenuList.ts"() {
+    "use strict";
+    init_AbstractElementWithParent();
+    init_actions();
+    init_waitElementIsClickable();
+    init_fixElementStaleError();
+    init_typesUtil();
+    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/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}]`;
+}
+var init_cssToXPath = __esm({
+  "src/utils/cssToXPath.ts"() {
+    "use strict";
+  }
+});
+
+// src/pageObjects/elements/DXContextMenuList.ts
+var import_selenium_webdriver24, CONTEXT_MENU_CLASS, CONTEXT_MENU_ITEM_TEXT_CLASS, DXContextMenuList;
+var init_DXContextMenuList = __esm({
+  "src/pageObjects/elements/DXContextMenuList.ts"() {
+    "use strict";
+    init_AbstractDropDownMenuList();
+    import_selenium_webdriver24 = require("selenium-webdriver");
+    init_cssToXPath();
+    init_waitElementIsVisible();
+    CONTEXT_MENU_CLASS = "dx-context-menu";
+    CONTEXT_MENU_ITEM_TEXT_CLASS = "dx-menu-item-text";
+    DXContextMenuList = class extends AbstractDropDownMenuList {
+      /**
+       * @param parentCssSelector
+       * @param classNames - Список класів. Починається з крапки
+       * @param driver
+       */
+      constructor(parentCssSelector, classNames, driver) {
+        super(parentCssSelector, `.${CONTEXT_MENU_CLASS}${classNames}`, driver);
+      }
+      getButtonTitleBy(title) {
+        const buttonByTextXpath2 = (text) => `//span[contains(@class, "${CONTEXT_MENU_ITEM_TEXT_CLASS}") and contains(text(), "${text}")]`;
+        const xpath = "//div" + cssClassesToXPath(this.elementCssSelector) + buttonByTextXpath2(title);
+        return import_selenium_webdriver24.By.xpath(xpath);
+      }
+      async isVisible() {
+        try {
+          await waitElementIsVisible_default({
+            element: await this.driver.findElement(import_selenium_webdriver24.By.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;
+var init_ContextMenu = __esm({
+  "src/pageObjects/elements/Table/elements/ContextMenu.ts"() {
+    "use strict";
+    init_DXContextMenuList();
+    init_locators();
+    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 import_selenium_webdriver24, Table;
+var import_selenium_webdriver25, Table;
 var init_Table = __esm({
   "src/pageObjects/elements/Table/Table.ts"() {
     "use strict";
-    import_selenium_webdriver24 = require("selenium-webdriver");
+    import_selenium_webdriver25 = require("selenium-webdriver");
     init_createDataTestId();
     init_AbstractElementWithParent();
     init_Row();
     init_Column();
     init_FormField();
+    init_ContextMenu();
+    init_actions();
     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;
       }
@@ -1947,10 +2172,18 @@ var init_Table = __esm({
         }
         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,
@@ -1973,12 +2206,16 @@ var init_Table = __esm({
           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(import_selenium_webdriver24.By.css(rowsFullCssSelector));
+        const rows = await this.driver.findElements(import_selenium_webdriver25.By.css(rowsFullCssSelector));
         const result = [];
         rows.forEach((_, index) => {
           const newRow = new Row(
@@ -1994,7 +2231,7 @@ var init_Table = __esm({
       }
       async getColumns() {
         const columns = await this.driver.findElements(
-          import_selenium_webdriver24.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+          import_selenium_webdriver25.By.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
         );
         const result = [];
         columns.forEach((_, index) => {
@@ -2020,132 +2257,265 @@ var init_Table = __esm({
       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;
-var init_ToolbarGroupButton = __esm({
-  "src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts"() {
+// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
+var import_selenium_webdriver26, TOOLBAR_BUTTON_CLASS, TOOLBAR_BUTTON_TEXT_CLASS, getToolbarButtonSelector, getToolbarButtonTextSelector, ToolbarButton;
+var init_ToolbarButton = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarButton.ts"() {
     "use strict";
+    import_selenium_webdriver26 = require("selenium-webdriver");
     init_AbstractButton();
-    ToolbarGroupButton = class extends AbstractButton {
+    TOOLBAR_BUTTON_CLASS = "toolbar-button";
+    TOOLBAR_BUTTON_TEXT_CLASS = "dx-button-text";
+    getToolbarButtonSelector = (name) => `#${TOOLBAR_BUTTON_CLASS}-${name}`;
+    getToolbarButtonTextSelector = (name) => `${getToolbarButtonSelector(name)} .${TOOLBAR_BUTTON_TEXT_CLASS}`;
+    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(import_selenium_webdriver26.By.css(getToolbarButtonTextSelector(this.name)));
+          return await buttonTextContainer.getText();
+        } catch (_) {
+          return null;
+        }
+      }
     };
   }
 });
 
-// src/pageObjects/elements/TableToolbar/ToolbarButton.ts
-var TOOLBAR_BUTTON_CLASS, ToolbarButton;
-var init_ToolbarButton = __esm({
-  "src/pageObjects/elements/TableToolbar/ToolbarButton.ts"() {
+// src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
+var import_selenium_webdriver27, ToolbarGroupButton;
+var init_ToolbarGroupButton = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts"() {
     "use strict";
     init_AbstractButton();
-    TOOLBAR_BUTTON_CLASS = "toolbar-button";
-    ToolbarButton = class extends AbstractButton {
+    import_selenium_webdriver27 = require("selenium-webdriver");
+    init_ToolbarButton();
+    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(import_selenium_webdriver27.By.css(getToolbarButtonTextSelector(this.name)));
+          return await buttonTextContainer.getText();
+        } catch (_) {
+          return null;
+        }
+      }
     };
   }
 });
 
-// src/utils/typesUtil.ts
-var types, type, isArray, isString;
-var init_typesUtil = __esm({
-  "src/utils/typesUtil.ts"() {
+// src/pageObjects/elements/AbstractDropDownMenuButton.ts
+var AbstractDropDownMenuButton;
+var init_AbstractDropDownMenuButton = __esm({
+  "src/pageObjects/elements/AbstractDropDownMenuButton.ts"() {
     "use strict";
-    types = {
-      "[object Array]": "array",
-      "[object Date]": "date",
-      "[object Object]": "object",
-      "[object String]": "string",
-      "[object Null]": "null"
-    };
-    type = function(object) {
-      const typeOfObject = Object.prototype.toString.call(object);
-      return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
-    };
-    isArray = function(value) {
-      return type(value) === "array";
+    init_AbstractElementWithParent();
+    init_actions();
+    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);
+      }
     };
-    isString = function(object) {
-      return typeof object === "string";
+  }
+});
+
+// src/pageObjects/elements/TableToolbar/ToolbarMenuItem.ts
+var ToolbarMenuItem;
+var init_ToolbarMenuItem = __esm({
+  "src/pageObjects/elements/TableToolbar/ToolbarMenuItem.ts"() {
+    "use strict";
+    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 import_selenium_webdriver25, SPINDOWN_CLASS, buttonGroupItemSelector, getFullCssSelector, buttonByTextXpath, ToolbarMenu;
+var SPINDOWN_CLASS, buttonGroupItemSelector, getFullCssSelector, ToolbarMenuList, ToolbarMenu;
 var init_ToolbarMenu = __esm({
   "src/pageObjects/elements/TableToolbar/ToolbarMenu.ts"() {
     "use strict";
-    import_selenium_webdriver25 = require("selenium-webdriver");
     init_typesUtil();
-    init_AbstractElementWithParent();
     init_locators();
-    init_actions();
-    init_waitElementIsClickable();
-    init_fixElementStaleError();
+    init_AbstractDropDownMenuButton();
+    init_DXContextMenuList();
+    init_ToolbarMenuItem();
     SPINDOWN_CLASS = ".dx-icon-spindown";
     buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
     getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
-    buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
-    ToolbarMenu = class extends AbstractElementWithParent {
+    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);
+    };
+    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, import_selenium_webdriver25.By.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();
       }
     };
   }
@@ -2173,8 +2543,7 @@ var init_ToolbarItem = __esm({
         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);
@@ -2198,6 +2567,10 @@ var init_ToolbarItem = __esm({
           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);
       }
@@ -2227,11 +2600,11 @@ var init_FormToolbar = __esm({
 });
 
 // src/pageObjects/elements/Filters/FilterOperation.ts
-var import_selenium_webdriver26, FILTER_OPERATIONS, BUTTON_OPERATION_WIDGET, OPERATIONS_WIDGET_POPUP, getWidgetInPopupSelector, FilterOperation;
+var import_selenium_webdriver28, FILTER_OPERATIONS, BUTTON_OPERATION_WIDGET, OPERATIONS_WIDGET_POPUP, getWidgetInPopupSelector, FilterOperation;
 var init_FilterOperation = __esm({
   "src/pageObjects/elements/Filters/FilterOperation.ts"() {
     "use strict";
-    import_selenium_webdriver26 = require("selenium-webdriver");
+    import_selenium_webdriver28 = require("selenium-webdriver");
     init_fixElementStaleError();
     init_AbstractElementWithParent();
     init_locators();
@@ -2266,16 +2639,16 @@ var init_FilterOperation = __esm({
       }
       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(import_selenium_webdriver26.By.className("dx-icon"));
+        const clickableElement = await widgetButtonEl.findElement(import_selenium_webdriver28.By.className("dx-icon"));
         await click(clickableElement, this.driver);
         try {
-          const widgetPopupEl = await this.driver.findElement(import_selenium_webdriver26.By.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
-          await waitElementIsVisible({
+          const widgetPopupEl = await this.driver.findElement(import_selenium_webdriver28.By.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
+          await waitElementIsVisible_default({
             element: widgetPopupEl,
             errorMessage: `Operation widget popup is not visible`,
             driver: this.driver
@@ -2289,13 +2662,12 @@ var init_FilterOperation = __esm({
           throw new Error(`Operation with name "${operationName}" is not correct.`);
         }
         await this.initOperationWidget();
-        const operationEl = await fixElementStaleError(import_selenium_webdriver26.By.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)} ${getWidgetInPopupSelector(operationName)}`), this.driver);
+        const operationEl = await fixElementStaleError(import_selenium_webdriver28.By.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,
@@ -2304,15 +2676,14 @@ var init_FilterOperation = __esm({
       }
       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;
@@ -2394,7 +2765,8 @@ var init_FormFilterField = __esm({
       async initOperation() {
         return new FilterOperation({
           parentCssSelector: this.parentCssSelector,
-          filterTestID: createLayoutFilterTestId(this.formName, this.name)
+          filterTestID: createLayoutFilterTestId(this.formName, this.name),
+          driver: this.driver
         });
       }
       /**
@@ -2501,7 +2873,8 @@ var init_PanelFilterField = __esm({
       async initOperation() {
         return new FilterOperation({
           parentCssSelector: this.parentCssSelector,
-          filterTestID: createDocFilterTestId(this.formName, this.name)
+          filterTestID: createDocFilterTestId(this.formName, this.name),
+          driver: this.driver
         });
       }
       /**
@@ -2545,11 +2918,11 @@ var init_PanelFilterField = __esm({
 });
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-var import_selenium_webdriver27, drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
+var import_selenium_webdriver29, drawerSelector, FILTER_PANEL_SELECTOR, CLOSE_SELECTOR, FilterPanel;
 var init_FilterPanel = __esm({
   "src/pageObjects/elements/Filters/FilterPanel.ts"() {
     "use strict";
-    import_selenium_webdriver27 = require("selenium-webdriver");
+    import_selenium_webdriver29 = require("selenium-webdriver");
     init_AbstractElement();
     init_PanelFilterField();
     init_actions();
@@ -2564,7 +2937,7 @@ var init_FilterPanel = __esm({
       async filterPanelButtons() {
         const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
         const el = await this.getElement();
-        return el.findElements(import_selenium_webdriver27.By.css(selector));
+        return el.findElements(import_selenium_webdriver29.By.css(selector));
       }
       constructor(formName, driver) {
         super(driver, drawerSelector(formName));
@@ -2597,7 +2970,7 @@ var init_FilterPanel = __esm({
         await this.driver.sleep(300);
       }
       async close() {
-        const btn = await this.driver.findElement(import_selenium_webdriver27.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+        const btn = await this.driver.findElement(import_selenium_webdriver29.By.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
         await click(btn, this.driver);
       }
     };
@@ -2633,12 +3006,12 @@ var init_HeaderFilterField = __esm({
 });
 
 // src/pageObjects/elements/Filters/ColumnFilter.ts
-var import_selenium_webdriver28, APPLY_SELECTOR, CANCEL_SELECTOR, HEADER_FILTER_ICON, HEADER_FILTER_CONTAINER, HEADER_FILTER_BUTTONS, ColumnFilter;
+var import_selenium_webdriver30, APPLY_SELECTOR, CANCEL_SELECTOR, HEADER_FILTER_ICON, HEADER_FILTER_CONTAINER, HEADER_FILTER_BUTTONS, ColumnFilter;
 var init_ColumnFilter = __esm({
   "src/pageObjects/elements/Filters/ColumnFilter.ts"() {
     "use strict";
     init_actions();
-    import_selenium_webdriver28 = require("selenium-webdriver");
+    import_selenium_webdriver30 = require("selenium-webdriver");
     init_HeaderFilterField();
     init_waitElementIsVisible();
     init_AbstractElement();
@@ -2663,11 +3036,11 @@ var init_ColumnFilter = __esm({
       }
       async getApplyButton() {
         const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
-        return this.driver.findElement(import_selenium_webdriver28.By.css(selector));
+        return this.driver.findElement(import_selenium_webdriver30.By.css(selector));
       }
       async getCancelButton() {
         const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
-        return this.driver.findElement(import_selenium_webdriver28.By.css(selector));
+        return this.driver.findElement(import_selenium_webdriver30.By.css(selector));
       }
       async apply() {
         const btn = await this.getApplyButton();
@@ -2681,9 +3054,9 @@ var init_ColumnFilter = __esm({
         const columnEl = await this._column.getElement();
         const actions = this.driver.actions({ async: true });
         await actions.move({ origin: columnEl }).perform();
-        const elements = await columnEl.findElements(import_selenium_webdriver28.By.css(HEADER_FILTER_ICON));
+        const elements = await columnEl.findElements(import_selenium_webdriver30.By.css(HEADER_FILTER_ICON));
         let headerFilterIcon = null;
-        await wait(
+        await safeWait(
           async () => {
             let result = false;
             for (let element of elements) {
@@ -2698,12 +3071,11 @@ var init_ColumnFilter = __esm({
           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`
@@ -2731,16 +3103,18 @@ var init_ColumnFilter = __esm({
        */
       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);
@@ -2775,7 +3149,8 @@ var init_ColumnFilter = __esm({
         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
         });
       }
       /**
@@ -2825,7 +3200,7 @@ var ListForm_exports = {};
 __export(ListForm_exports, {
   default: () => ListForm
 });
-var DATAGRID_HEADER_CSS_SELECTOR, DATAGRID_CONTENT_CSS_SELECTOR, FIXED_DATAGRID_CONTENT_CSS_SELECTOR, ListForm;
+var DATAGRID_HEADER_CSS_SELECTOR, DATAGRID_CONTENT_CSS_SELECTOR, FIXED_DATAGRID_CONTENT_CSS_SELECTOR, CONTEXT_MENU_CSS_SELECTOR, ListForm;
 var init_ListForm = __esm({
   "src/pageObjects/elements/Forms/ListForm.ts"() {
     "use strict";
@@ -2838,16 +3213,19 @@ var init_ListForm = __esm({
     DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
     DATAGRID_CONTENT_CSS_SELECTOR = ".dx-datagrid-content:not(.dx-datagrid-content-fixed)";
     FIXED_DATAGRID_CONTENT_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
+    CONTEXT_MENU_CSS_SELECTOR = ".dx-datagrid";
     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;
       }
       /**
        * Находит таблицу
@@ -2858,12 +3236,15 @@ var init_ListForm = __esm({
        */
       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
+          }
         );
       }
       /**
@@ -2922,9 +3303,10 @@ var init_TreeView = __esm({
     TreeView = class extends ListForm {
       constructor(driver) {
         super(driver);
-        this.popupContainerCssSelector = `.popup.wrapper-tree-view-${this.formName}`;
+        this.popupContainerCssSelector = `.popup.tree-view-${this.formName}`;
         this.headerCssSelector = TREELIST_HEADER_CSS_SELECTOR;
         this.fixedTableContentCssSelector = FIXED_TREELIST_CONTENT_CSS_SELECTOR;
+        this.contextMenuCssSelector = ".dx-treelist-container";
         this.tableContentCssSelector = TREELIST_CONTENT_CSS_SELECTOR;
       }
     };
@@ -2932,8 +3314,12 @@ var init_TreeView = __esm({
 });
 
 // src/pageObjects/elements/Forms/createSubFormInstance.ts
-function subformCssSelector(parentCssSelector, testId) {
-  return `${parentCssSelector} ${byTestIdCssSelector(testId)}`;
+function subformCssSelector(parentCssSelector, testId, isDockPanel = false) {
+  if (isDockPanel) {
+    return `${SECONDARY_DRAWER_LAYOUT_CONTENT} ${byTestIdCssSelector(testId)}`;
+  } else {
+    return `${parentCssSelector} ${byTestIdCssSelector(testId)}`;
+  }
 }
 async function classDependencyInjector(formType) {
   let SubFormFactoryClass;
@@ -2954,23 +3340,24 @@ async function classDependencyInjector(formType) {
   }
   return SubFormFactoryClass;
 }
-var subFormTestId;
+var SECONDARY_DRAWER_LAYOUT_CONTENT, subFormTestId;
 var init_createSubFormInstance = __esm({
   "src/pageObjects/elements/Forms/createSubFormInstance.ts"() {
     "use strict";
     init_locators();
     init_types2();
+    SECONDARY_DRAWER_LAYOUT_CONTENT = ".secondary-drawer-layout-content";
     subFormTestId = (name) => `subform-${name}`;
   }
 });
 
 // src/pageObjects/elements/Forms/Form.ts
-var import_selenium_webdriver29, formTestId, Form;
+var import_selenium_webdriver31, formTestId, Form;
 var init_Form = __esm({
   "src/pageObjects/elements/Forms/Form.ts"() {
     "use strict";
     init_locators();
-    import_selenium_webdriver29 = require("selenium-webdriver");
+    import_selenium_webdriver31 = require("selenium-webdriver");
     init_AbstractForm();
     init_waitElementIsVisible();
     init_createSubFormInstance();
@@ -2995,10 +3382,15 @@ var init_Form = __esm({
        */
       async getTitleText() {
         if (await this.isModal()) {
-          const titleEl2 = await this.driver.findElement(import_selenium_webdriver29.By.css(`${this.popupContainerCssSelector} .popup-title`));
+          const titleEl2 = await this.driver.findElement(import_selenium_webdriver31.By.css(`${this.popupContainerCssSelector} .popup-title`));
+          await waitElementIsVisible_default({
+            element: titleEl2,
+            driver: this.driver,
+            errorMessage: `Form title element is not visible`
+          });
           return titleEl2.getText();
         }
-        let titleEl = await this.driver.findElement(import_selenium_webdriver29.By.className("main-toolbar-form-title"));
+        let titleEl = await this.driver.findElement(import_selenium_webdriver31.By.className("main-toolbar-form-title"));
         return titleEl.getText();
       }
       setSubFormMode() {
@@ -3014,11 +3406,12 @@ var init_Form = __esm({
        * //...
        * expect(await form.subForm(name));
        */
-      async subForm(name) {
-        const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name));
-        const byCssSelector = import_selenium_webdriver29.By.css(cssSelector);
+      async subForm(name, options = {}) {
+        const { isDockPanel = false } = options;
+        const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name), isDockPanel);
+        const byCssSelector = import_selenium_webdriver31.By.css(cssSelector);
         const subFormEl = await this.driver.findElement(byCssSelector);
-        await waitElementIsVisible({
+        await waitElementIsVisible_default({
           element: subFormEl,
           driver: this.driver,
           errorMessage: `Subform "${name}" is not visible`
@@ -3046,12 +3439,12 @@ var FormEdit_exports = {};
 __export(FormEdit_exports, {
   default: () => FormEdit
 });
-var import_selenium_webdriver30, FormEdit;
+var import_selenium_webdriver32, FormEdit;
 var init_FormEdit = __esm({
   "src/pageObjects/elements/Forms/FormEdit.ts"() {
     "use strict";
     init_Form();
-    import_selenium_webdriver30 = require("selenium-webdriver");
+    import_selenium_webdriver32 = require("selenium-webdriver");
     init_FormField();
     init_actions();
     init_wait();
@@ -3087,7 +3480,7 @@ var init_FormEdit = __esm({
        */
       async isSaveButtonDisabled() {
         const saveButtonCssSelector = await this.getButtonCssSelector(this.saveButtonId);
-        const saveButton = await this.driver.findElement(import_selenium_webdriver30.By.css(saveButtonCssSelector));
+        const saveButton = await this.driver.findElement(import_selenium_webdriver32.By.css(saveButtonCssSelector));
         const result = await saveButton.getAttribute("aria-disabled");
         return result === "true";
       }
@@ -3100,8 +3493,8 @@ var init_FormEdit = __esm({
        */
       async saveButtonClick() {
         const saveButtonCssSelector = await this.getButtonCssSelector(this.saveButtonId);
-        const saveButton = await this.driver.findElement(import_selenium_webdriver30.By.css(saveButtonCssSelector));
-        await wait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
+        const saveButton = await this.driver.findElement(import_selenium_webdriver32.By.css(saveButtonCssSelector));
+        await safeWait(async () => !await this.isSaveButtonDisabled(), this.driver, "Button is disabled");
         await click(saveButton, this.driver);
       }
       /**
@@ -3113,7 +3506,7 @@ var init_FormEdit = __esm({
        */
       async closeButtonClick() {
         const closeButtonCssSelector = await this.getButtonCssSelector(this.closeButtonId);
-        const closeButton = await this.driver.findElement(import_selenium_webdriver30.By.css(closeButtonCssSelector));
+        const closeButton = await this.driver.findElement(import_selenium_webdriver32.By.css(closeButtonCssSelector));
         await click(closeButton, this.driver);
       }
     };
@@ -3142,13 +3535,15 @@ __export(src_exports, {
   byTestIdCssSelector: () => byTestIdCssSelector,
   click: () => click,
   config: () => config,
+  contextMenu: () => contextMenu,
   createDriver: () => createDriver,
   editorFactory: () => editorFactory,
   elementIsNotPresent: () => elementIsNotPresent,
   readonlyLocator: () => readonlyLocator,
   signIn: () => signIn,
-  wait: () => wait,
-  waitElementIsVisible: () => waitElementIsVisible
+  wait: () => safeWait,
+  waitElementIsClickable: () => waitElementIsClickable_default,
+  waitElementIsVisible: () => waitElementIsVisible_default
 });
 module.exports = __toCommonJS(src_exports);
 init_config();
@@ -3159,6 +3554,7 @@ init_config();
 init_waitElementIsVisible();
 init_actions();
 init_locators();
+var import_selenium_webdriver3 = require("selenium-webdriver");
 var LOGIN_PATH = "/login";
 var LoginPage = class extends AbstractPage {
   usernameField = byTestId("loginField", "input");
@@ -3167,7 +3563,7 @@ var LoginPage = class extends AbstractPage {
   async locate() {
     await super.locate();
     const login = await this.driver.findElement(this.usernameField);
-    await waitElementIsVisible({
+    await waitElementIsVisible_default({
       element: login,
       driver: this.driver
     });
@@ -3183,6 +3579,11 @@ var LoginPage = class extends AbstractPage {
   }
   async clickLoginButton() {
     await click(await this.driver.findElement(this.loginButton), this.driver);
+    await waitElementIsVisible_default({
+      driver: this.driver,
+      by: import_selenium_webdriver3.By.id("section"),
+      errorMessage: "Sing in not successful"
+    });
   }
   async loginWith(username, password) {
     await this.enterUsername(username);
@@ -3200,8 +3601,38 @@ init_locators();
 // src/utils/createDriver.ts
 var import_selenium_webdriver4 = require("selenium-webdriver");
 init_config();
+var import_chrome = __toESM(require("selenium-webdriver/chrome"));
+var import_firefox = __toESM(require("selenium-webdriver/firefox"));
+function chromeOptions(builder, options) {
+  const ChromeOptions = new import_chrome.default.Options();
+  if (options.headless) {
+    ChromeOptions.addArguments(`--headless=new`);
+  }
+  return builder.setChromeOptions(ChromeOptions);
+}
+function firefoxOptions(builder, options) {
+  const FirefoxOptions = new import_firefox.default.Options();
+  if (options.headless) {
+    FirefoxOptions.addArguments(`--headless`);
+  }
+  return builder.setFirefoxOptions(FirefoxOptions);
+}
+function setOptions(builder, browser, options) {
+  switch (browser) {
+    case "chrome":
+      return chromeOptions(builder, options);
+    case "firefox":
+      return firefoxOptions(builder, options);
+    default:
+      return builder;
+  }
+}
 var createDriver = async (browser) => {
-  const driver = await new import_selenium_webdriver4.Builder().forBrowser(browser ?? config().browser).build();
+  const _browser = browser ?? config().browser;
+  const headless = config().headless === "true";
+  let builder = new import_selenium_webdriver4.Builder().forBrowser(_browser);
+  builder = setOptions(builder, _browser, { headless });
+  const driver = await builder.build();
   const manage = driver.manage();
   await manage.setTimeouts({ implicit: config().timeout });
   await manage.window().maximize();
@@ -3219,13 +3650,12 @@ var elementIsNotPresent = function elementIsNotPresent2(locator) {
 
 // src/index.ts
 init_waitElementIsVisible();
+init_waitElementIsClickable();
 init_wait();
 
 // src/utils/signIn.ts
-init_config();
 async function signIn(driver) {
   const webDriver = driver ?? await createDriver();
-  config().driver = webDriver;
   const loginPage = new LoginPage(webDriver);
   await loginPage.locate();
   await loginPage.authorize();
@@ -3257,6 +3687,8 @@ init_Editors();
 // src/pageObjects/elements/SubsystemsPanel/SubsystemItem.ts
 init_actions();
 init_fixElementStaleError();
+init_waitElementIsVisible();
+init_waitElementIsClickable();
 var SubsystemItem = class {
   bySelector;
   driver;
@@ -3268,10 +3700,22 @@ var SubsystemItem = class {
     return fixElementStaleError(this.bySelector, this.driver);
   }
   async getTitle() {
+    await waitElementIsVisible_default(
+      {
+        by: this.bySelector,
+        driver: this.driver
+      }
+    );
     const el = await this.getElement();
     return await el.getAttribute("data-title");
   }
   async click() {
+    await waitElementIsClickable_default(
+      {
+        by: this.bySelector,
+        driver: this.driver
+      }
+    );
     const el = await this.getElement();
     await click(el, this.driver);
   }
@@ -3282,6 +3726,7 @@ init_createDataTestId();
 init_actions();
 init_ClearButtonStrategy();
 init_waitElementIsVisible();
+init_fixElementStaleError();
 var SEARCH_ITEM_SELECTOR = "search-item";
 var BACK_BUTTON_SELECTOR = "subsystem-back-item";
 var SEARCH_INPUT_SELECTOR = "search-subsystem-input";
@@ -3296,11 +3741,11 @@ var SubsystemsPanel = class extends AbstractElement {
   }
   async headerTitle() {
     const title = await this.header.title();
-    await wait(async () => await title.getText() != "", this.driver);
+    await safeWait(async () => await title.getText() != "", this.driver);
     return title.getText();
   }
   getSearchComponent() {
-    return new TextEditor("#aside", byTestIdCssSelector(SEARCH_INPUT_SELECTOR));
+    return new TextEditor("#aside", byTestIdCssSelector(SEARCH_INPUT_SELECTOR), this.driver);
   }
   /**
    * Находит сабсистему по заголовку
@@ -3311,8 +3756,9 @@ var SubsystemsPanel = class extends AbstractElement {
    */
   async search(title) {
     const searchComponent = this.getSearchComponent();
+    await this.searchClear();
     await searchComponent.setValue(title);
-    await wait(
+    await safeWait(
       async () => {
         const findElement = await this.itemByTitle(title).getElement();
         const classes = await findElement.getAttribute("class");
@@ -3331,7 +3777,7 @@ var SubsystemsPanel = class extends AbstractElement {
    */
   async searchClear() {
     const clearBtnSelector = `#aside ${byTestIdCssSelector(SEARCH_INPUT_SELECTOR)} .${DX_CLEAR_BUTTON_AREA}`;
-    const clearBtn = await this.driver.findElement(import_selenium_webdriver16.By.css(clearBtnSelector));
+    const clearBtn = await fixElementStaleError(import_selenium_webdriver16.By.css(clearBtnSelector), this.driver);
     if (await clearBtn.isDisplayed()) {
       await click(clearBtn, this.driver);
     }
@@ -3365,14 +3811,14 @@ var SubsystemsPanel = class extends AbstractElement {
    * wait subsystemsPanel.back();
    */
   async back() {
-    const backButton = this.driver.findElement(import_selenium_webdriver16.By.css(`#aside .${BACK_BUTTON_SELECTOR}`));
-    await waitElementIsVisible(
+    const by = import_selenium_webdriver16.By.css(`#aside .${BACK_BUTTON_SELECTOR}`);
+    await waitElementIsVisible_default(
       {
-        element: backButton,
+        by,
         driver: this.driver
       }
     );
-    await click(backButton, this.driver);
+    await click(await fixElementStaleError(by, this.driver), this.driver);
   }
 };
 
@@ -3410,13 +3856,13 @@ init_FilterPanel();
 
 // src/pageObjects/elements/Dialog.ts
 init_AbstractElement();
-var import_selenium_webdriver31 = require("selenium-webdriver");
+var import_selenium_webdriver33 = require("selenium-webdriver");
 init_AbstractButton();
 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 buttonByTextXpath = (text) => `.//span[contains(@class, "dx-button-text") and contains(text(), "${text}")]`;
 var DialogButton = class extends AbstractButton {
   text;
   constructor(parentCssSelector, text, driver) {
@@ -3425,11 +3871,14 @@ var DialogButton = class extends AbstractButton {
   }
   async getElement() {
     const panel = await super.getElement();
-    return panel.findElement(import_selenium_webdriver31.By.xpath(buttonByTextXpath2(this.text)));
+    return panel.findElement(import_selenium_webdriver33.By.xpath(buttonByTextXpath(this.text)));
   }
   buttonNotDisplayedError() {
     return `Dialog button ${this.text} cannot be clicked. It is not displayed or it is disabled`;
   }
+  getTitle() {
+    throw new Error(`Method "getTitle()" is not working.`);
+  }
 };
 var Dialog = class extends AbstractElement {
   constructor(driver) {
@@ -3445,11 +3894,11 @@ var Dialog = class extends AbstractElement {
     return this.joinRelativeCssSelectors([DIALOG_CLASS, DIALOG_BUTTONS_PANEL_CLASS]);
   }
   async title() {
-    const el = await this.driver.findElement(import_selenium_webdriver31.By.css(this.titleSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver33.By.css(this.titleSelector));
     return await el.getText();
   }
   async text() {
-    const el = await this.driver.findElement(import_selenium_webdriver31.By.css(this.textSelector));
+    const el = await this.driver.findElement(import_selenium_webdriver33.By.css(this.textSelector));
     return await el.getText();
   }
   button(text) {
@@ -3477,11 +3926,13 @@ var Dialog = class extends AbstractElement {
   byTestIdCssSelector,
   click,
   config,
+  contextMenu,
   createDriver,
   editorFactory,
   elementIsNotPresent,
   readonlyLocator,
   signIn,
   wait,
+  waitElementIsClickable,
   waitElementIsVisible
 });