@dynatrace/strato-components-testing 1.18.0 → 3.0.1

package/esm/jest/testing-helpers/tables/datatable.js

@@ -0,0 +1,794 @@
+import { act, fireEvent, screen, within } from "@testing-library/react";
+import { PointerEventsCheckLevel } from "@testing-library/user-event";
+import { setupUserEvent } from "../utils/setup-user-event.js";
+class DataTableSubRowsHelper {
+  constructor(rootHelper) {
+    this.rootHelper = rootHelper;
+  }
+  async getSubRowButton(rowId) {
+    try {
+      return within(this.rootHelper.element).getByLabelText(
+        "subrow with id",
+        {
+          suggest: false,
+          selector: `[data-rowid="${CSS.escape(rowId)}"] button`,
+          exact: false
+        }
+      );
+    } catch {
+      throw new Error(`Unable to locate subrow expander with id "${rowId}"`);
+    }
+  }
+  get getToggleAllSubRowsButton() {
+    return within(this.rootHelper.element).getByLabelText(
+      /Collapse all subrows|Expand all subrows/
+    );
+  }
+  /**
+   * Return the expanded state of the passed subrow id.
+   */
+  async getSubRowStateById(rowId) {
+    const subRowButton = await this.getSubRowButton(rowId);
+    return subRowButton.getAttribute("aria-expanded") === "true";
+  }
+  /**
+   * Expands the given row identified by the passed rowId if it not yet expanded.
+   */
+  async expandRowById(rowId) {
+    const subRowButton = await this.getSubRowButton(rowId);
+    if (subRowButton.getAttribute("aria-expanded") === "false") {
+      const userEvent = setupUserEvent();
+      await userEvent.click(subRowButton);
+    }
+  }
+  /**
+   * Collapses the given row identified by the passed rowId if not yet collapsed.
+   */
+  async collapseRowById(rowId) {
+    const subRowButton = await this.getSubRowButton(rowId);
+    if (subRowButton.getAttribute("aria-expanded") === "true") {
+      const userEvent = setupUserEvent();
+      await userEvent.click(subRowButton);
+    }
+  }
+  /**
+   * Toggles the expanded state of a given row identified by the passed rowId if not yet collapsed.
+   */
+  async toggleSubRowById(rowId) {
+    const subRowButton = await this.getSubRowButton(rowId);
+    const userEvent = setupUserEvent();
+    await userEvent.click(subRowButton);
+  }
+  /**
+   * Expands/Collapses all sub rows in the table.
+   */
+  async toggleAllSubRows() {
+    const toggleAllButton = this.getToggleAllSubRowsButton;
+    const userEvent = setupUserEvent();
+    await userEvent.click(toggleAllButton);
+  }
+}
+class DataTableRowSelectionHelper {
+  constructor(rootHelper) {
+    this.rootHelper = rootHelper;
+  }
+  async getCheckboxById(id) {
+    return await within(
+      this.rootHelper.element
+    ).findByLabelText(
+      `Toggle row selection for row with id "${id}".`,
+      {
+        suggest: false,
+        selector: "input"
+      }
+    );
+  }
+  async getCheckboxSelectAll() {
+    return await within(
+      this.rootHelper.element
+    ).findByLabelText(
+      // A partial of both options that could be in the aria label.
+      /select all rows/i,
+      {
+        suggest: false,
+        selector: "input"
+      }
+    );
+  }
+  /**
+   * Ticks the selection checkbox for a row if it is not yet selected.
+   */
+  async selectRowById(id) {
+    const checkbox = await this.getCheckboxById(id);
+    if (checkbox) {
+      if (!checkbox.checked) {
+        fireEvent.click(checkbox);
+      }
+    }
+  }
+  /**
+   * Unselects the selection checkbox for a row if it is not selected.
+   */
+  async deselectRowById(id) {
+    const checkbox = await this.getCheckboxById(id);
+    if (checkbox) {
+      if (checkbox.checked) {
+        fireEvent.click(checkbox);
+      }
+    }
+  }
+  /**
+   * Toggles selection on the row.
+   */
+  async toggleSelectionRowById(id) {
+    const checkbox = await this.getCheckboxById(id);
+    if (checkbox) {
+      fireEvent.click(checkbox);
+    }
+  }
+  /**
+   * Toggles selection on the row with the Shift key pressed (batch selection).
+   */
+  async shiftToggleSelectionRowById(id) {
+    const checkbox = await this.getCheckboxById(id);
+    if (checkbox) {
+      fireEvent.click(checkbox, { shiftKey: true });
+    }
+  }
+  /**
+   * Returns the selection state for the row with the given ID.
+   */
+  async getSelectionStateById(id) {
+    const checkbox = await this.getCheckboxById(id);
+    return checkbox.indeterminate === true ? "indeterminate" : checkbox.checked;
+  }
+  /**
+   * Returns a selection state for the currently shown checkboxes (current page).
+   * Hint: Elements might be virtualized or not shown on this page.
+   */
+  async getSelectionState() {
+    const rows = await within(this.rootHelper.element).findAllByRole("row", {
+      hidden: true
+    });
+    const selectionState = {};
+    for (const row of rows) {
+      const rowId = row.getAttribute("data-rowid");
+      if (!rowId) {
+        continue;
+      }
+      const checkbox = within(
+        this.rootHelper.element
+      ).queryByLabelText(
+        `Toggle row selection for row with id "${rowId}".`,
+        {
+          suggest: false,
+          selector: "input"
+        }
+      );
+      if (!checkbox) {
+        continue;
+      }
+      selectionState[rowId] = checkbox.indeterminate ? "indeterminate" : checkbox.checked;
+    }
+    return selectionState;
+  }
+  async isSelectAllDisabled() {
+    const checkbox = await this.getCheckboxSelectAll();
+    const disabled = checkbox.getAttribute("aria-disabled");
+    return disabled === "true";
+  }
+  async getSelectAllState() {
+    const checkbox = await this.getCheckboxSelectAll();
+    const value = checkbox.getAttribute("aria-checked");
+    if (value === "true") {
+      return true;
+    } else if (value === "false") {
+      return false;
+    } else if (value === "mixed") {
+      return "indeterminate";
+    }
+    throw new Error(
+      "Could not determine the state of the select all checkbox."
+    );
+  }
+  async toggleSelectAll() {
+    const checkbox = await this.getCheckboxSelectAll();
+    fireEvent.click(checkbox);
+  }
+}
+class DataTableUserActionHelper {
+  constructor(dataTestId) {
+    this.dataTestId = dataTestId;
+  }
+  /**
+   * Gets the root element of the DataTable
+   */
+  get element() {
+    return screen.getByTestId(this.dataTestId);
+  }
+  /**
+   * Lets you call a HeaderAction registered on the DataTable
+   */
+  async activateHeaderAction(headerName, actionName) {
+    const headerCells = await within(this.element).findAllByRole(
+      "columnheader",
+      { hidden: true }
+    );
+    const headerCell = headerCells.find(
+      (element) => element.textContent === headerName
+    );
+    const headerCellRow = headerCell?.getAttribute("data-header-row");
+    const headerCellColumn = headerCell?.getAttribute("data-column");
+    const headerButton = document.querySelector(
+      `[data-testid="${this.dataTestId}"] button[data-trigger="useraction"][data-header-row="${headerCellRow}"][data-column="${headerCellColumn}"]`
+    );
+    if (!headerButton) {
+      throw new Error(`Could not find header button for ${headerName}`);
+    }
+    fireEvent.click(headerButton);
+    const menuItem = await screen.findByRole("menuitem", {
+      hidden: true,
+      name: actionName
+    });
+    fireEvent.click(menuItem);
+  }
+  /**
+   * Lets you call a CellAction registered on the DataTable
+   */
+  async activateCellAction(headerName, row, actionName) {
+    const userEvent = setupUserEvent({
+      pointerEventsCheck: PointerEventsCheckLevel.Never
+    });
+    const header = await within(this.element).findByRole("columnheader", {
+      hidden: true,
+      name: headerName
+    });
+    const columnIndex = header.getAttribute("data-column");
+    const cellActionTrigger = document.querySelector(
+      `[data-testid="${this.dataTestId}"] [data-row="${row}"] [data-column="${columnIndex}"]`
+    );
+    if (cellActionTrigger) {
+      await userEvent.pointer({
+        keys: "[MouseRight]",
+        target: cellActionTrigger
+      });
+      const menuItem = await screen.findByRole("menuitem", {
+        hidden: true,
+        name: actionName
+      });
+      await userEvent.click(menuItem);
+    } else {
+      throw new Error(
+        `No cell action for ${headerName} (index: ${columnIndex}) / ${row} was found.`
+      );
+    }
+  }
+  /**
+   * Lets you call a RowAction registered on the DataTable
+   */
+  async activateRowAction(row, actionName) {
+    const userEvent = setupUserEvent({
+      pointerEventsCheck: PointerEventsCheckLevel.Never
+    });
+    const header = this.element.querySelector(
+      '[role="columnheader"][data-columnid="DataTableRowActions"]'
+    );
+    if (!header) {
+      throw new Error("No RowActions column was found.");
+    }
+    const columnIndex = header.getAttribute("data-column");
+    const rowActionsCell = document.querySelector(
+      `[data-testid="${this.dataTestId}"] [data-row="${row}"] [data-column="${columnIndex}"]`
+    );
+    if (rowActionsCell) {
+      const directRowActionButton = await within(rowActionsCell).findByRole(
+        "button",
+        { name: actionName }
+      );
+      await userEvent.click(directRowActionButton);
+    } else {
+      throw new Error(
+        `No RowActions cell (column: ${columnIndex}) / ${row} was found.`
+      );
+    }
+  }
+}
+class DataTablePaginationHelper {
+  constructor(dataTestId) {
+    this.dataTestId = dataTestId;
+  }
+  /**
+   * Gets the root element of the DataTable
+   */
+  get element() {
+    return screen.getByTestId(this.dataTestId);
+  }
+  get paginationElement() {
+    return within(this.element).getByRole("navigation", { hidden: true });
+  }
+  get pageSizeSelect() {
+    const inputElement = within(
+      this.paginationElement
+    ).getByLabelText(/Select page size/, {
+      suggest: false
+    });
+    const triggerElement = inputElement.closest('[type="button"]');
+    if (triggerElement) {
+      return triggerElement;
+    }
+    throw new Error("Trigger for the pageSizeSelect was not found.");
+  }
+  get pageIndexSelect() {
+    const inputElement = within(
+      this.paginationElement
+    ).getByLabelText(/Select current page/, {
+      suggest: false
+    });
+    const triggerElement = inputElement.closest('[type="button"]');
+    if (triggerElement) {
+      return triggerElement;
+    }
+    throw new Error("Trigger for the pageIndexSelect was not found.");
+  }
+  /**
+   * Allows you to set the pageSize via the select in the DataTable Pagination.
+   * @param pageSize - Target pageSize the pagination should be set to.
+   */
+  async setPageSizeTo(pageSize) {
+    await act(async () => {
+      fireEvent.click(this.pageSizeSelect);
+    });
+    const controlsInput = this.pageSizeSelect.querySelector("[aria-controls]");
+    const controlsAria = controlsInput?.getAttribute("aria-controls");
+    if (controlsAria) {
+      const portalOutletElement = document.getElementById(controlsAria);
+      if (portalOutletElement) {
+        try {
+          const selectedOption = within(portalOutletElement).getByRole(
+            "option",
+            {
+              name: `${pageSize}`,
+              hidden: true
+            }
+          );
+          if (selectedOption.getAttribute("aria-selected") === "true") {
+            const userEvent = setupUserEvent();
+            await userEvent.keyboard("{Escape /}");
+            return;
+          }
+          await act(async () => {
+            fireEvent.click(selectedOption);
+          });
+        } catch (error) {
+          throw new Error(error);
+        }
+      }
+    }
+  }
+  /**
+   * Allows you to set the pageIndex via the select in the DataTable Pagination.
+   * @param pageIndex - pageIndex you want to navigate to. 0 based value
+   */
+  async setPageIndex(pageIndex) {
+    act(() => {
+      fireEvent.click(this.pageIndexSelect);
+    });
+    const controlsInput = this.pageIndexSelect.querySelector("[aria-controls]");
+    const controlsAria = controlsInput?.getAttribute("aria-controls");
+    if (controlsAria) {
+      const portalOutletElement = document.getElementById(controlsAria);
+      if (portalOutletElement) {
+        try {
+          const selectedOption = within(portalOutletElement).getByRole(
+            "option",
+            {
+              name: `${pageIndex + 1}`,
+              hidden: true
+            }
+          );
+          if (selectedOption.getAttribute("aria-selected") === "true") {
+            const userEvent = setupUserEvent();
+            await userEvent.keyboard("{Escape /}");
+            return;
+          }
+          act(() => {
+            fireEvent.click(selectedOption);
+          });
+        } catch (error) {
+          throw new Error(error);
+        }
+      }
+    }
+  }
+  /**
+   * Allows you to go to the next page using the "Next page" button.
+   */
+  async goToNextPage() {
+    const nextButton = screen.getByRole("button", { name: /Go to next page/ });
+    const userEvent = setupUserEvent();
+    await userEvent.click(nextButton);
+  }
+  /**
+   * Allows you to go to the previous page using the "Previous page" button.
+   */
+  async goToPreviousPage() {
+    const previousButton = screen.getByRole("button", {
+      name: /Go to previous page/
+    });
+    const userEvent = setupUserEvent();
+    await userEvent.click(previousButton);
+  }
+}
+const getSortCombination = (current, target) => {
+  if (!current || current === "other" || !target) {
+    return void 0;
+  }
+  return `from-${current}-to-${target}`;
+};
+class DataTableSortingHelper {
+  constructor(dataTestId, rootHelper) {
+    this.dataTestId = dataTestId;
+    this.rootHelper = rootHelper;
+  }
+  /**
+   * Gets the root element of the DataTable
+   */
+  get element() {
+    return screen.getByTestId(this.dataTestId);
+  }
+  /**
+   * Get a column header by header name
+   */
+  async getColumnHeader(headerName) {
+    return (await within(this.element).findByLabelText(headerName)).closest(
+      '[role="columnheader"]'
+    );
+  }
+  /**
+   * Will return the current sorting direction of the column provided by the parameter.
+   */
+  async getSortingDirection(headerName) {
+    const header = await this.getColumnHeader(headerName);
+    if (header) {
+      return header.getAttribute("aria-sort");
+    }
+    return null;
+  }
+  /**
+   * Will return the current `sortDescFirst` attribute of the column provided by the parameter.
+   */
+  async getSortDescFirst(headerName) {
+    const header = await this.getColumnHeader(headerName);
+    if (header) {
+      return header.dataset.sortDescFirst === "true";
+    }
+    return false;
+  }
+  /**
+   * Lets you sort the column.
+   */
+  async sortColumn(headerName, options) {
+    const userEvent = setupUserEvent({
+      pointerEventsCheck: PointerEventsCheckLevel.Never
+    });
+    const header = await this.getColumnHeader(headerName);
+    const [currentSortDirection, sortDescFirst] = await Promise.all([
+      this.getSortingDirection(headerName),
+      this.getSortDescFirst(headerName)
+    ]);
+    const columnIndex = header?.getAttribute("data-column") || null;
+    const headerRowIndex = header?.getAttribute("data-header-row") || null;
+    if (columnIndex === null || headerRowIndex === null) {
+      return;
+    }
+    const headerButtonTrigger = document.querySelector(
+      `[data-testid="${this.dataTestId}"] [data-header-row="${headerRowIndex}"][data-column="${columnIndex}"]`
+    );
+    const actionType = headerButtonTrigger?.getAttribute("aria-label")?.includes("sorting") ? "sortButton" : "headerAction";
+    if (!headerButtonTrigger || !actionType) {
+      return;
+    }
+    if (actionType === "headerAction") {
+      const actionName = `Sort ${options?.direction}`;
+      await this.rootHelper.userActions.activateHeaderAction(
+        headerName,
+        actionName
+      );
+      return;
+    }
+    if (options?.multiSorting) {
+      await userEvent.keyboard("[ShiftLeft>]");
+    }
+    const combination = getSortCombination(
+      currentSortDirection,
+      options?.direction
+    );
+    if (!combination) {
+      await userEvent.click(headerButtonTrigger);
+      return;
+    }
+    if (sortDescFirst) {
+      switch (combination) {
+        case "from-none-to-ascending": {
+          await userEvent.click(headerButtonTrigger);
+          await userEvent.click(headerButtonTrigger);
+          return;
+        }
+        case "from-none-to-descending": {
+          await userEvent.click(headerButtonTrigger);
+          return;
+        }
+        case "from-ascending-to-descending": {
+          await userEvent.click(headerButtonTrigger);
+          await userEvent.click(headerButtonTrigger);
+          return;
+        }
+        case "from-descending-to-ascending": {
+          await userEvent.click(headerButtonTrigger);
+          return;
+        }
+      }
+    }
+    switch (combination) {
+      case "from-none-to-ascending": {
+        await userEvent.click(headerButtonTrigger);
+        return;
+      }
+      case "from-none-to-descending": {
+        await userEvent.click(headerButtonTrigger);
+        await userEvent.click(headerButtonTrigger);
+        return;
+      }
+      case "from-ascending-to-descending": {
+        await userEvent.click(headerButtonTrigger);
+        return;
+      }
+      case "from-descending-to-ascending": {
+        await userEvent.click(headerButtonTrigger);
+        await userEvent.click(headerButtonTrigger);
+        return;
+      }
+    }
+  }
+}
+class DataTableInteractiveRowsHelper {
+  constructor(_rootHelper) {
+    this._rootHelper = _rootHelper;
+  }
+  /**
+   * Returns the id of the currently active row or null if no rows are selected.
+   */
+  async getActivatedRowId() {
+    const activatedRow = await within(
+      this._rootHelper.element
+    ).queryByLabelText(/Deactivate row with id/i, {
+      selector: '[data-trigger="interactive-row"]'
+    });
+    if (activatedRow) {
+      return activatedRow.getAttribute("data-rowid") ?? null;
+    }
+    return null;
+  }
+  /**
+   * Toggles the row identified by the given rowId as active.
+   */
+  async toggleActiveRow(rowId) {
+    const activatedRow = await within(this._rootHelper.element).findByLabelText(
+      /(Activate|Deactivate) row with id/i,
+      {
+        selector: `[data-rowid="${CSS.escape(
+          rowId
+        )}"][data-trigger="interactive-row"]`
+      }
+    );
+    const userEvent = setupUserEvent();
+    await userEvent.click(activatedRow);
+  }
+}
+class DataTableDownloadHelper {
+  constructor(rootHelper) {
+    this.rootHelper = rootHelper;
+  }
+  async getDownloadMenuTrigger() {
+    const menuToggle = await within(
+      this.rootHelper.element
+    ).getByLabelText(/Download table data/, {
+      suggest: false,
+      selector: "button"
+    });
+    return menuToggle;
+  }
+  async openDownloadMenu() {
+    const isMenuOpen = await this.isMenuOpen();
+    if (!isMenuOpen) {
+      const trigger = await this.getDownloadMenuTrigger();
+      const userEvent = setupUserEvent();
+      await userEvent.click(trigger);
+    }
+  }
+  async isMenuOpen() {
+    const trigger = await this.getDownloadMenuTrigger();
+    return trigger.getAttribute("aria-expanded") === "true";
+  }
+  async getMenuItem(name) {
+    return screen.getByRole("menuitem", { suggest: false, hidden: true, name });
+  }
+  /**
+   * Activates the _download all_ item in the DataTable.Toolbar menu.
+   */
+  async downloadAllCSV() {
+    await this.openDownloadMenu();
+    const csvSubMenu = await this.getMenuItem("Download as CSV");
+    fireEvent.click(csvSubMenu);
+    const downloadAll = await this.getMenuItem("All");
+    fireEvent.click(downloadAll);
+  }
+  /**
+   * Activates the _download current page_ item in the DataTable.Toolbar menu.
+   */
+  async downloadPageCSV() {
+    await this.openDownloadMenu();
+    const csvSubMenu = await this.getMenuItem("Download as CSV");
+    fireEvent.click(csvSubMenu);
+    const downloadAll = await this.getMenuItem("Current page");
+    fireEvent.click(downloadAll);
+  }
+  /**
+   * Activates the _download selected_ item in the DataTable.Toolbar menu.
+   */
+  async downloadSelectedRowsCSV() {
+    await this.openDownloadMenu();
+    const csvSubMenu = await this.getMenuItem("Download as CSV");
+    fireEvent.click(csvSubMenu);
+    const downloadAll = await this.getMenuItem(/Selected rows/);
+    fireEvent.click(downloadAll);
+  }
+}
+class DataTableExpandableRowHelper {
+  constructor(rootHelper) {
+    this.rootHelper = rootHelper;
+  }
+  getExpandedRowIds() {
+    const expandedRows = this.rootHelper.element.querySelectorAll(
+      '[role="row"][data-rowid$="-expanded"]'
+    );
+    const result = [];
+    for (const expandedRow of Array.from(expandedRows)) {
+      const { rowid } = expandedRow.dataset;
+      if (rowid) {
+        result.push(rowid.replace("-expanded", ""));
+      }
+    }
+    return result;
+  }
+  async expandRowById(rowId) {
+    const rowDetailsTrigger = await within(
+      this.rootHelper.element
+    ).findByLabelText(/Expand row with id/, {
+      suggest: false,
+      exact: false,
+      selector: `[data-rowid="${CSS.escape(rowId)}"] button`
+    });
+    if (rowDetailsTrigger) {
+      const expanded = rowDetailsTrigger.getAttribute("aria-expanded");
+      if (expanded === "false") {
+        const userEvent = setupUserEvent();
+        await userEvent.click(rowDetailsTrigger);
+      }
+    }
+  }
+  async collapseRowById(rowId) {
+    const rowDetailsTrigger = await within(
+      this.rootHelper.element
+    ).findByLabelText(/Collapse row with id/, {
+      suggest: false,
+      exact: false,
+      selector: `[data-rowid="${CSS.escape(rowId)}"] button`
+    });
+    if (rowDetailsTrigger) {
+      const expanded = rowDetailsTrigger.getAttribute("aria-expanded");
+      if (expanded === "true") {
+        const userEvent = setupUserEvent();
+        await userEvent.click(rowDetailsTrigger);
+      }
+    }
+  }
+  async toggleRowById(rowId) {
+    const rowDetailsTrigger = await within(
+      this.rootHelper.element
+    ).findByLabelText(/(Expand|Collapse) row with id/, {
+      suggest: false,
+      exact: false,
+      selector: `[data-rowid="${CSS.escape(rowId)}"] button`
+    });
+    if (rowDetailsTrigger) {
+      const userEvent = setupUserEvent();
+      await userEvent.click(rowDetailsTrigger);
+    }
+  }
+}
+class DataTableHelper {
+  constructor(dataTestId) {
+    this.dataTestId = dataTestId;
+    this.userActions = new DataTableUserActionHelper(dataTestId);
+    this.pagination = new DataTablePaginationHelper(dataTestId);
+    this.sorting = new DataTableSortingHelper(dataTestId, this);
+    this.rowSelection = new DataTableRowSelectionHelper(this);
+    this.subRows = new DataTableSubRowsHelper(this);
+    this.interactiveRows = new DataTableInteractiveRowsHelper(this);
+    this.download = new DataTableDownloadHelper(this);
+    this.expandableRows = new DataTableExpandableRowHelper(this);
+  }
+  get tableElement() {
+    return within(this.element).getByRole("grid", { hidden: true });
+  }
+  getHeaderRow(index) {
+    const headerCells = this.tableElement.querySelectorAll(
+      `[role="columnheader"][data-header-row="${index}"]`
+    );
+    return Array.from(headerCells);
+  }
+  getAllCellsInBodyRow(index) {
+    const rowCells = this.tableElement.querySelectorAll(
+      `[data-rowgroup="body"] [data-row="${index}"] [role="cell"]`
+    );
+    return Array.from(rowCells);
+  }
+  userActions;
+  pagination;
+  sorting;
+  rowSelection;
+  subRows;
+  interactiveRows;
+  download;
+  expandableRows;
+  /**
+   * Gets the root element of the DataTable
+   */
+  get element() {
+    return screen.getByTestId(this.dataTestId);
+  }
+  get headerRowCount() {
+    const headerCells = this.tableElement.querySelectorAll(
+      '[role="columnheader"]'
+    );
+    const uniqueRows = /* @__PURE__ */ new Set();
+    for (const headerCell of Array.from(headerCells)) {
+      const headerRowAttr = headerCell.dataset.headerRow;
+      if (headerRowAttr) {
+        uniqueRows.add(headerRowAttr);
+      }
+    }
+    return uniqueRows.size;
+  }
+  getHeaderRowContent(index) {
+    return this.getHeaderRow(index).map((element) => element.textContent);
+  }
+  getRowContent(index) {
+    return this.getAllCellsInBodyRow(index).map(
+      (element) => element.textContent
+    );
+  }
+  get rowCount() {
+    const rows = this.tableElement.querySelectorAll(
+      '[data-rowgroup="body"] [role="row"]:not([data-rowid*="expanded"])'
+    );
+    return rows.length;
+  }
+}
+function getDataTableHelper(testid) {
+  return new DataTableHelper(testid);
+}
+export {
+  DataTableDownloadHelper,
+  DataTableExpandableRowHelper,
+  DataTableHelper,
+  DataTableInteractiveRowsHelper,
+  DataTablePaginationHelper,
+  DataTableRowSelectionHelper,
+  DataTableSortingHelper,
+  DataTableSubRowsHelper,
+  DataTableUserActionHelper,
+  getDataTableHelper
+};
+//# sourceMappingURL=datatable.js.map