d5-testing-library 1.4.0 → 1.5.0

package/dist/chunk-VWNH6HVN.mjs

@@ -0,0 +1,1106 @@
+// src/config.ts
+import * as process from "node:process";
+var driversMap = /* @__PURE__ */ new Map();
+var 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);
+    }
+  });
+};
+var Config = class _Config {
+  static instance;
+  appConfig;
+  static getInstance() {
+    if (!_Config.instance) {
+      _Config.instance = new _Config();
+    }
+    return _Config.instance;
+  }
+  config = (cfg) => {
+    if (!cfg)
+      return createConfigProxy(this.appConfig);
+    this.appConfig = cfg;
+  };
+};
+var configInstance = Config.getInstance();
+function config(cfg) {
+  return configInstance.config(cfg);
+}
+
+// src/pageObjects/AbstractElement.ts
+import { By } from "selenium-webdriver";
+
+// src/utils/fixElementStaleError.ts
+function fixElementStaleError(by, driver) {
+  const maxCount = 3;
+  let err;
+  const call = async (times = 0) => {
+    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 (err)
+      throw err;
+  };
+  return call();
+}
+
+// src/pageObjects/AbstractElement.ts
+var AbstractElement = class {
+  driver;
+  elementCssSelector;
+  constructor(driver, elementCssSelector) {
+    this.driver = driver || config().driver;
+    this.elementCssSelector = elementCssSelector;
+  }
+  getFullCssSelector() {
+    return this.elementCssSelector;
+  }
+  joinRelativeCssSelectors(selectors) {
+    return selectors.join(" ");
+  }
+  getElement() {
+    return fixElementStaleError(By.css(this.getFullCssSelector()), this.driver);
+  }
+  async getAttribute(attr) {
+    const element = await this.getElement();
+    return await element.getAttribute(attr);
+  }
+  async getClasses() {
+    return await this.getAttribute("class");
+  }
+  async getDataTestId() {
+    return await this.getAttribute("data-testid");
+  }
+};
+
+// src/pageObjects/pages/AbstractPage.ts
+var AbstractPage = class extends AbstractElement {
+  url;
+  host;
+  constructor(driver) {
+    super(driver);
+    this.host = config().auth.host;
+    this.url = this.host + this.prependHash(this.path);
+  }
+  prependHash(urlPath) {
+    if (!urlPath.startsWith("/#")) {
+      return `/#${urlPath}`;
+    }
+    return urlPath;
+  }
+  async goToUrl(url) {
+    await this.driver.get(url);
+  }
+  get path() {
+    return "/#";
+  }
+  async locate() {
+    await this.goToUrl(this.url);
+  }
+  async reloadPage() {
+    await this.driver.navigate().refresh();
+  }
+};
+
+// src/utils/wait.ts
+async function wait(condition, driver, errorMessage, timeout) {
+  driver = driver ?? config().driver;
+  await driver.wait(condition, timeout ?? config().timeout, errorMessage);
+}
+
+// src/utils/waitElementIsVisible.ts
+import { until } from "selenium-webdriver";
+async function waitElementIsVisible({
+  element,
+  timeout,
+  errorMessage,
+  driver
+}) {
+  driver = driver ?? config().driver;
+  const condition = until.elementIsVisible(element);
+  await wait(condition.fn, driver, errorMessage ?? condition.description(), timeout ?? config().timeout);
+}
+
+// src/utils/actions.ts
+var 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();
+};
+
+// src/utils/locators.ts
+import { By as By2 } from "selenium-webdriver";
+var byTestIdCssSelector = (testId, element = "div") => {
+  return `${element}[data-testid="${testId}"]`;
+};
+var byTestId = (testId, element = "div") => {
+  return By2.css(byTestIdCssSelector(testId, element));
+};
+var readonlyLocator = "readonly";
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+import { By as By3, Key } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
+var InputClearStrategy = class {
+  async clear(editor) {
+    const inputEl = await editor.getInputElement();
+    await inputEl.clear();
+  }
+};
+
+// src/pageObjects/AbstractElementWithParent.ts
+var AbstractElementWithParent = class extends AbstractElement {
+  parentCssSelector;
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(driver, elementCssSelector);
+    this.parentCssSelector = parentCssSelector;
+  }
+  getFullCssSelector() {
+    if (!this.elementCssSelector) {
+      return this.parentCssSelector;
+    }
+    if (!this.parentCssSelector) {
+      return this.elementCssSelector;
+    }
+    return `${this.parentCssSelector} ${this.elementCssSelector}`;
+  }
+  async isReadonly() {
+    const classSting = await this.getClasses();
+    return classSting.includes(readonlyLocator);
+  }
+};
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var AbstractDXEditorWithInput = class extends AbstractElementWithParent {
+  clearStrategy = new InputClearStrategy();
+  setClearStrategy(strategy) {
+    this.clearStrategy = strategy;
+  }
+  getInputCssSelector() {
+    return `${this.getFullCssSelector()} .dx-texteditor-input`;
+  }
+  async getInputElement() {
+    return this.driver.findElement(By3.css(this.getInputCssSelector()));
+  }
+  async getInputValue() {
+    const inputEl = await this.getInputElement();
+    return inputEl.getAttribute("value");
+  }
+  async setInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await click(inputEl, this.driver);
+    await inputEl.sendKeys(value, Key.ENTER);
+  }
+  async clear() {
+    await this.clearStrategy.clear(this);
+  }
+};
+
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor = class extends AbstractDXEditorWithInput {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  getValue() {
+    return this.getInputValue();
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor = class extends AbstractDXEditorWithInput {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/types.ts
+var ControlClass = /* @__PURE__ */ ((ControlClass2) => {
+  ControlClass2["Text"] = "text-control";
+  ControlClass2["TextArea"] = "text-area-control";
+  ControlClass2["Number"] = "number-control";
+  ControlClass2["CheckBox"] = "check-box";
+  ControlClass2["Multiselect"] = "multi-select-control";
+  ControlClass2["Select"] = "select-control";
+  ControlClass2["Switch"] = "switch-control";
+  ControlClass2["Date"] = "date-control";
+  ControlClass2["SingleDateRange"] = "single-date-range-control";
+  ControlClass2["BooleanSelector"] = "buttons-group";
+  ControlClass2["ButtonGroup"] = "button-group-field";
+  return ControlClass2;
+})(ControlClass || {});
+
+// src/pageObjects/AbstractFormElement.ts
+var AbstractFormElement = class extends AbstractElementWithParent {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/CheckBox.ts
+var CheckBox = class extends AbstractElementWithParent {
+  async getValue() {
+    const result = await this.getAttribute("aria-checked");
+    if (result === "true")
+      return 1;
+    if (result === "false")
+      return 0;
+    return null;
+  }
+  async setValue(value) {
+    const inputEl = await this.getElement();
+    const currentValue = await this.getValue();
+    if (currentValue !== value) {
+      await click(inputEl, this.driver);
+    }
+  }
+};
+
+// src/pageObjects/elements/Editors/SelectBoxEditor.ts
+import { By as By5, Key as Key2 } from "selenium-webdriver";
+
+// src/utils/xpathHelper.ts
+var XPathHelper = class {
+  static getClassAndValueXpath(cssClass, value) {
+    return `div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+  }
+};
+
+// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
+import { By as By4 } from "selenium-webdriver";
+var DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
+var DX_CLEAR_BUTTON_AREA = "dx-clear-button-area";
+var ClearButtonStrategy = class {
+  editorContainerClass;
+  _driver;
+  constructor(editorContainerClass, driver) {
+    this.editorContainerClass = editorContainerClass;
+    this._driver = driver;
+  }
+  async isEmptyEditorField() {
+    const editorContainer = await this._driver.findElement(By4.css(this.editorContainerClass));
+    const classAttribute = await editorContainer.getAttribute("class");
+    return classAttribute.includes(DX_TEXTEDITOR_EMPTY);
+  }
+  async clear() {
+    if (await this.isEmptyEditorField()) {
+      throw new Error("This field is already empty");
+    }
+    const clearBtnSelector = `${this.editorContainerClass} .${DX_CLEAR_BUTTON_AREA}`;
+    const clearBtn = await this._driver.findElement(By4.css(clearBtnSelector));
+    await click(clearBtn, this._driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/SelectBoxEditor.ts
+var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
+var combinedValueXpath = (value) => `//body/div[@id="root"]/div[contains(@class, "dx-overlay-wrapper")]//${XPathHelper.getClassAndValueXpath(SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, value)}`;
+var dropDownOptionClick = async (optionValue, driver, delay = true) => {
+  const { implicit } = await driver.manage().getTimeouts();
+  let optElement = null;
+  const timeout = delay ? implicit : 200;
+  let err = null;
+  try {
+    await driver.manage().setTimeouts({ implicit: timeout });
+    optElement = await driver.findElement(By5.xpath(combinedValueXpath(optionValue)));
+    await click(optElement, driver);
+  } catch (e) {
+    err = new Error(`Item not found: "${optionValue}"`);
+  } finally {
+    await driver.manage().setTimeouts({ implicit });
+  }
+  if (err)
+    throw err;
+};
+var SelectBoxEditor = class extends AbstractDXEditorWithInput {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+  }
+  async setSelectInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await click(inputEl, this.driver);
+    try {
+      await dropDownOptionClick(value, this.driver, false);
+    } catch {
+      await inputEl.sendKeys(value, Key2.ENTER);
+      await dropDownOptionClick(value, this.driver);
+    }
+  }
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : value;
+  }
+  setValue(value) {
+    return this.setSelectInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/SwitchEditor.ts
+var SwitchEditor = class extends AbstractElementWithParent {
+  async getValue() {
+    const result = await this.getAttribute("aria-label");
+    if (result === "ON")
+      return 1;
+    if (result === "OFF")
+      return 0;
+    return null;
+  }
+  async setValue(value) {
+    if (value !== 0 && value !== 1) {
+      value = value ? 1 : 0;
+    }
+    const inputEl = await this.getElement();
+    const currentValue = await this.getValue();
+    if (currentValue === value) {
+      return;
+    }
+    await click(inputEl, this.driver);
+    await wait(async () => {
+      const updatedValue = await this.getValue();
+      return updatedValue !== currentValue;
+    }, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/TagBox.ts
+import { By as By6 } from "selenium-webdriver";
+var TAGS_SELECTOR = ".dx-tag .tag-text";
+var DX_TAG_CONTAINER = "dx-tag-container";
+var DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
+var BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
+var TAG_BOX_LIST_ITEM_SELECTOR = '.dx-tagbox-popup-wrapper .dx-list-item[aria-selected="true"]';
+var TagBox = class extends AbstractDXEditorWithInput {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new ClearButtonStrategy(this.getFullCssSelector(), this.driver));
+  }
+  async setTagBoxInputValue(values) {
+    const lastElement = values[values.length - 1];
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    for (const value of values) {
+      await this.selectOption(inputEl, value, lastElement);
+    }
+    await this.confirmSelection();
+  }
+  async waitOptionSelection() {
+    const option = await this.driver.findElement(By6.css(TAG_BOX_LIST_ITEM_SELECTOR));
+    await wait(() => option.isDisplayed(), this.driver);
+  }
+  async selectOption(inputEl, value, lastElement) {
+    try {
+      await dropDownOptionClick(value, this.driver, false);
+    } catch {
+      await inputEl.sendKeys(value);
+      await dropDownOptionClick(value, this.driver);
+    }
+    await this.waitOptionSelection();
+    if (value !== lastElement) {
+      await inputEl.clear();
+    }
+  }
+  async confirmSelection() {
+    const btnOk = await this.driver.findElement(By6.css(BTN_OK_SELECTOR));
+    await click(btnOk, this.driver);
+  }
+  async getTagBoxInputValue() {
+    if (await this.isTagBoxEmpty()) {
+      return [];
+    }
+    const tags = await this.driver.findElements(
+      By6.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${TAGS_SELECTOR}`)
+    );
+    const values = [];
+    for (const tag of tags) {
+      values.push(await tag.getAttribute("textContent"));
+    }
+    return values;
+  }
+  async isTagBoxEmpty() {
+    const classAttribute = await this.getClasses();
+    return classAttribute.includes(DX_TEXTEDITOR_EMPTY2);
+  }
+  async getValue() {
+    const value = await this.getTagBoxInputValue();
+    return value.length ? value : null;
+  }
+  async setValue(values) {
+    if (!Array.isArray(values)) {
+      throw new Error("The provided value is not an array");
+    }
+    await this.setTagBoxInputValue(values);
+  }
+  async remove(itemText) {
+    const tagValues = await this.getValue();
+    const tagExists = tagValues.includes(itemText);
+    if (!tagExists) {
+      throw new Error(`The tag with the text: ${itemText} was not found`);
+    }
+    const clearBtnTestId = byTestIdCssSelector(`clear-button-${itemText}`);
+    const clearBtn = await this.driver.findElement(
+      By6.css(`${this.getFullCssSelector()} .${DX_TAG_CONTAINER} ${clearBtnTestId}`)
+    );
+    await click(clearBtn, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/ButtonGroup.ts
+import { By as By7 } from "selenium-webdriver";
+var ITEM_CLASS = "dx-buttongroup-item";
+var SELECTED_CLASS = "dx-state-selected";
+var ButtonGroup = class extends AbstractElementWithParent {
+  getItems() {
+    return this.driver.findElements(By7.css(`${this.getFullCssSelector()} .${ITEM_CLASS}`));
+  }
+  getDataValue(el) {
+    return el.getAttribute("data-value");
+  }
+  async getValue() {
+    const selectedEl = await this.driver.findElement(By7.css(`${this.getFullCssSelector()} .${ITEM_CLASS}.${SELECTED_CLASS}`));
+    return this.getDataValue(selectedEl);
+  }
+  async setValue(value) {
+    const items = await this.getItems();
+    let buttonEl = void 0;
+    for (const item of items) {
+      const text = await this.getDataValue(item);
+      if (text == value) {
+        buttonEl = item;
+        break;
+      }
+    }
+    if (!buttonEl)
+      throw new Error(`Cannot find item in button group with text: ${value}`);
+    await click(buttonEl, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/BooleanSelector.ts
+var BooleanSelector = class extends ButtonGroup {
+  // @ts-ignore
+  async getValue() {
+    const value = await super.getValue();
+    return value === "null" ? null : value === "1" ? 1 : 0;
+  }
+  // @ts-ignore
+  async setValue(value) {
+    const val = value == null ? "null" : value ? "1" : "0";
+    await super.setValue(val);
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
+import { By as By9 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
+import { By as By8, Key as Key3 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/Date/utils.ts
+var formatDMYDate = (date) => {
+  const [year, month, day] = date.toJSON().split("T")[0].split("-");
+  return `${day}${month}${year}`;
+};
+
+// src/pageObjects/elements/Editors/Date/BaseDateEditor.ts
+var BTN_CALENDAR_POPOVER_OPEN_SELECTOR = "calendar-popover-open-button";
+var BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR = "DateRange__inputs-item--dateFrom";
+var BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR = "DateRange__inputs-item--dateTo";
+var BTN_SAVE_SELECTOR = "DateRange__button-save";
+var BaseDateEditor = class extends AbstractDXEditorWithInput {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async setDateValue(value) {
+    const actions = this.driver.actions({ async: true });
+    const dateField = await this.driver.findElement(By8.css(`${this.getFullCssSelector()}`));
+    const dateFieldDataTestID = await this.getDataTestId();
+    const calendarPopoverSelector = byTestIdCssSelector(`${dateFieldDataTestID}-calendar-popover`);
+    const dateInputEl = await this.getInputElement();
+    await dateInputEl.clear();
+    if (Array.isArray(value)) {
+      const formattedDates = value.map(formatDMYDate);
+      const button = await dateField.findElement(By8.css(`.${BTN_CALENDAR_POPOVER_OPEN_SELECTOR}`));
+      await button.click();
+      const calendarPopoverElement = await this.driver.findElement(By8.css(calendarPopoverSelector));
+      const dateFromInput = await calendarPopoverElement.findElement(By8.css(`.${BTN_CALENDAR_POPOVER_DATE_FROM_INPUT_SELECTOR} .dx-texteditor-input`));
+      const dateToInput = await calendarPopoverElement.findElement(By8.css(`.${BTN_CALENDAR_POPOVER_DATE_TO_INPUT_SELECTOR} .dx-texteditor-input`));
+      await dateFromInput.click();
+      await dateFromInput.sendKeys(formattedDates[0]);
+      await dateToInput.click();
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.HOME).perform();
+      await dateToInput.sendKeys(formattedDates[1]);
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.ENTER).perform();
+      const btnOk = await this.driver.findElement(By8.css(`.${BTN_SAVE_SELECTOR}`));
+      await btnOk.click();
+    } else {
+      const formattedDate = formatDMYDate(value);
+      await click(dateInputEl, this.driver);
+      await actions.move({ origin: dateInputEl }).sendKeys(Key3.HOME).perform();
+      await actions.move({ origin: dateInputEl }).sendKeys(formattedDate, Key3.ENTER).perform();
+    }
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/SingleDateEditor.ts
+var SingleDateEditor = class extends BaseDateEditor {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getDateElement() {
+    return this.driver.findElement(By9.css(this.getFullCssSelector() + " .dx-dropdowneditor-input-wrapper input[type=hidden]"));
+  }
+  async getDateValue() {
+    const inputEl = await this.getDateElement();
+    return inputEl.getAttribute("value");
+  }
+  async getValue() {
+    const value = await this.getDateValue();
+    return value == "" ? null : new Date(value);
+  }
+  setValue(value) {
+    if (typeof value === "object") {
+      return this.setDateValue(value);
+    }
+    throw new Error(`Value is incorrect. It should be Object`);
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/DateRangeEditor.ts
+import { By as By10 } from "selenium-webdriver";
+var DateRangeEditor = class extends BaseDateEditor {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getDateElement() {
+    return this.driver.findElement(By10.css(this.getFullCssSelector() + " .dx-texteditor-input"));
+  }
+  async getDateValue() {
+    const inputEl = await this.getDateElement();
+    const dateFromStr = await inputEl.getAttribute("datefrom");
+    const dateToStr = await inputEl.getAttribute("dateto");
+    const dateFrom = new Date(dateFromStr);
+    const dateTo = new Date(dateToStr);
+    return [dateFrom, dateTo];
+  }
+  async getValue() {
+    const values = await this.getDateValue();
+    return !values.length ? null : values;
+  }
+  setValue(value) {
+    if (typeof value === "object") {
+      return this.setDateValue(value);
+    }
+    throw new Error(`Value is incorrect. It should be Object`);
+  }
+};
+
+// src/pageObjects/elements/Editors/Date/DateEditor.ts
+var DateEditor = class extends AbstractDXEditorWithInput {
+  editorInstance = null;
+  initPromise;
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+    this.initPromise = this.init(parentCssSelector, elementCssSelector, driver);
+  }
+  async init(parentCssSelector, elementCssSelector, driver) {
+    await this.updateEditorInstance(parentCssSelector, elementCssSelector, driver);
+  }
+  async updateEditorInstance(parentCssSelector, elementCssSelector, driver) {
+    const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+    const classString = await elementInstance.getClasses();
+    switch (true) {
+      case classString.includes("date-control" /* Date */):
+        this.editorInstance = new SingleDateEditor(parentCssSelector, elementCssSelector, driver);
+        break;
+      case classString.includes("single-date-range-control" /* SingleDateRange */):
+        this.editorInstance = new DateRangeEditor(parentCssSelector, elementCssSelector, driver);
+        break;
+      default:
+        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.");
+  }
+  async getValue() {
+    await this.ensureInitialized();
+    if (this.editorInstance) {
+      return this.editorInstance.getValue();
+    }
+    throw new Error("Editor instance is not initialized.");
+  }
+};
+
+// src/pageObjects/elements/Editors/editorFactory.ts
+var editorFactory = async (parentCssSelector, elementCssSelector, driver) => {
+  const elementInstance = new AbstractFormElement(parentCssSelector, elementCssSelector, driver);
+  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("select-control" /* Select */))
+    return new SelectBoxEditor(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);
+  }
+  if (classSting.includes("buttons-group" /* BooleanSelector */))
+    return new BooleanSelector(parentCssSelector, elementCssSelector, driver);
+  if (classSting.includes("button-group-field" /* ButtonGroup */))
+    return new ButtonGroup(parentCssSelector, elementCssSelector, driver);
+  throw new Error("Unknown type of editor. Please write ticket to the support");
+};
+
+// src/utils/createDataTestId.ts
+function createDataTestId(formName, itemType, itemName) {
+  return `${formName}-${itemType}-${itemName}`;
+}
+function createFieldTestId(formName, itemName) {
+  return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
+}
+function createGroupTestId(formName, itemName) {
+  return createDataTestId(formName, "group" /* GROUP */, itemName);
+}
+function createFilterTestId(formName, itemName, layout) {
+  return createDataTestId(formName, "filter" /* FILTER */, itemName) + `-${layout}`;
+}
+function createDocFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
+}
+function createLayoutFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
+}
+function createTableId(formName) {
+  return `${"table" /* TABLE */}-${formName}`;
+}
+function createFormButtonTestId(formName, itemName) {
+  return createDataTestId(formName, "button" /* BUTTON */, itemName);
+}
+
+// src/pageObjects/elements/AbstractEditor.ts
+var AbstractEditor = class extends AbstractElementWithParent {
+  editor;
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await editorFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+    }
+  }
+  /**
+   * Возвращает значение в поле
+   * @example
+   * expect(await formEdit.field('NumberFld').getValue()).toBe(10);
+   * expect(await formEdit.field('TextFld').getValue()).toBe('TestValue');
+   */
+  async getValue() {
+    await this.initEditor();
+    return this.editor.getValue();
+  }
+  /**
+   * Устанавливает значение в поле
+   * @example
+   * await formEdit.field('NumberFld').setValue(123);
+   * await formEdit.field('TextFld').setValue('TestValue');
+   */
+  async setValue(value) {
+    await this.initEditor();
+    return this.editor.setValue(value);
+  }
+  /**
+   * Очищает значение в поле
+   * @example
+   * await formEdit.field('NumberFld').clear();
+   */
+  async clear() {
+    await this.initEditor();
+    if (!this.editor.clear) {
+      throw new Error("The clear method is not available for this field type.");
+    }
+    return this.editor.clear();
+  }
+  /**
+   * Удаляет тег по переданному тексту
+   * @example
+   * await formEdit.field('TagBox').remove('test');
+   */
+  async remove(itemText) {
+    await this.initEditor();
+    if (!this.editor.remove) {
+      throw new Error("This method is only available for the TagBox field.");
+    }
+    return this.editor.remove(itemText);
+  }
+  /**
+   * Возвращает значение true|false в зависимости readOnly поле или нет
+   * @example
+   * expect(await formEdit.field('NumberFld').isReadonly()).toBe(true);
+   * expect(await formEdit.field('TextFld').isReadonly()).toBe(false);
+   */
+  async isReadonly() {
+    await this.initEditor();
+    return this.editor.isReadonly();
+  }
+};
+
+// src/pageObjects/elements/FormField.ts
+var FormField = class extends AbstractEditor {
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createFieldTestId(formName, name)), driver);
+  }
+};
+
+// src/pageObjects/elements/Forms/Form.ts
+import { By as By13 } from "selenium-webdriver";
+
+// 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);
+}
+
+// src/pageObjects/elements/TableToolbar/AbstractButton.ts
+var AbstractButton = class extends AbstractElementWithParent {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  async click() {
+    const button = await this.getElement();
+    await waitElementIsClickable({
+      element: button,
+      errorMessage: this.buttonNotDisplayedError(),
+      driver: this.driver
+    });
+    await click(button, this.driver);
+  }
+  async isDisabled() {
+    const button = await this.getElement();
+    return await button.getCssValue("pointer-events") === "none";
+  }
+};
+
+// src/pageObjects/elements/DXComponents/DXButton.ts
+import { By as By11 } from "selenium-webdriver";
+var DXButton = class extends AbstractButton {
+  async getText() {
+    const classes = await this.getClasses();
+    if (!classes.includes("dx-button-has-text")) {
+      return null;
+    }
+    const el = await this.getElement();
+    const textEl = el.findElement(By11.className("dx-button-text"));
+    return await textEl.getText();
+  }
+};
+
+// src/pageObjects/elements/FormButton.ts
+var FormButton = class extends DXButton {
+  name;
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createFormButtonTestId(formName, name)), driver);
+    this.name = name;
+  }
+  buttonNotDisplayedError() {
+    return `Form Button ${this.name} cannot be clicked. It is not displayed or it is disabled`;
+  }
+};
+
+// src/pageObjects/elements/Groups/AbstractGroup.ts
+var AbstractGroup = class extends AbstractElementWithParent {
+  async isDisplayed() {
+    const groupElement = await this.getElement();
+    return await groupElement.isDisplayed();
+  }
+};
+
+// src/pageObjects/elements/Groups/Panel.ts
+var Panel = class extends AbstractGroup {
+};
+
+// src/pageObjects/elements/Groups/TabPanel/TabPanel.ts
+import { By as By12 } from "selenium-webdriver";
+var getTabTestIdByName = (name) => `tab-caption-${name}`;
+var TabPanel = class extends AbstractGroup {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  _getTab(name) {
+    return this.driver.findElement(By12.css(`${this.getFullCssSelector()} ${byTestIdCssSelector(getTabTestIdByName(name))}`));
+  }
+  async tabClick(name) {
+    const tabEl = this._getTab(name);
+    await tabEl.click();
+  }
+};
+
+// src/pageObjects/elements/Groups/groupFactory.ts
+var 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("panel-group"))
+    return new Panel(parentCssSelector, elementCssSelector, driver);
+  throw new Error("Unknown type of group. Please write ticket to the support");
+};
+
+// src/pageObjects/elements/FormGroup.ts
+var FormGroup = class extends AbstractElementWithParent {
+  editor;
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+    }
+  }
+  /**
+   * Возвращает булевое значение доступна ли группа
+   * @example
+   * expect(await tableList.group('MainSuperPanel').isDisplayed();
+   */
+  async isDisplayed() {
+    try {
+      await this.initEditor();
+      return this.editor.isDisplayed();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Происходит клик по табе
+   * @example
+   * expect(await tableList.group('TabPanel').tabClick(tabName);
+   */
+  async tabClick(name) {
+    await this.initEditor();
+    await this.editor.tabClick(name);
+  }
+};
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm = class extends AbstractPage {
+  containerCssSelector = "";
+  _formName = "";
+  containerBy;
+  getContainerElement = () => {
+    return this.driver.findElement(this.containerBy);
+  };
+  set formName(name) {
+    this._formName = name;
+  }
+  get formName() {
+    return this._formName;
+  }
+  /**
+   * Возвращает true если форма есть в DOM
+   * @example
+   * class MyForm extends FormEdit {}
+   * //...
+   * const formEdit = new MyForm();
+   * expect(await formEdit.exists()).toBe(true);
+   */
+  async exists() {
+    try {
+      let elements = await this.driver.findElements(this.containerBy);
+      return elements.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  button(name) {
+    return new FormButton(this.containerCssSelector, this.formName, name, this.driver);
+  }
+  /**
+   * Находит группу на форме по имени
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * expect(await formEdit.group('Name');
+   */
+  group(name) {
+    return new FormGroup(this.containerCssSelector, this.formName, name, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Forms/createSubFormInstance.ts
+var subFormTestId = (name) => `subform-${name}`;
+function subformCssSelector(parentCssSelector, testId) {
+  return `${parentCssSelector} ${byTestIdCssSelector(testId)}`;
+}
+async function classDependencyInjector(formType) {
+  let SubFormFactoryClass;
+  switch (formType) {
+    case "1" /* LIST */:
+      SubFormFactoryClass = (await import("./ListForm-HDVXB6CG.mjs")).default;
+      break;
+    case "3" /* TREE */:
+      SubFormFactoryClass = (await import("./TreeView-DE5RBMDD.mjs")).default;
+      break;
+    case "2" /* EDIT */:
+    case "99" /* FREE_FORM */:
+    case "4" /* REPORT */:
+      SubFormFactoryClass = (await import("./FormEdit-MZJH5R5H.mjs")).default;
+      break;
+    default:
+      throw new Error(`Unsupported form type ${formType}`);
+  }
+  return SubFormFactoryClass;
+}
+
+// src/pageObjects/elements/Forms/Form.ts
+var formTestId = (formName) => `form-content-wrapper-${formName}`;
+var Form = class extends AbstractForm {
+  popupContainerCssSelector;
+  constructor(driver) {
+    super(driver);
+    this.setSubFormMode();
+  }
+  async isModal() {
+    const el = await this.getContainerElement();
+    const value = await el.getAttribute("data-ismodal");
+    return value === "true";
+  }
+  /**
+   * Получение заголовка на формы
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(await listForm.getTitleText()).toBe('MyFormTitle');
+   */
+  async getTitleText() {
+    if (await this.isModal()) {
+      const titleEl2 = await this.driver.findElement(By13.css(`${this.popupContainerCssSelector} .popup-title`));
+      return titleEl2.getText();
+    }
+    let titleEl = await this.driver.findElement(By13.className("main-toolbar-form-title"));
+    return titleEl.getText();
+  }
+  setSubFormMode() {
+    const testId = formTestId(this.formName);
+    this.containerBy = byTestId(testId);
+    this.containerCssSelector = byTestIdCssSelector(testId);
+  }
+  /**
+   * Возвращает сабформу
+   * @returns {Promise<ListForm | TreeView | FormEdit>}
+   * @example
+   * const form = new MyForm();
+   * //...
+   * expect(await form.subForm(name));
+   */
+  async subForm(name) {
+    const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name));
+    const byCssSelector = By13.css(cssSelector);
+    const subFormEl = await this.driver.findElement(byCssSelector);
+    await waitElementIsVisible({
+      element: subFormEl,
+      driver: this.driver,
+      errorMessage: `Subform "${name}" is not visible`
+    });
+    const formType = await subFormEl.getAttribute("data-formtype");
+    const formName = await subFormEl.getAttribute("data-formname");
+    let SubFormFactoryClass = await classDependencyInjector(formType);
+    const SubForm = class extends SubFormFactoryClass {
+      setSubFormMode() {
+        this.containerCssSelector = cssSelector;
+        this.containerBy = byCssSelector;
+      }
+      get formName() {
+        return formName;
+      }
+    };
+    return new SubForm(this.driver);
+  }
+};
+
+export {
+  config,
+  fixElementStaleError,
+  AbstractElement,
+  AbstractPage,
+  wait,
+  waitElementIsVisible,
+  click,
+  byTestIdCssSelector,
+  byTestId,
+  readonlyLocator,
+  AbstractElementWithParent,
+  createDocFilterTestId,
+  createLayoutFilterTestId,
+  createTableId,
+  waitElementIsClickable,
+  AbstractButton,
+  TextEditor,
+  NumberEditor,
+  ControlClass,
+  editorFactory,
+  AbstractEditor,
+  FormField,
+  Form
+};