d5-testing-library 1.9.0-alpha.3 → 1.9.0-alpha.33

package/dist/{chunk-GP4LKGNA.mjs → chunk-TSE33S3X.mjs}

@@ -17,14 +17,15 @@ import {
   safeWait,
   staleElementAction,
   waitElementIsClickable_default,
-  waitElementIsVisible_default
-} from "./chunk-ROHBQLRX.mjs";
+  waitElementIsVisible_default,
+  withCustomTimeouts_default
+} from "./chunk-RPSLW2WB.mjs";
 
 // src/pageObjects/elements/Table/Table.ts
 import { By as By6 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Row.ts
-import { By as By3 } from "selenium-webdriver";
+import { By as By3, Key } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Cell.ts
 import { By as By2 } from "selenium-webdriver";
@@ -76,21 +77,30 @@ var Cell = class extends AbstractElementWithParent {
   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));
+    const getDate = (stringDate) => {
+      const isWithTime = cellElClass.includes("with-time");
+      try {
+        if (isWithTime) {
+          const [datePart, timePart] = stringDate.split(", ");
+          const [day, month, year] = datePart.split(".").map(Number);
+          const [hours, minutes] = timePart.split(":").map(Number);
+          return new Date(year, month - 1, day, hours, minutes, 0, 0);
+        } else {
+          const [day, month, year] = stringDate.split(".").map(Number);
+          return new Date(Date.UTC(year, month - 1, day));
+        }
+      } catch (error) {
+        console.error(`Error parsing date value "${stringDate}":`, error);
+        return null;
       }
-    } catch (error) {
-      console.error(`Error parsing date value "${value}":`, error);
-      return null;
+    };
+    const periodValue = value.split(" - ");
+    if (periodValue.length > 1) {
+      const dateFrom = getDate(periodValue[0]);
+      const dateTo = getDate(periodValue[1]);
+      return [dateFrom, dateTo];
     }
+    return getDate(value);
   }
   async getElement() {
     if (this._index == null) {
@@ -117,6 +127,7 @@ var Cell = class extends AbstractElementWithParent {
 var DX_SELECTION_CLASS = "dx-selection";
 var DX_ROW_EDIT_CLASS = "dx-edit-row";
 var DX_DATA_ROW_CLASS = "dx-data-row";
+var FIRST_CLICKED_CELL_SELECTOR = 'td[aria-colindex="1"]';
 var Row = class extends AbstractElementWithParent {
   index;
   getColumnBy;
@@ -153,10 +164,20 @@ var Row = class extends AbstractElementWithParent {
   getCellByTitle(title) {
     return this._getCell({ title });
   }
-  async select() {
+  async select(preserve = false) {
     await staleElementAction(async () => {
       const rowEl = await this.getElement();
-      await click(rowEl, this.driver);
+      const isSelected = (await this.getClasses()).includes(DX_SELECTION_CLASS);
+      const clickedElement = await rowEl.findElement(By3.css(FIRST_CLICKED_CELL_SELECTOR));
+      if (isSelected && !preserve) {
+        await this.driver.actions({ async: true }).keyUp(Key.CONTROL).perform();
+      }
+      if (preserve && !isSelected) {
+        await this.driver.actions({ async: true }).keyDown(Key.CONTROL).perform();
+        await click(clickedElement, this.driver);
+        return;
+      }
+      await click(clickedElement, this.driver);
     });
     await safeWait(
       async () => {
@@ -366,7 +387,7 @@ var DXContextMenuList = class extends AbstractDropDownMenuList {
   async isVisible() {
     try {
       await waitElementIsVisible_default({
-        element: await this.driver.findElement(By5.css(`.dx-overlay-wrapper .dx-contextmenu`)),
+        element: await this.driver.findElement(By5.css(`.dx-overlay-wrapper .dx-context-menu`)),
         driver: this.driver,
         errorMessage: "Cannot find dropdown element"
       });
@@ -467,13 +488,32 @@ var Table = class extends AbstractElementWithParent {
   /**
    * Вибрати рядок по індексу.
    * @param index починається з 0
+   * @param preserve boolean який изначає, чи повинні раніше вибрані рядки залишатися вибраними
    */
-  selectRowByIndex(index) {
-    return this.getRowByIndex(index).select();
+  selectRowByIndex(index, preserve = false) {
+    return this.getRowByIndex(index).select(preserve);
   }
-  async getRows() {
+  /**
+   * Вибрати масив рядків по індексу.
+   * @param indexes починається з 0
+   */
+  async selectRowsByIndexes(indexes) {
+    for (const index of indexes) {
+      await this.selectRowByIndex(index, true);
+    }
+  }
+  getRowElements(timeout) {
     const rowsFullCssSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
-    const rows = await this.driver.findElements(By6.css(rowsFullCssSelector));
+    return withCustomTimeouts_default({
+      driver: this.driver,
+      timeout,
+      callback: () => {
+        return this.driver.findElements(By6.css(rowsFullCssSelector));
+      }
+    });
+  }
+  async getRows() {
+    const rows = await this.getRowElements();
     const result = [];
     rows.forEach((_, index) => {
       const newRow = new Row(
@@ -559,6 +599,72 @@ var Table = class extends AbstractElementWithParent {
       await contextMenu(cellElement, this.driver);
     });
   }
+  /**
+   * Отримує значення комірки таблиці за ім'ям комірки та індексом рядка.
+   *
+   * @param {string} cellName - Ім'я комірки (поля) в таблиці
+   * @param {number} rowIndex - Індекс рядка (починається з 0)
+   * @throws {Error} Викидає помилку, якщо rowIndex не вказано
+   * @returns {Promise<string>} Повертає значення комірки
+   *
+   * @example
+   * const table = new Table(driver);
+   *
+   * // Отримання значення комірки 'Name' в першому рядку (індекс 0)
+   * const cellValue = await table.getCellValueByCellName('Name', 0);
+   * expect(cellValue).toBe('Очікуване значення');
+   */
+  getCellValueByCellName(cellName, rowIndex) {
+    if (rowIndex == null) {
+      throw new Error("Error: getCellValue(): rowIndex is required");
+    }
+    const row = this.getRowByIndex(rowIndex);
+    return row.getCell(cellName).getValue();
+  }
+  /**
+   * Перевіряє, чи є таблиця порожньою (не містить жодного рядка з даними).
+   *
+   * @returns {Promise<boolean>} Повертає true, якщо таблиця порожня, false - якщо містить рядки
+   *
+   * @example
+   * const table = new Table(driver);
+   *
+   * // Перевірка чи порожня таблиця
+   * const empty = await table.isEmpty();
+   * expect(empty).toBe(true);
+   */
+  async isEmpty() {
+    try {
+      await this.waitRowsCount(0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Очікує, поки кількість рядків у таблиці не стане рівною заданому значенню.
+   * Використовується для синхронізації тестів з динамічним завантаженням даних.
+   *
+   * @param {number} count - Очікувана кількість рядків у таблиці
+   * @returns {Promise<void>} Повертає Promise, який виконується, коли кількість рядків відповідає очікуваній
+   * @throws {Error} Викидає помилку, якщо очікування перевищує тайм-аут
+   *
+   * @example
+   * const table = new Table(driver);
+   *
+   * // Очікування, поки таблиця не стане порожньою
+   * await table.waitRowsCount(0);
+   *
+   * // Очікування, поки в таблиці не з'явиться 5 рядків
+   * await table.waitRowsCount(5);
+   * console.log('Таблиця містить 5 рядків');
+   */
+  async waitRowsCount(count) {
+    await safeWait(async () => {
+      const rows = await this.getRowElements(1e3);
+      return rows.length === count;
+    }, this.driver, `Rows count not equal: ${count}`);
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
@@ -570,6 +676,7 @@ var TOOLBAR_BUTTON_CLASS = "toolbar-button";
 var TOOLBAR_BUTTON_TEXT_CLASS = "dx-button-text";
 var getToolbarButtonSelector = (name) => `#${TOOLBAR_BUTTON_CLASS}-${name}`;
 var getToolbarButtonTextSelector = (name) => `${getToolbarButtonSelector(name)} .${TOOLBAR_BUTTON_TEXT_CLASS}`;
+var getToolbarButtonTextByTestIdSelector = (testId) => `${byTestIdCssSelector(testId)} .${TOOLBAR_BUTTON_TEXT_CLASS}`;
 var ToolbarButton = class extends AbstractButton {
   name;
   constructor(parentCssSelector, name, driver) {
@@ -601,7 +708,8 @@ var ToolbarGroupButton = class extends AbstractButton {
   }
   async getTitle() {
     try {
-      const buttonTextContainer = await this.driver.findElement(By8.css(getToolbarButtonTextSelector(this.name)));
+      const buttonTestId = await this.getDataTestId();
+      const buttonTextContainer = await this.driver.findElement(By8.css(getToolbarButtonTextByTestIdSelector(buttonTestId)));
       return await buttonTextContainer.getText();
     } catch (_) {
       return null;
@@ -776,6 +884,14 @@ var ToolbarItem = class extends AbstractElementWithParent {
       return false;
     }
   }
+  async isPressed() {
+    try {
+      await this.init();
+      return this._button.isPressed();
+    } catch (error) {
+      return false;
+    }
+  }
   async getTitle() {
     await this.init();
     return await this._button.getTitle();
@@ -983,6 +1099,12 @@ var FormFilterField = class extends AbstractEditor {
     const filterOperation = await this.initOperation();
     return await filterOperation.getIsBlank();
   }
+  async isReadonly() {
+    return super.isReadonly();
+  }
+  async isDisabled() {
+    return super.isDisabled();
+  }
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
@@ -1084,6 +1206,12 @@ var PanelFilterField = class extends AbstractEditor {
     const filterOperation = await this.initOperation();
     return await filterOperation.getIsBlank();
   }
+  async isReadonly() {
+    return super.isReadonly();
+  }
+  async isDisabled() {
+    return super.isDisabled();
+  }
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
@@ -1156,12 +1284,18 @@ var HeaderFilterField = class extends AbstractEditor {
   async remove(itemText) {
     return super.remove(itemText);
   }
+  async isReadonly() {
+    return super.isReadonly();
+  }
+  async isDisabled() {
+    return super.isDisabled();
+  }
 };
 
 // src/pageObjects/elements/Filters/ColumnFilter.ts
 var APPLY_SELECTOR = ".apply-button";
 var CANCEL_SELECTOR = ".cancel-button";
-var HEADER_FILTER_ICON = ".dx-column-indicators .dx-header-filter";
+var HEADER_FILTER_ICON = ".indicators-container .filter-icon";
 var HEADER_FILTER_CONTAINER = ".header-filter";
 var HEADER_FILTER_BUTTONS = ".header-filter-buttons";
 var ColumnFilter = class extends AbstractElement {
@@ -1195,24 +1329,15 @@ var ColumnFilter = class extends AbstractElement {
     const columnEl = await this._column.getElement();
     const actions = this.driver.actions({ async: true });
     await actions.move({ origin: columnEl }).perform();
-    const elements = await columnEl.findElements(By11.css(HEADER_FILTER_ICON));
-    let headerFilterIcon = null;
+    const headerFilterIconBy = By11.css(HEADER_FILTER_ICON);
+    let headerFilterIcon = await columnEl.findElement(headerFilterIconBy);
     await safeWait(
-      async () => {
-        let result = false;
-        for (let element of elements) {
-          if (await element.isDisplayed()) {
-            headerFilterIcon = element;
-            result = true;
-            break;
-          }
-        }
-        return result;
+      () => {
+        return headerFilterIcon.isDisplayed();
       },
       this.driver,
       `HeaderFilter "${this._name}" is not visible`
     );
-    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();
@@ -1332,6 +1457,18 @@ var ColumnFilter = class extends AbstractElement {
     const filterOperation = await this.initOperation();
     return await filterOperation.getIsBlank();
   }
+  async isReadonly() {
+    const filter = await this.initFilter();
+    const result = await filter.isReadonly();
+    await this.cancel();
+    return result;
+  }
+  async isDisabled() {
+    const filter = await this.initFilter();
+    const result = await filter.isDisabled();
+    await this.cancel();
+    return result;
+  }
 };
 
 // src/pageObjects/elements/Forms/ListForm.ts