d5-testing-library 1.8.0-alpha.2 → 1.8.0-alpha.21

package/dist/{chunk-LTHDA5XH.mjs → chunk-PMZQRKUZ.mjs}

@@ -8,18 +8,19 @@ import {
   byTestId,
   byTestIdCssSelector,
   click,
+  contextMenu,
   createDocFilterTestId,
   createHeaderFilterTestId,
   createLayoutFilterTestId,
   createTableId,
   fixElementStaleError,
   wait,
-  waitElementIsClickable,
+  waitElementIsClickable_default,
   waitElementIsVisible
-} from "./chunk-ZT3B7BQ2.mjs";
+} from "./chunk-MV63JF3H.mjs";
 
 // src/pageObjects/elements/Table/Table.ts
-import { By as By5 } from "selenium-webdriver";
+import { By as By6 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Table/elements/Row.ts
 import { By as By3 } from "selenium-webdriver";
@@ -65,7 +66,31 @@ var Cell = class extends AbstractElementWithParent {
     for (const tag of tags) {
       values.push(await tag.getAttribute("textContent"));
     }
-    return values;
+    return values.length ? values : null;
+  }
+  async getNumberValue(cellEl) {
+    const value = (await cellEl.getText()).trim();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  async getDateValue(cellEl, cellElClass) {
+    const value = (await cellEl.getText()).trim();
+    if (value === "")
+      return null;
+    const isWithTime = cellElClass.includes("with-time");
+    try {
+      if (isWithTime) {
+        const [datePart, timePart] = value.split(", ");
+        const [day, month, year] = datePart.split(".").map(Number);
+        const [hours, minutes] = timePart.split(":").map(Number);
+        return new Date(Date.UTC(year, month - 1, day, hours, minutes));
+      } else {
+        const [day, month, year] = value.split(".").map(Number);
+        return new Date(Date.UTC(year, month - 1, day));
+      }
+    } catch (error) {
+      console.error(`Error parsing date value "${value}":`, error);
+      return null;
+    }
   }
   async getElement() {
     if (this._index == null) {
@@ -80,7 +105,12 @@ var Cell = class extends AbstractElementWithParent {
       return this.getBooleanValue(cellEl);
     if (cellElClass.includes("tags-column" /* Tags */))
       return this.getTagsValue(cellEl);
-    return cellEl.getText();
+    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;
@@ -94,10 +124,19 @@ var DX_DATA_ROW_CLASS = "dx-data-row";
 var Row = class extends AbstractElementWithParent {
   index;
   getColumnBy;
-  constructor(parentCssSelector, index, driver, 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;
     this.getColumnBy = getColumnBy;
+    this.fixedTableContentCssSelector = fixedTableContentCssSelector;
   }
   _getCell({ index, name, title }) {
     return new Cell(
@@ -147,12 +186,11 @@ var Row = class extends AbstractElementWithParent {
     return result;
   }
   async clickInlineButton(buttonClass) {
-    const FIXED_TABLE_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
     const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(
       this.index
     )}"] .${buttonClass}`;
     const button = await fixElementStaleError(
-      By3.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`),
+      By3.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`),
       this.driver
     );
     return click(button, this.driver);
@@ -235,14 +273,144 @@ var Column = class extends AbstractElementWithParent {
   }
 };
 
+// src/utils/typesUtil.ts
+import { isObject } from "selenium-webdriver/lib/util";
+var types = {
+  "[object Array]": "array",
+  "[object Date]": "date",
+  "[object Object]": "object",
+  "[object String]": "string",
+  "[object Null]": "null"
+};
+var type = function(object) {
+  const typeOfObject = Object.prototype.toString.call(object);
+  return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
+};
+var isArray = function(value) {
+  return type(value) === "array";
+};
+var isString = function(object) {
+  return typeof object === "string";
+};
+
+// src/pageObjects/elements/AbstractDropDownMenuList.ts
+var AbstractDropDownMenuList = class extends AbstractElementWithParent {
+  buttonNotDisplayedError(name) {
+    return `Menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+  async clickItemBy(errorMessage, by) {
+    await waitElementIsClickable_default({
+      errorMessage,
+      driver: this.driver,
+      by
+    });
+    const menuItemElement = await fixElementStaleError(by, this.driver);
+    await click(menuItemElement, this.driver);
+  }
+  async clickItemByPath(path, getBy) {
+    let pathList = isString(path) ? [path] : path;
+    for (let text of pathList) {
+      await this.clickItemBy(this.buttonNotDisplayedError(text), getBy(text));
+    }
+  }
+  clickButton(name) {
+    return this.clickItemByPath(name, this.getButtonNameBy.bind(this));
+  }
+  clickButtonByTitle(title) {
+    return this.clickItemByPath(title, this.getButtonTitleBy.bind(this));
+  }
+  isVisible() {
+    return Promise.resolve(true);
+  }
+};
+
+// src/pageObjects/elements/DXContextMenuList.ts
+import { By as By5 } from "selenium-webdriver";
+
+// src/utils/cssToXPath.ts
+function cssClassesToXPath(classNames) {
+  const classNamesList = classNames.split(".").filter((className) => !!className);
+  const chained = classNamesList.map((className) => `contains(@class, "${className}")`).join(" and ");
+  return `[${chained}]`;
+}
+
+// src/pageObjects/elements/DXContextMenuList.ts
+var CONTEXT_MENU_CLASS = "dx-context-menu";
+var CONTEXT_MENU_ITEM_TEXT_CLASS = "dx-menu-item-text";
+var DXContextMenuList = class extends AbstractDropDownMenuList {
+  /**
+   * @param parentCssSelector
+   * @param classNames - Список класів. Починається з крапки
+   * @param driver
+   */
+  constructor(parentCssSelector, classNames, driver) {
+    super(parentCssSelector, `.${CONTEXT_MENU_CLASS}${classNames}`, driver);
+  }
+  getButtonTitleBy(title) {
+    const buttonByTextXpath = (text) => `//span[contains(@class, "${CONTEXT_MENU_ITEM_TEXT_CLASS}") and contains(text(), "${text}")]`;
+    const xpath = "//div" + cssClassesToXPath(this.elementCssSelector) + buttonByTextXpath(title);
+    return By5.xpath(xpath);
+  }
+  async isVisible() {
+    try {
+      await waitElementIsVisible({
+        element: await this.driver.findElement(By5.css(`.dx-overlay-wrapper .dx-contextmenu`)),
+        driver: this.driver,
+        errorMessage: "Cannot find dropdown element"
+      });
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/pageObjects/elements/Table/elements/ContextMenu.ts
+var ContextMenu = class extends DXContextMenuList {
+  _formName;
+  _initFn;
+  constructor(cssClass, formName, driver) {
+    super("", cssClass, driver);
+    this._formName = formName;
+  }
+  setInit(cb) {
+    this._initFn = cb;
+    return this;
+  }
+  getButtonNameBy(name) {
+    return byTestId(`cm-${this._formName}-${name}`);
+  }
+  async clickButtonByTitle(title) {
+    await this._initFn?.();
+    await super.clickButtonByTitle(title);
+  }
+  async clickButton(name) {
+    await this._initFn?.();
+    await super.clickButton(name);
+  }
+};
+
 // src/pageObjects/elements/Table/Table.ts
 var Table = class extends AbstractElementWithParent {
   formName;
   headerCssSelector;
-  constructor(parentCssSelector, headerCssSelector, formName, driver) {
+  contextMenuCssSelector;
+  fixedTableContentCssSelector;
+  tableContentCssSelector;
+  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;
   }
   getColumnBy = (args) => {
     if (args.title) {
@@ -250,10 +418,18 @@ var Table = class extends AbstractElementWithParent {
     }
     return this.getColumnByName(args.name);
   };
+  /**
+   * Отримати рядок по індексу.
+   * @param index починається з 0
+   */
   getRowByIndex(index) {
-    return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+    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,
@@ -276,21 +452,32 @@ var Table = class extends AbstractElementWithParent {
       driver: this.driver
     });
   };
+  /**
+   * Вибрати рядок по індексу.
+   * @param index починається з 0
+   */
   selectRowByIndex(index) {
     return this.getRowByIndex(index).select();
   }
   async getRows() {
-    const rows = await this.driver.findElements(By5.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
+    const rowsFullCssSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
+    const rows = await this.driver.findElements(By6.css(rowsFullCssSelector));
     const result = [];
     rows.forEach((_, index) => {
-      const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+      const newRow = new Row(
+        this.getFullCssSelector(),
+        this.fixedTableContentCssSelector,
+        index,
+        this.driver,
+        this.getColumnBy
+      );
       result.push(newRow);
     });
     return result;
   }
   async getColumns() {
     const columns = await this.driver.findElements(
-      By5.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"]`)
+      By6.css(`${this.getFullCssSelector()} ${this.headerCssSelector} td[role="columnheader"] .header-template-text`)
     );
     const result = [];
     columns.forEach((_, index) => {
@@ -316,6 +503,50 @@ var Table = class extends AbstractElementWithParent {
   field(name) {
     return new FormField(this.getFullCssSelector(), this.formName, name, this.driver);
   }
+  /**
+   * Возвращает список строк которые выделены
+   * @returns Row[]
+   * @example
+   * const form = new MyForm();
+   * //...
+   * await form.getSelectedRows();
+   */
+  async getSelectedRows() {
+    const rows = await this.getRows();
+    let result = [];
+    for (const row of rows) {
+      if (await row.isSelected()) {
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  /**
+   * Вызывает контекстное меню в области с данными.
+   * @param fieldName - имя поля
+   * @param [rowIndex] - индекс строки. Если значение не передано, то по умолчанию контекстное меню будет вызвано на первой выделенной строке.
+   * @throws {Error} Если нет выделенных строк, то выбросит исключение.
+   * @example
+   * const form = new MyForm();
+   * //...
+   * await form.contextMenu('FieldName').clickButton('OpenFormButton');
+   * // or
+   * await form.contextMenu('FieldName', 3).clickButton(['Group', 'ButtonInGroup']);
+   */
+  contextMenu(fieldName, rowIndex) {
+    return new ContextMenu(this.contextMenuCssSelector, this.formName, this.driver).setInit(async () => {
+      let row;
+      if (rowIndex != null) {
+        row = this.getRowByIndex(rowIndex);
+      } else {
+        [row] = await this.getSelectedRows();
+      }
+      if (!row)
+        throw new Error("No row available row for context menu");
+      const cellElement = await row.getCell(fieldName).getElement();
+      await contextMenu(cellElement, this.driver);
+    });
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/ToolbarGroupButton.ts
@@ -343,75 +574,57 @@ var ToolbarButton = class extends AbstractButton {
   }
 };
 
-// src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
-import { By as By6 } from "selenium-webdriver";
-
-// src/utils/typesUtil.ts
-var types = {
-  "[object Array]": "array",
-  "[object Date]": "date",
-  "[object Object]": "object",
-  "[object String]": "string",
-  "[object Null]": "null"
-};
-var type = function(object) {
-  const typeOfObject = Object.prototype.toString.call(object);
-  return typeof object === "object" ? types[typeOfObject] || "object" : typeof object;
-};
-var isArray = function(value) {
-  return type(value) === "array";
-};
-var isString = function(object) {
-  return typeof object === "string";
+// src/pageObjects/elements/AbstractDropDownMenuButton.ts
+var AbstractDropDownMenuButton = class extends AbstractElementWithParent {
+  _list;
+  constructor(parentCssSelector, elementCssSelector, list, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this._list = list;
+  }
+  async openDropdownMenu() {
+    const dropdown = await this.getElement();
+    await click(dropdown, this.driver);
+    await this._list.isVisible();
+  }
+  async clickButton(name) {
+    await this.openDropdownMenu();
+    await this._list.clickButton(name);
+  }
+  async clickButtonByTitle(title) {
+    await this.openDropdownMenu();
+    await this._list.clickButtonByTitle(title);
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
 var SPINDOWN_CLASS = ".dx-icon-spindown";
 var buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
 var getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
-var buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
-var ToolbarMenu = class extends AbstractElementWithParent {
+var ToolbarMenuList = class extends DXContextMenuList {
   _formName;
-  constructor(parentCssSelector, formName, name, driver) {
-    super(parentCssSelector, getFullCssSelector(formName, name), driver);
+  constructor(parentCssSelector, elementCssSelector, formName, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
     this._formName = formName;
   }
-  async openDropdownMenu() {
-    const dropdown = await this.getElement();
-    await click(dropdown, this.driver);
-  }
-  getCssSelectorToButton(name) {
+  getButtonNameBy(name) {
     return byTestId(`ftb-${this._formName}-${name}`);
   }
-  buttonNotDisplayedError(name) {
-    return `Toolbar menu button ${name} cannot be clicked. It is not displayed or it is disabled`;
-  }
-  async goToButton(name, by) {
-    const toolbarMenuItem = await fixElementStaleError(by, this.driver);
-    await waitElementIsClickable({
-      element: toolbarMenuItem,
-      errorMessage: this.buttonNotDisplayedError(name),
-      driver: this.driver
-    });
-    await click(toolbarMenuItem, this.driver);
+};
+var ToolbarMenu = class extends AbstractDropDownMenuButton {
+  constructor(parentCssSelector, formName, name, driver) {
+    const fullSelector = getFullCssSelector(formName, name);
+    const list = new ToolbarMenuList(parentCssSelector, ".toolbar-dropdown-context-menu", formName, driver);
+    super(parentCssSelector, fullSelector, list, driver);
   }
   async clickButton(name) {
-    await this.openDropdownMenu();
     if (!isString(name) && !isArray(name))
       throw new Error(`"name" must be a string or array of string`);
-    let lName = isString(name) ? [name] : name;
-    for (let n of lName) {
-      await this.goToButton(n, this.getCssSelectorToButton(n));
-    }
+    await super.clickButton(name);
   }
   async clickButtonByTitle(title) {
-    await this.openDropdownMenu();
     if (!isString(title) && !isArray(title))
       throw new Error(`"title" must be a string or array of string`);
-    let lTitle = isString(title) ? [title] : title;
-    for (let t of lTitle) {
-      await this.goToButton(t, By6.xpath(buttonByTextXpath(t)));
-    }
+    await super.clickButtonByTitle(title);
   }
 };
 
@@ -445,6 +658,14 @@ var ToolbarItem = class extends AbstractElementWithParent {
     await this.init();
     return await this._button.isDisabled();
   }
+  async isDisplayed() {
+    try {
+      await this.init();
+      return this._button.isDisplayed();
+    } catch (error) {
+      return false;
+    }
+  }
   get menu() {
     return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
   }
@@ -492,7 +713,7 @@ var FilterOperation = class extends AbstractElementWithParent {
   }
   async initOperationWidget() {
     const widgetButtonEl = await this.getElement();
-    await waitElementIsClickable({
+    await waitElementIsClickable_default({
       element: widgetButtonEl,
       errorMessage: "Widget operation is not clickable",
       driver: this.driver
@@ -577,8 +798,15 @@ var FormFilterField = class extends AbstractEditor {
    * @example
    * await form.formFilter('NumberFld').setValue(123);
    * await form.formFilter('TextFld').setValue('TestValue');
+   * await form.formFilter('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
+    if (typeof operation === "string") {
+      await this.setOperation(operation);
+    }
+    if (typeof isBlank === "boolean") {
+      await this.setIsBlank(isBlank);
+    }
     return super.setValue(value);
   }
   /**
@@ -670,8 +898,15 @@ var PanelFilterField = class extends AbstractEditor {
    * @example
    * await form.filterPanel.filterField('NumberFld').setValue(123);
    * await form.filterPanel.filterField('TextFld').setValue('TestValue');
+   * await form.filterPanel.filterField('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
+    if (typeof operation === "string") {
+      await this.setOperation(operation);
+    }
+    if (typeof isBlank === "boolean") {
+      await this.setIsBlank(isBlank);
+    }
     return super.setValue(value);
   }
   /**
@@ -892,9 +1127,23 @@ var ColumnFilter = class extends AbstractElement {
    * @example
    * await form.columnFilter('NumberFld').setValue(123);
    * await form.columnFilter('TextFld').setValue('TestValue');
+   * await form.columnFilter('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
     const filter = await this.initFilter();
+    const filterOperation = new FilterOperation({
+      parentCssSelector: HEADER_FILTER_CONTAINER,
+      filterTestID: createHeaderFilterTestId(this._formName, this._name)
+    });
+    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);
     return this.apply();
   }
@@ -918,32 +1167,52 @@ var ColumnFilter = class extends AbstractElement {
     await filter.remove(itemText);
     return this.apply();
   }
-  // ToDo: Треба доробити після того, як буде реалізована логіка з editor buttons
+  /**
+   * Инициализация операции фильтра
+   */
   async initOperation() {
-    await this.initFilter();
+    const filter = await this.initFilter();
+    const inputEl = await filter.getElement();
+    await inputEl.click();
     return new FilterOperation({
       parentCssSelector: HEADER_FILTER_CONTAINER,
       filterTestID: createHeaderFilterTestId(this._formName, this._name)
     });
   }
-  // ToDo: Треба доробити після того, як буде реалізована логіка з editor buttons
+  /**
+   * Устанавливает операцию для фильтра
+   * @example
+   * await form.columnFilter('TagBox').setOperation("=");
+   */
   async setOperation(operationName) {
     const filterOperation = await this.initOperation();
     await filterOperation.setOperation(operationName);
     await this.apply();
   }
-  // ToDo: Треба доробити після того, як буде реалізована логіка з editor buttons
+  /**
+   * Возвращает операцию фильтра
+   * @example
+   * expect(await form.columnFilter('NumberFld').getOperation()).toBe("=");
+   */
   async getOperation() {
     const filterOperation = await this.initOperation();
     return await filterOperation.getOperation();
   }
-  // ToDo: Треба доробити після того, як буде реалізована логіка з editor buttons
+  /**
+   * Устанавливает операцию 'isblank' для фильтра
+   * @example
+   * await form.columnFilter('TagBox').setIsBlank(true);
+   */
   async setIsBlank(value) {
     const filterOperation = await this.initOperation();
     await filterOperation.setIsBlank(value);
     await this.apply();
   }
-  // ToDo: Треба доробити після того, як буде реалізована логіка з editor buttons
+  /**
+   * Возвращает true|false, если операция 'isblank' установлена для фильтра
+   * @example
+   * expect(await form.columnFilter('NumberFld').getIsBlank()).toBe(false);
+   */
   async getIsBlank() {
     const filterOperation = await this.initOperation();
     return await filterOperation.getIsBlank();
@@ -952,12 +1221,21 @@ var ColumnFilter = class extends AbstractElement {
 
 // src/pageObjects/elements/Forms/ListForm.ts
 var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
+var DATAGRID_CONTENT_CSS_SELECTOR = ".dx-datagrid-content:not(.dx-datagrid-content-fixed)";
+var FIXED_DATAGRID_CONTENT_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
+var CONTEXT_MENU_CSS_SELECTOR = ".dx-datagrid";
 var ListForm = class extends Form {
   headerCssSelector;
+  fixedTableContentCssSelector;
+  tableContentCssSelector;
+  contextMenuCssSelector;
   constructor(driver) {
     super(driver);
-    this.popupContainerCssSelector = `.popup .form-inline-${this.formName}`;
+    this.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;
   }
   /**
    * Находит таблицу
@@ -967,7 +1245,17 @@ var ListForm = class extends Form {
    * expect(listForm.table());
    */
   table() {
-    return new Table(this.containerCssSelector, this.headerCssSelector, this.formName, this.driver);
+    return new Table(
+      {
+        parentCssSelector: this.containerCssSelector,
+        headerCssSelector: this.headerCssSelector,
+        fixedTableContentCssSelector: this.fixedTableContentCssSelector,
+        formName: this.formName,
+        driver: this.driver,
+        contextMenuCssSelector: this.contextMenuCssSelector,
+        tableContentCssSelector: this.tableContentCssSelector
+      }
+    );
   }
   /**
    * Находит таблицу