d5-testing-library 1.0.0

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

@@ -0,0 +1,354 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractPage: () => AbstractPage,
+  FormEdit: () => FormEdit,
+  FormField: () => FormField,
+  ListForm: () => ListForm,
+  LoginPage: () => LoginPage,
+  NumberEditor: () => NumberEditor,
+  SubsystemsPanel: () => SubsystemsPanel,
+  TextEditor: () => TextEditor,
+  byTestId: () => byTestId,
+  config: () => config,
+  createDriver: () => createDriver,
+  editorFactory: () => editorFactory,
+  elementIsNotPresent: () => elementIsNotPresent,
+  signIn: () => signIn
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var Config = class _Config {
+  static instance;
+  appConfig;
+  static getInstance() {
+    if (!_Config.instance) {
+      _Config.instance = new _Config();
+    }
+    return _Config.instance;
+  }
+  config = (cfg) => {
+    if (!cfg)
+      return this.appConfig;
+    this.appConfig = cfg;
+  };
+};
+var configInstance = Config.getInstance();
+function config(cfg) {
+  return configInstance.config(cfg);
+}
+
+// src/pageObjects/AbstractElement.ts
+var AbstractElement = class {
+  driver;
+  constructor(driver) {
+    this.driver = driver || config().driver;
+  }
+};
+
+// 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/locators.ts
+var import_selenium_webdriver = require("selenium-webdriver");
+var byTestId = (testId, element = "div") => {
+  return import_selenium_webdriver.By.css(`${element}[data-testid=${testId}]`);
+};
+
+// src/utils/createDriver.ts
+var import_selenium_webdriver2 = require("selenium-webdriver");
+var createDriver = async (browser) => {
+  const driver = await new import_selenium_webdriver2.Builder().forBrowser(browser ?? config().browser).build();
+  const manage = driver.manage();
+  await manage.setTimeouts({ implicit: config().timeout });
+  await manage.window().maximize();
+  return driver;
+};
+
+// src/utils/elementIsNotPresent.ts
+var import_selenium_webdriver3 = require("selenium-webdriver");
+var elementIsNotPresent = function elementIsNotPresent2(locator) {
+  return new import_selenium_webdriver3.Condition("for no element to be located " + locator, function(driver) {
+    return driver.findElements(locator).then(function(elements) {
+      return elements.length == 0;
+    });
+  });
+};
+
+// src/pageObjects/AbstractElementWithParent.ts
+var AbstractElementWithParent = class extends AbstractElement {
+  getParentElement;
+  elementBy;
+  constructor(getParentElement, driver) {
+    super(driver);
+    this.getParentElement = getParentElement;
+  }
+  async getElement() {
+    const parentEl = await this.getParentElement();
+    return parentEl.findElement(this.elementBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
+var SubsystemsPanelHeader = class extends AbstractElementWithParent {
+  titleBy = byTestId("subsystems-panel-title", "span");
+  async title() {
+    const panel = await this.getParentElement();
+    return panel.findElement(this.titleBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+var import_selenium_webdriver4 = require("selenium-webdriver");
+var SubsystemsPanel = class extends AbstractElement {
+  panelBy = import_selenium_webdriver4.By.id("aside");
+  header;
+  constructor(driver) {
+    super(driver);
+    this.header = new SubsystemsPanelHeader(this.panelElement, this.driver);
+  }
+  panelElement = () => {
+    return this.driver.findElement(this.panelBy);
+  };
+  headerTitle() {
+    return this.header.title().then((el) => el.getText());
+  }
+};
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm = class extends AbstractPage {
+  containerBy;
+  constructor(driver) {
+    super(driver);
+    this.containerBy = byTestId(`form-content-wrapper-${this.formName}`);
+  }
+  getContainerElement = () => {
+    return this.driver.findElement(this.containerBy);
+  };
+  get formName() {
+    return "";
+  }
+  async exists() {
+    try {
+      await this.driver.wait(elementIsNotPresent(this.containerBy), 1e3);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+var import_selenium_webdriver6 = require("selenium-webdriver");
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var import_selenium_webdriver5 = require("selenium-webdriver");
+
+// src/pageObjects/AbstractFormElement.ts
+var AbstractFormElement = class extends AbstractElementWithParent {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, driver);
+    this.elementBy = elementBy;
+  }
+};
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var AbstractDXEditorWithInput = class extends AbstractFormElement {
+  async getInputElement() {
+    const controlEl = await this.getElement();
+    return controlEl.findElement(import_selenium_webdriver5.By.className("dx-texteditor-input"));
+  }
+  async getInputValue() {
+    const inputEl = await this.getInputElement();
+    return inputEl.getAttribute("value");
+  }
+  async setInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    await inputEl.sendKeys(value, import_selenium_webdriver5.Key.ENTER);
+  }
+};
+
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor = class extends AbstractDXEditorWithInput {
+  getValue() {
+    return this.getInputValue();
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor = class extends AbstractDXEditorWithInput {
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/editorFactory.ts
+var editorFactory = async (getParentElement, elementBy, driver) => {
+  const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
+  const element = await elementInstance.getElement();
+  const classSting = await element.getAttribute("class");
+  if (classSting.includes("text-control"))
+    return new TextEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("number-control"))
+    return new NumberEditor(getParentElement, elementBy, 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);
+}
+
+// src/pageObjects/elements/FormField.ts
+var FormField = class extends AbstractElementWithParent {
+  editor;
+  constructor(getParentElement, formName, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = byTestId(createFieldTestId(formName, name));
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await editorFactory(this.getParentElement, this.elementBy, this.driver);
+    }
+  }
+  async getValue() {
+    await this.initEditor();
+    return this.editor.getValue();
+  }
+  async setValue(value) {
+    await this.initEditor();
+    return this.editor.setValue(value);
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+var FormEdit = class extends AbstractForm {
+  saveButtonBy = import_selenium_webdriver6.By.id("button-save");
+  field(name) {
+    return new FormField(this.getContainerElement, this.formName, name, this.driver);
+  }
+  async saveButtonClick() {
+    await this.driver.findElement(this.saveButtonBy).click();
+  }
+};
+
+// src/pageObjects/elements/Forms/ListForm.ts
+var import_selenium_webdriver7 = require("selenium-webdriver");
+var ListForm = class extends AbstractForm {
+  titleBy = import_selenium_webdriver7.By.className("form-toolbar-name-container");
+  getTitleText() {
+    return this.getContainerElement().then((el) => el.findElement(this.titleBy)).then((el) => el.getText());
+  }
+};
+
+// src/utils/signIn.ts
+async function signIn(driver) {
+  const webDriver = driver ?? await createDriver();
+  config().driver = webDriver;
+  const loginPage = new LoginPage(webDriver);
+  await loginPage.locate();
+  await loginPage.authorize();
+  return webDriver;
+}
+
+// src/pageObjects/pages/LoginPage.ts
+var LOGIN_PATH = "/login";
+var LoginPage = class extends AbstractPage {
+  usernameField = byTestId("loginField", "input");
+  passwordField = byTestId("passwordField", "input");
+  loginButton = byTestId("loginButton");
+  get path() {
+    return LOGIN_PATH;
+  }
+  async enterUsername(username) {
+    await this.driver.findElement(this.usernameField).sendKeys(username);
+  }
+  async enterPassword(password) {
+    await this.driver.findElement(this.passwordField).sendKeys(password);
+  }
+  async clickLoginButton() {
+    await this.driver.findElement(this.loginButton).click();
+  }
+  async loginWith(username, password) {
+    await this.enterUsername(username);
+    await this.enterPassword(password);
+    await this.clickLoginButton();
+  }
+  async authorize() {
+    await this.loginWith(config().auth.login, config().auth.password);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractPage,
+  FormEdit,
+  FormField,
+  ListForm,
+  LoginPage,
+  NumberEditor,
+  SubsystemsPanel,
+  TextEditor,
+  byTestId,
+  config,
+  createDriver,
+  editorFactory,
+  elementIsNotPresent,
+  signIn
+});

package/dist/d5-testing-library.d.ts

@@ -0,0 +1,140 @@
+import * as selenium_webdriver from 'selenium-webdriver';
+import { WebDriver, Browser, By, Condition, WebElementPromise } from 'selenium-webdriver';
+
+type DriverType = typeof Browser;
+type BrowserList = DriverType[keyof DriverType];
+type IConfig = {
+    auth: {
+        host: string;
+        login: string;
+        password: string;
+    };
+    timeout: number;
+    browser: BrowserList;
+    driver?: WebDriver;
+};
+declare function config(cfg?: IConfig): IConfig;
+
+declare abstract class AbstractElement {
+    protected driver: WebDriver;
+    protected constructor(driver?: WebDriver);
+}
+
+declare abstract class AbstractPage extends AbstractElement {
+    protected url: string;
+    protected host: string;
+    constructor(driver?: WebDriver);
+    private prependHash;
+    protected goToUrl(url: string): Promise<void>;
+    protected get path(): string;
+    locate(): Promise<void>;
+    reloadPage(): Promise<void>;
+}
+
+declare class LoginPage extends AbstractPage {
+    usernameField: selenium_webdriver.By;
+    passwordField: selenium_webdriver.By;
+    loginButton: selenium_webdriver.By;
+    get path(): string;
+    enterUsername(username: string): Promise<void>;
+    enterPassword(password: string): Promise<void>;
+    clickLoginButton(): Promise<void>;
+    loginWith(username: string, password: string): Promise<void>;
+    authorize(): Promise<void>;
+}
+
+/**
+ * Returns a By locator object that can be used to locate an element by its test ID.
+ *
+ * @param {string} testId - The test ID of the element.
+ * @param {string} [element='div'] - The HTML tag name of the element (optional).
+ * @returns {By} - The By locator object.
+ */
+declare const byTestId: (testId: string, element?: string) => By;
+
+/**
+ * Creates a WebDriver instance for the specified browser.
+ * If no browser parameter is provided, it uses the default browser specified in the configuration.
+ * The default timeout is also set based on the configuration.
+ *
+ * @param {BrowserList} browser - The browser to create the WebDriver instance for.
+ * @returns {Promise<WebDriver>} A promise that resolves to the WebDriver instance.
+ */
+declare const createDriver: (browser?: BrowserList) => Promise<WebDriver>;
+
+declare const elementIsNotPresent: (locator: By) => Condition<boolean>;
+
+declare function signIn(driver?: WebDriver): Promise<WebDriver>;
+
+declare class SubsystemsPanel extends AbstractElement {
+    private panelBy;
+    private header;
+    constructor(driver?: WebDriver);
+    private panelElement;
+    headerTitle(): Promise<string>;
+}
+
+declare abstract class AbstractForm extends AbstractPage {
+    protected containerBy: By;
+    constructor(driver?: WebDriver);
+    protected getContainerElement: () => selenium_webdriver.WebElementPromise;
+    protected get formName(): string;
+    exists(): Promise<boolean>;
+}
+
+declare abstract class AbstractElementWithParent extends AbstractElement {
+    protected getParentElement: () => WebElementPromise;
+    protected elementBy: By;
+    constructor(getParentElement: () => WebElementPromise, driver?: WebDriver);
+    getElement(): Promise<selenium_webdriver.WebElement>;
+}
+
+interface Editor {
+    setValue(value: any): Promise<void>;
+    getValue(): Promise<any>;
+}
+
+declare class AbstractFormElement extends AbstractElementWithParent {
+    constructor(getParentElement: () => WebElementPromise, elementBy: By, driver?: WebDriver);
+}
+
+declare abstract class AbstractDXEditorWithInput extends AbstractFormElement implements Editor {
+    protected getInputElement(): Promise<selenium_webdriver.WebElement>;
+    protected getInputValue(): Promise<string>;
+    protected setInputValue(value: string): Promise<void>;
+    abstract setValue(value: any): Promise<void>;
+    abstract getValue(): Promise<any>;
+}
+
+declare class TextEditor extends AbstractDXEditorWithInput {
+    getValue(): Promise<string>;
+    setValue(value: string): Promise<void>;
+}
+
+declare class NumberEditor extends AbstractDXEditorWithInput {
+    getValue(): Promise<number | null>;
+    setValue(value: any): Promise<void>;
+}
+
+declare const editorFactory: (getParentElement: () => WebElementPromise, elementBy: By, driver?: WebDriver) => Promise<Editor>;
+
+declare class FormField extends AbstractElementWithParent implements Editor {
+    editor: Editor;
+    constructor(getParentElement: () => WebElementPromise, formName: string, name: string, driver?: WebDriver);
+    private initEditor;
+    getValue(): Promise<any>;
+    setValue(value: any): Promise<void>;
+}
+
+declare abstract class FormEdit extends AbstractForm {
+    saveButtonBy: By;
+    field(name: string): FormField;
+    saveButtonClick(): Promise<void>;
+}
+
+declare abstract class ListForm extends AbstractForm {
+    titleBy: By;
+    getTitleText(): Promise<string>;
+}
+
+export { AbstractPage, Editor, FormEdit, FormField, ListForm, LoginPage, NumberEditor, SubsystemsPanel, TextEditor, byTestId, config, createDriver, editorFactory, elementIsNotPresent, signIn };

package/dist/d5-testing-library.legacy-esm.js

@@ -0,0 +1,314 @@
+// src/config.ts
+var Config = class _Config {
+  static instance;
+  appConfig;
+  static getInstance() {
+    if (!_Config.instance) {
+      _Config.instance = new _Config();
+    }
+    return _Config.instance;
+  }
+  config = (cfg) => {
+    if (!cfg)
+      return this.appConfig;
+    this.appConfig = cfg;
+  };
+};
+var configInstance = Config.getInstance();
+function config(cfg) {
+  return configInstance.config(cfg);
+}
+
+// src/pageObjects/AbstractElement.ts
+var AbstractElement = class {
+  driver;
+  constructor(driver) {
+    this.driver = driver || config().driver;
+  }
+};
+
+// 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/locators.ts
+import { By } from "selenium-webdriver";
+var byTestId = (testId, element = "div") => {
+  return By.css(`${element}[data-testid=${testId}]`);
+};
+
+// src/utils/createDriver.ts
+import { Builder } from "selenium-webdriver";
+var createDriver = async (browser) => {
+  const driver = await new Builder().forBrowser(browser ?? config().browser).build();
+  const manage = driver.manage();
+  await manage.setTimeouts({ implicit: config().timeout });
+  await manage.window().maximize();
+  return driver;
+};
+
+// src/utils/elementIsNotPresent.ts
+import { Condition } from "selenium-webdriver";
+var elementIsNotPresent = function elementIsNotPresent2(locator) {
+  return new Condition("for no element to be located " + locator, function(driver) {
+    return driver.findElements(locator).then(function(elements) {
+      return elements.length == 0;
+    });
+  });
+};
+
+// src/pageObjects/AbstractElementWithParent.ts
+var AbstractElementWithParent = class extends AbstractElement {
+  getParentElement;
+  elementBy;
+  constructor(getParentElement, driver) {
+    super(driver);
+    this.getParentElement = getParentElement;
+  }
+  async getElement() {
+    const parentEl = await this.getParentElement();
+    return parentEl.findElement(this.elementBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
+var SubsystemsPanelHeader = class extends AbstractElementWithParent {
+  titleBy = byTestId("subsystems-panel-title", "span");
+  async title() {
+    const panel = await this.getParentElement();
+    return panel.findElement(this.titleBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+import { By as By3 } from "selenium-webdriver";
+var SubsystemsPanel = class extends AbstractElement {
+  panelBy = By3.id("aside");
+  header;
+  constructor(driver) {
+    super(driver);
+    this.header = new SubsystemsPanelHeader(this.panelElement, this.driver);
+  }
+  panelElement = () => {
+    return this.driver.findElement(this.panelBy);
+  };
+  headerTitle() {
+    return this.header.title().then((el) => el.getText());
+  }
+};
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm = class extends AbstractPage {
+  containerBy;
+  constructor(driver) {
+    super(driver);
+    this.containerBy = byTestId(`form-content-wrapper-${this.formName}`);
+  }
+  getContainerElement = () => {
+    return this.driver.findElement(this.containerBy);
+  };
+  get formName() {
+    return "";
+  }
+  async exists() {
+    try {
+      await this.driver.wait(elementIsNotPresent(this.containerBy), 1e3);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+import { By as By5 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+import { By as By4, Key } from "selenium-webdriver";
+
+// src/pageObjects/AbstractFormElement.ts
+var AbstractFormElement = class extends AbstractElementWithParent {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, driver);
+    this.elementBy = elementBy;
+  }
+};
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var AbstractDXEditorWithInput = class extends AbstractFormElement {
+  async getInputElement() {
+    const controlEl = await this.getElement();
+    return controlEl.findElement(By4.className("dx-texteditor-input"));
+  }
+  async getInputValue() {
+    const inputEl = await this.getInputElement();
+    return inputEl.getAttribute("value");
+  }
+  async setInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    await inputEl.sendKeys(value, Key.ENTER);
+  }
+};
+
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor = class extends AbstractDXEditorWithInput {
+  getValue() {
+    return this.getInputValue();
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor = class extends AbstractDXEditorWithInput {
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/editorFactory.ts
+var editorFactory = async (getParentElement, elementBy, driver) => {
+  const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
+  const element = await elementInstance.getElement();
+  const classSting = await element.getAttribute("class");
+  if (classSting.includes("text-control"))
+    return new TextEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("number-control"))
+    return new NumberEditor(getParentElement, elementBy, 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);
+}
+
+// src/pageObjects/elements/FormField.ts
+var FormField = class extends AbstractElementWithParent {
+  editor;
+  constructor(getParentElement, formName, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = byTestId(createFieldTestId(formName, name));
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await editorFactory(this.getParentElement, this.elementBy, this.driver);
+    }
+  }
+  async getValue() {
+    await this.initEditor();
+    return this.editor.getValue();
+  }
+  async setValue(value) {
+    await this.initEditor();
+    return this.editor.setValue(value);
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+var FormEdit = class extends AbstractForm {
+  saveButtonBy = By5.id("button-save");
+  field(name) {
+    return new FormField(this.getContainerElement, this.formName, name, this.driver);
+  }
+  async saveButtonClick() {
+    await this.driver.findElement(this.saveButtonBy).click();
+  }
+};
+
+// src/pageObjects/elements/Forms/ListForm.ts
+import { By as By6 } from "selenium-webdriver";
+var ListForm = class extends AbstractForm {
+  titleBy = By6.className("form-toolbar-name-container");
+  getTitleText() {
+    return this.getContainerElement().then((el) => el.findElement(this.titleBy)).then((el) => el.getText());
+  }
+};
+
+// src/utils/signIn.ts
+async function signIn(driver) {
+  const webDriver = driver ?? await createDriver();
+  config().driver = webDriver;
+  const loginPage = new LoginPage(webDriver);
+  await loginPage.locate();
+  await loginPage.authorize();
+  return webDriver;
+}
+
+// src/pageObjects/pages/LoginPage.ts
+var LOGIN_PATH = "/login";
+var LoginPage = class extends AbstractPage {
+  usernameField = byTestId("loginField", "input");
+  passwordField = byTestId("passwordField", "input");
+  loginButton = byTestId("loginButton");
+  get path() {
+    return LOGIN_PATH;
+  }
+  async enterUsername(username) {
+    await this.driver.findElement(this.usernameField).sendKeys(username);
+  }
+  async enterPassword(password) {
+    await this.driver.findElement(this.passwordField).sendKeys(password);
+  }
+  async clickLoginButton() {
+    await this.driver.findElement(this.loginButton).click();
+  }
+  async loginWith(username, password) {
+    await this.enterUsername(username);
+    await this.enterPassword(password);
+    await this.clickLoginButton();
+  }
+  async authorize() {
+    await this.loginWith(config().auth.login, config().auth.password);
+  }
+};
+export {
+  AbstractPage,
+  FormEdit,
+  FormField,
+  ListForm,
+  LoginPage,
+  NumberEditor,
+  SubsystemsPanel,
+  TextEditor,
+  byTestId,
+  config,
+  createDriver,
+  editorFactory,
+  elementIsNotPresent,
+  signIn
+};

package/dist/d5-testing-library.mjs

@@ -0,0 +1,314 @@
+// src/config.ts
+var Config = class _Config {
+  static instance;
+  appConfig;
+  static getInstance() {
+    if (!_Config.instance) {
+      _Config.instance = new _Config();
+    }
+    return _Config.instance;
+  }
+  config = (cfg) => {
+    if (!cfg)
+      return this.appConfig;
+    this.appConfig = cfg;
+  };
+};
+var configInstance = Config.getInstance();
+function config(cfg) {
+  return configInstance.config(cfg);
+}
+
+// src/pageObjects/AbstractElement.ts
+var AbstractElement = class {
+  driver;
+  constructor(driver) {
+    this.driver = driver || config().driver;
+  }
+};
+
+// 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/locators.ts
+import { By } from "selenium-webdriver";
+var byTestId = (testId, element = "div") => {
+  return By.css(`${element}[data-testid=${testId}]`);
+};
+
+// src/utils/createDriver.ts
+import { Builder } from "selenium-webdriver";
+var createDriver = async (browser) => {
+  const driver = await new Builder().forBrowser(browser ?? config().browser).build();
+  const manage = driver.manage();
+  await manage.setTimeouts({ implicit: config().timeout });
+  await manage.window().maximize();
+  return driver;
+};
+
+// src/utils/elementIsNotPresent.ts
+import { Condition } from "selenium-webdriver";
+var elementIsNotPresent = function elementIsNotPresent2(locator) {
+  return new Condition("for no element to be located " + locator, function(driver) {
+    return driver.findElements(locator).then(function(elements) {
+      return elements.length == 0;
+    });
+  });
+};
+
+// src/pageObjects/AbstractElementWithParent.ts
+var AbstractElementWithParent = class extends AbstractElement {
+  getParentElement;
+  elementBy;
+  constructor(getParentElement, driver) {
+    super(driver);
+    this.getParentElement = getParentElement;
+  }
+  async getElement() {
+    const parentEl = await this.getParentElement();
+    return parentEl.findElement(this.elementBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanelHeader.ts
+var SubsystemsPanelHeader = class extends AbstractElementWithParent {
+  titleBy = byTestId("subsystems-panel-title", "span");
+  async title() {
+    const panel = await this.getParentElement();
+    return panel.findElement(this.titleBy);
+  }
+};
+
+// src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
+import { By as By3 } from "selenium-webdriver";
+var SubsystemsPanel = class extends AbstractElement {
+  panelBy = By3.id("aside");
+  header;
+  constructor(driver) {
+    super(driver);
+    this.header = new SubsystemsPanelHeader(this.panelElement, this.driver);
+  }
+  panelElement = () => {
+    return this.driver.findElement(this.panelBy);
+  };
+  headerTitle() {
+    return this.header.title().then((el) => el.getText());
+  }
+};
+
+// src/pageObjects/elements/Forms/AbstractForm.ts
+var AbstractForm = class extends AbstractPage {
+  containerBy;
+  constructor(driver) {
+    super(driver);
+    this.containerBy = byTestId(`form-content-wrapper-${this.formName}`);
+  }
+  getContainerElement = () => {
+    return this.driver.findElement(this.containerBy);
+  };
+  get formName() {
+    return "";
+  }
+  async exists() {
+    try {
+      await this.driver.wait(elementIsNotPresent(this.containerBy), 1e3);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+import { By as By5 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+import { By as By4, Key } from "selenium-webdriver";
+
+// src/pageObjects/AbstractFormElement.ts
+var AbstractFormElement = class extends AbstractElementWithParent {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, driver);
+    this.elementBy = elementBy;
+  }
+};
+
+// src/pageObjects/elements/Editors/AbstractEditor.ts
+var AbstractDXEditorWithInput = class extends AbstractFormElement {
+  async getInputElement() {
+    const controlEl = await this.getElement();
+    return controlEl.findElement(By4.className("dx-texteditor-input"));
+  }
+  async getInputValue() {
+    const inputEl = await this.getInputElement();
+    return inputEl.getAttribute("value");
+  }
+  async setInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    await inputEl.sendKeys(value, Key.ENTER);
+  }
+};
+
+// src/pageObjects/elements/Editors/TextEditor.ts
+var TextEditor = class extends AbstractDXEditorWithInput {
+  getValue() {
+    return this.getInputValue();
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/NumberEditor.ts
+var NumberEditor = class extends AbstractDXEditorWithInput {
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : Number.parseFloat(value);
+  }
+  setValue(value) {
+    return this.setInputValue(value);
+  }
+};
+
+// src/pageObjects/elements/Editors/editorFactory.ts
+var editorFactory = async (getParentElement, elementBy, driver) => {
+  const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
+  const element = await elementInstance.getElement();
+  const classSting = await element.getAttribute("class");
+  if (classSting.includes("text-control"))
+    return new TextEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("number-control"))
+    return new NumberEditor(getParentElement, elementBy, 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);
+}
+
+// src/pageObjects/elements/FormField.ts
+var FormField = class extends AbstractElementWithParent {
+  editor;
+  constructor(getParentElement, formName, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = byTestId(createFieldTestId(formName, name));
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await editorFactory(this.getParentElement, this.elementBy, this.driver);
+    }
+  }
+  async getValue() {
+    await this.initEditor();
+    return this.editor.getValue();
+  }
+  async setValue(value) {
+    await this.initEditor();
+    return this.editor.setValue(value);
+  }
+};
+
+// src/pageObjects/elements/Forms/FormEdit.ts
+var FormEdit = class extends AbstractForm {
+  saveButtonBy = By5.id("button-save");
+  field(name) {
+    return new FormField(this.getContainerElement, this.formName, name, this.driver);
+  }
+  async saveButtonClick() {
+    await this.driver.findElement(this.saveButtonBy).click();
+  }
+};
+
+// src/pageObjects/elements/Forms/ListForm.ts
+import { By as By6 } from "selenium-webdriver";
+var ListForm = class extends AbstractForm {
+  titleBy = By6.className("form-toolbar-name-container");
+  getTitleText() {
+    return this.getContainerElement().then((el) => el.findElement(this.titleBy)).then((el) => el.getText());
+  }
+};
+
+// src/utils/signIn.ts
+async function signIn(driver) {
+  const webDriver = driver ?? await createDriver();
+  config().driver = webDriver;
+  const loginPage = new LoginPage(webDriver);
+  await loginPage.locate();
+  await loginPage.authorize();
+  return webDriver;
+}
+
+// src/pageObjects/pages/LoginPage.ts
+var LOGIN_PATH = "/login";
+var LoginPage = class extends AbstractPage {
+  usernameField = byTestId("loginField", "input");
+  passwordField = byTestId("passwordField", "input");
+  loginButton = byTestId("loginButton");
+  get path() {
+    return LOGIN_PATH;
+  }
+  async enterUsername(username) {
+    await this.driver.findElement(this.usernameField).sendKeys(username);
+  }
+  async enterPassword(password) {
+    await this.driver.findElement(this.passwordField).sendKeys(password);
+  }
+  async clickLoginButton() {
+    await this.driver.findElement(this.loginButton).click();
+  }
+  async loginWith(username, password) {
+    await this.enterUsername(username);
+    await this.enterPassword(password);
+    await this.clickLoginButton();
+  }
+  async authorize() {
+    await this.loginWith(config().auth.login, config().auth.password);
+  }
+};
+export {
+  AbstractPage,
+  FormEdit,
+  FormField,
+  ListForm,
+  LoginPage,
+  NumberEditor,
+  SubsystemsPanel,
+  TextEditor,
+  byTestId,
+  config,
+  createDriver,
+  editorFactory,
+  elementIsNotPresent,
+  signIn
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "d5-testing-library",
+  "version": "1.0.0",
+  "description": "e2e testing D5 projects",
+  "main": "dist/cjs/d5-testing-library.cjs",
+  "module": "dist/d5-testing-library.legacy-esm.js",
+  "types": "dist/d5-testing-library.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/d5-testing-library.d.ts",
+      "import": "./dist/d5-testing-library.mjs",
+      "default": "./dist/cjs/d5-testing-library.cjs"
+    }
+  },
+  "repository": "",
+  "engines": {
+    "node": ">18"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsup",
+    "changelog": "node ./scripts/releaseChangelog.mjs changelog -p v1.0.0",
+    "prepublishOnly": "yarn clean",
+    "prepack": "yarn build"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "selenium-webdriver": "^4.17.0",
+    "typescript": "5.3.3"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.9",
+    "@types/node": "^20.11.16",
+    "@types/selenium-webdriver": "^4.1.21",
+    "commander": "12.0.0",
+    "esbuild-extra": "^0.3.1",
+    "rimraf": "^5.0.5",
+    "tsup": "7.0.0"
+  },
+  "peerDependencies": {
+    "selenium-webdriver": "^4.17.0"
+  }
+}