@nextsparkjs/testing 0.1.0-beta.39

package/dist/pom/index.js

@@ -0,0 +1,817 @@
+// src/pom/BasePOMCore.ts
+var BasePOMCore = class {
+  /**
+   * Get a Cypress selector using the centralized selectors
+   * Wrapper for cySelector with a shorter name
+   *
+   * @example
+   * this.cy('auth.login.form')
+   * // Returns: '[data-cy="login-form"]'
+   *
+   * this.cy('entities.table.row', { slug: 'tasks', id: '123' })
+   * // Returns: '[data-cy="tasks-row-123"]'
+   */
+  cy(path, replacements) {
+    return this.cySelector(path, replacements);
+  }
+  /**
+   * Replaces placeholders in a selector pattern and wraps with data-cy attribute
+   *
+   * @param pattern - Selector pattern with {placeholder} syntax
+   * @param replacements - Object with placeholder values
+   * @returns Formatted data-cy selector string
+   *
+   * @example
+   * selector('{slug}-row-{id}', { slug: 'tasks', id: '123' })
+   * // Returns: '[data-cy="tasks-row-123"]'
+   */
+  selector(pattern, replacements = {}) {
+    let result = pattern;
+    for (const [key, value] of Object.entries(replacements)) {
+      result = result.replaceAll(`{${key}}`, String(value));
+    }
+    return `[data-cy="${result}"]`;
+  }
+  /**
+   * Wrapper for cy.get with selector pattern support
+   * @param pattern - Selector pattern or direct selector
+   * @param replacements - Optional placeholder replacements
+   */
+  get(pattern, replacements = {}) {
+    return cy.get(this.selector(pattern, replacements));
+  }
+  /**
+   * Generic wait with configurable timeout
+   * @param selector - CSS selector to wait for
+   * @param timeout - Max wait time in ms (default: 15000)
+   */
+  waitFor(selector, timeout = 15e3) {
+    cy.get(selector, { timeout }).should("be.visible");
+    return this;
+  }
+  /**
+   * Wait for URL to contain a specific path
+   * @param path - Path segment to check for
+   */
+  waitForUrl(path) {
+    cy.url().should("include", path);
+    return this;
+  }
+  /**
+   * Wait for URL to match a regex pattern
+   * @param pattern - RegExp to match against URL
+   */
+  waitForUrlMatch(pattern) {
+    cy.url().should("match", pattern);
+    return this;
+  }
+  /**
+   * Visit a URL and return self for chaining
+   * @param url - URL to visit
+   */
+  visit(url) {
+    cy.visit(url);
+    return this;
+  }
+  /**
+   * Wait for page to load (checks for body visible)
+   */
+  waitForPageLoad() {
+    cy.get("body").should("be.visible");
+    return this;
+  }
+  /**
+   * Get an element by selector
+   * @param selector - CSS selector
+   */
+  getElement(selector) {
+    return cy.get(selector);
+  }
+  /**
+   * Click on an element
+   * @param selector - CSS selector
+   */
+  click(selector) {
+    cy.get(selector).click();
+    return this;
+  }
+  /**
+   * Type text into an input
+   * @param selector - CSS selector
+   * @param text - Text to type
+   */
+  type(selector, text) {
+    cy.get(selector).clear().type(text);
+    return this;
+  }
+  /**
+   * Check if element exists
+   * @param selector - CSS selector
+   */
+  exists(selector) {
+    return cy.get(selector).should("exist");
+  }
+  /**
+   * Check if element is visible
+   * @param selector - CSS selector
+   */
+  isVisible(selector) {
+    return cy.get(selector).should("be.visible");
+  }
+  /**
+   * Check if element does not exist
+   * @param selector - CSS selector
+   */
+  notExists(selector) {
+    return cy.get(selector).should("not.exist");
+  }
+};
+
+// src/helpers/ApiInterceptor.ts
+var ApiInterceptor = class {
+  constructor(slugOrConfig) {
+    if (typeof slugOrConfig === "string") {
+      this.slug = slugOrConfig;
+      this.endpoint = `/api/v1/${slugOrConfig}`;
+    } else {
+      this.slug = slugOrConfig.slug;
+      this.endpoint = slugOrConfig.customPath || `/api/v1/${slugOrConfig.slug}`;
+    }
+  }
+  // ============================================
+  // ACCESSORS
+  // ============================================
+  /** Get the API endpoint path */
+  get path() {
+    return this.endpoint;
+  }
+  /** Get the entity slug */
+  get entitySlug() {
+    return this.slug;
+  }
+  /** Get alias names for all operations */
+  get aliases() {
+    return {
+      list: `${this.slug}List`,
+      create: `${this.slug}Create`,
+      update: `${this.slug}Update`,
+      delete: `${this.slug}Delete`
+    };
+  }
+  // ============================================
+  // INTERCEPT SETUP
+  // ============================================
+  /**
+   * Setup intercepts for all CRUD operations
+   * Call this BEFORE navigation in beforeEach or at test start
+   *
+   * Note: We intercept both PUT and PATCH for updates since different
+   * APIs may use different HTTP methods for updates.
+   */
+  setupCrudIntercepts() {
+    cy.intercept("GET", `${this.endpoint}*`).as(this.aliases.list);
+    cy.intercept("POST", this.endpoint).as(this.aliases.create);
+    cy.intercept("PUT", `${this.endpoint}/*`).as(this.aliases.update);
+    cy.intercept("PATCH", `${this.endpoint}/*`).as(`${this.aliases.update}Patch`);
+    cy.intercept("DELETE", `${this.endpoint}/*`).as(this.aliases.delete);
+    return this;
+  }
+  /**
+   * Setup only list + create intercepts
+   * Useful for list pages with inline create
+   */
+  setupListIntercepts() {
+    cy.intercept("GET", `${this.endpoint}*`).as(this.aliases.list);
+    cy.intercept("POST", this.endpoint).as(this.aliases.create);
+    return this;
+  }
+  // ============================================
+  // WAIT METHODS
+  // ============================================
+  /**
+   * Wait for list response (GET)
+   * Use after navigation or after mutations to wait for refresh
+   */
+  waitForList(timeout = 1e4) {
+    return cy.wait(`@${this.aliases.list}`, { timeout });
+  }
+  /**
+   * Wait for create response (POST) and validate success status
+   */
+  waitForCreate(timeout = 1e4) {
+    return cy.wait(`@${this.aliases.create}`, { timeout }).its("response.statusCode").should("be.oneOf", [200, 201]);
+  }
+  /**
+   * Wait for update response (PATCH or PUT) and validate success status
+   * Waits for PATCH first (more common), falls back to PUT
+   */
+  waitForUpdate(timeout = 1e4) {
+    return cy.wait(`@${this.aliases.update}Patch`, { timeout }).its("response.statusCode").should("be.oneOf", [200, 201]);
+  }
+  /**
+   * Wait for delete response (DELETE) and validate success status
+   */
+  waitForDelete(timeout = 1e4) {
+    return cy.wait(`@${this.aliases.delete}`, { timeout }).its("response.statusCode").should("be.oneOf", [200, 204]);
+  }
+  // ============================================
+  // CONVENIENCE METHODS
+  // ============================================
+  /**
+   * Wait for list refresh (alias for waitForList)
+   * Semantic name for use after create/update/delete
+   */
+  waitForRefresh(timeout = 1e4) {
+    return this.waitForList(timeout);
+  }
+  /**
+   * Wait for create + list refresh
+   * Common pattern: create entity, wait for success, wait for list to refresh
+   */
+  waitForCreateAndRefresh(timeout = 1e4) {
+    this.waitForCreate(timeout);
+    return this.waitForList(timeout);
+  }
+  /**
+   * Wait for update + list refresh
+   * Common pattern: update entity, wait for success, wait for list to refresh
+   */
+  waitForUpdateAndRefresh(timeout = 1e4) {
+    this.waitForUpdate(timeout);
+    return this.waitForList(timeout);
+  }
+  /**
+   * Wait for delete + list refresh
+   * Common pattern: delete entity, wait for success, wait for list to refresh
+   */
+  waitForDeleteAndRefresh(timeout = 1e4) {
+    this.waitForDelete(timeout);
+    return this.waitForList(timeout);
+  }
+};
+
+// src/pom/DashboardEntityPOMCore.ts
+var DashboardEntityPOMCore = class extends BasePOMCore {
+  constructor(entitySlugOrConfig) {
+    super();
+    this._api = null;
+    if (typeof entitySlugOrConfig === "string") {
+      this.slug = entitySlugOrConfig;
+      this.entityConfig = { slug: entitySlugOrConfig };
+    } else {
+      this.slug = entitySlugOrConfig.slug;
+      this.entityConfig = entitySlugOrConfig;
+    }
+  }
+  /**
+   * Get the entity slug (public accessor)
+   * Useful for building dynamic selectors and URLs in tests
+   */
+  get entitySlug() {
+    return this.slug;
+  }
+  // ============================================
+  // API INTERCEPTOR
+  // ============================================
+  /**
+   * Get or create ApiInterceptor instance for this entity
+   */
+  get api() {
+    if (!this._api) {
+      this._api = new ApiInterceptor(this.slug);
+    }
+    return this._api;
+  }
+  /**
+   * Setup API intercepts for all CRUD operations
+   * Call this BEFORE navigation
+   */
+  setupApiIntercepts() {
+    this.api.setupCrudIntercepts();
+    return this;
+  }
+  // ============================================
+  // SELECTORS (uses cySelector from theme)
+  // ============================================
+  /**
+   * Get all selectors for this entity, with placeholders replaced
+   * Uses the abstract cySelector method which themes implement
+   */
+  get selectors() {
+    const slug = this.slug;
+    return {
+      // Page
+      page: this.cySelector("entities.page.container", { slug }),
+      pageTitle: this.cySelector("entities.page.title", { slug }),
+      // Table
+      tableContainer: this.cySelector("entities.table.container", { slug }),
+      table: this.cySelector("entities.table.element", { slug }),
+      addButton: this.cySelector("entities.table.addButton", { slug }),
+      search: this.cySelector("entities.table.search", { slug }),
+      searchContainer: this.cySelector("entities.table.search", { slug }),
+      searchClear: this.cySelector("entities.search.clear", { slug }),
+      selectAll: this.cySelector("entities.table.selectAll", { slug }),
+      selectionCount: this.cySelector("entities.table.selectionCount", { slug }),
+      row: (id) => this.cySelector("entities.table.row", { slug, id }),
+      rowSelect: (id) => this.cySelector("entities.table.rowSelect", { slug, id }),
+      rowMenu: (id) => this.cySelector("entities.table.rowMenu", { slug, id }),
+      rowAction: (action, id) => this.cySelector("entities.table.rowAction", { slug, action, id }),
+      cell: (field, id) => this.cySelector("entities.table.cell", { slug, field, id }),
+      rowGeneric: `[data-cy^="${slug}-row-"]`,
+      // Pagination
+      pagination: this.cySelector("entities.pagination.container", { slug }),
+      pageSize: this.cySelector("entities.pagination.pageSize", { slug }),
+      pageSizeOption: (size) => this.cySelector("entities.pagination.pageSizeOption", { slug, size }),
+      pageInfo: this.cySelector("entities.pagination.pageInfo", { slug }),
+      pageFirst: this.cySelector("entities.pagination.first", { slug }),
+      pagePrev: this.cySelector("entities.pagination.prev", { slug }),
+      pageNext: this.cySelector("entities.pagination.next", { slug }),
+      pageLast: this.cySelector("entities.pagination.last", { slug }),
+      // Header (detail pages) - modes: view, edit, create
+      viewHeader: this.cySelector("entities.header.container", { slug, mode: "view" }),
+      editHeader: this.cySelector("entities.header.container", { slug, mode: "edit" }),
+      createHeader: this.cySelector("entities.header.container", { slug, mode: "create" }),
+      backButton: this.cySelector("entities.header.backButton", { slug }),
+      editButton: this.cySelector("entities.header.editButton", { slug }),
+      deleteButton: this.cySelector("entities.header.deleteButton", { slug }),
+      copyId: this.cySelector("entities.header.copyId", { slug }),
+      title: this.cySelector("entities.header.title", { slug }),
+      // Delete confirmation
+      deleteDialog: this.cySelector("entities.header.deleteDialog", { slug }),
+      deleteCancel: this.cySelector("entities.header.deleteCancel", { slug }),
+      deleteConfirm: this.cySelector("entities.header.deleteConfirm", { slug }),
+      // Form
+      form: this.cySelector("entities.form.container", { slug }),
+      field: (name) => this.cySelector("entities.form.field", { slug, name }),
+      submitButton: this.cySelector("entities.form.submitButton", { slug }),
+      // Filters
+      filter: (field) => this.cySelector("entities.filter.container", { slug, field }),
+      filterTrigger: (field) => this.cySelector("entities.filter.trigger", { slug, field }),
+      filterContent: (field) => this.cySelector("entities.filter.content", { slug, field }),
+      filterOption: (field, value) => this.cySelector("entities.filter.option", { slug, field, value }),
+      filterBadge: (field, value) => this.cySelector("entities.filter.badge", { slug, field, value }),
+      filterRemoveBadge: (field, value) => this.cySelector("entities.filter.removeBadge", { slug, field, value }),
+      filterClearAll: (field) => this.cySelector("entities.filter.clearAll", { slug, field }),
+      // Bulk actions
+      bulkBar: this.cySelector("entities.bulk.bar", { slug }),
+      bulkCount: this.cySelector("entities.bulk.count", { slug }),
+      bulkSelectAll: this.cySelector("entities.bulk.selectAll", { slug }),
+      bulkStatus: this.cySelector("entities.bulk.statusButton", { slug }),
+      bulkDelete: this.cySelector("entities.bulk.deleteButton", { slug }),
+      bulkClear: this.cySelector("entities.bulk.clearButton", { slug }),
+      // Bulk status dialog
+      bulkStatusDialog: this.cySelector("entities.bulk.statusDialog", { slug }),
+      bulkStatusSelect: this.cySelector("entities.bulk.statusSelect", { slug }),
+      bulkStatusOption: (value) => this.cySelector("entities.bulk.statusOption", { slug, value }),
+      bulkStatusCancel: this.cySelector("entities.bulk.statusCancel", { slug }),
+      bulkStatusConfirm: this.cySelector("entities.bulk.statusConfirm", { slug }),
+      // Bulk delete dialog
+      bulkDeleteDialog: this.cySelector("entities.bulk.deleteDialog", { slug }),
+      bulkDeleteCancel: this.cySelector("entities.bulk.deleteCancel", { slug }),
+      bulkDeleteConfirm: this.cySelector("entities.bulk.deleteConfirm", { slug }),
+      // Generic confirm dialog
+      confirmDialog: this.cySelector("entities.confirm.dialog", { slug }),
+      confirmCancel: this.cySelector("entities.confirm.cancel", { slug }),
+      confirmAction: this.cySelector("entities.confirm.action", { slug }),
+      // Parent delete confirmation (EntityDetailWrapper - generic, no slug)
+      parentDeleteConfirm: '[data-cy="confirm-delete"]',
+      parentDeleteCancel: '[data-cy="cancel-delete"]',
+      // Row action selectors (generic patterns for checking existence)
+      rowActionEditGeneric: `[data-cy^="${slug}-action-edit-"]`,
+      rowActionDeleteGeneric: `[data-cy^="${slug}-action-delete-"]`,
+      // Detail view
+      detail: this.cySelector("entities.detail.container", { slug })
+    };
+  }
+  // ============================================
+  // NAVIGATION
+  // ============================================
+  /**
+   * Navigate to entity list page
+   */
+  visitList() {
+    cy.visit(`/dashboard/${this.slug}`);
+    return this;
+  }
+  /**
+   * Navigate to create page
+   */
+  visitCreate() {
+    cy.visit(`/dashboard/${this.slug}/create`);
+    return this;
+  }
+  /**
+   * Navigate to edit page for specific entity
+   */
+  visitEdit(id) {
+    cy.visit(`/dashboard/${this.slug}/${id}/edit`);
+    return this;
+  }
+  /**
+   * Navigate to detail/view page for specific entity
+   */
+  visitDetail(id) {
+    cy.visit(`/dashboard/${this.slug}/${id}`);
+    return this;
+  }
+  // ============================================
+  // API-AWARE NAVIGATION
+  // ============================================
+  /**
+   * Navigate to list and wait for API response
+   */
+  visitListWithApiWait() {
+    this.setupApiIntercepts();
+    this.visitList();
+    this.api.waitForList();
+    return this;
+  }
+  /**
+   * Navigate to edit page and wait for form to be visible
+   */
+  visitEditWithApiWait(id) {
+    this.setupApiIntercepts();
+    this.visitEdit(id);
+    this.waitForForm();
+    return this;
+  }
+  /**
+   * Navigate to detail page and wait for content
+   */
+  visitDetailWithApiWait(id) {
+    this.setupApiIntercepts();
+    this.visitDetail(id);
+    this.waitForDetail();
+    return this;
+  }
+  // ============================================
+  // WAITS
+  // ============================================
+  /**
+   * Wait for list page to be fully loaded
+   */
+  waitForList() {
+    cy.url().should("include", `/dashboard/${this.slug}`);
+    cy.get(this.selectors.tableContainer, { timeout: 15e3 }).should("be.visible");
+    return this;
+  }
+  /**
+   * Wait for form to be visible
+   */
+  waitForForm() {
+    cy.get(this.selectors.form, { timeout: 15e3 }).should("be.visible");
+    return this;
+  }
+  /**
+   * Wait for detail page to be loaded
+   */
+  waitForDetail() {
+    cy.url().should("match", new RegExp(`/dashboard/${this.slug}/[a-z0-9-]+$`));
+    cy.get(this.selectors.editButton, { timeout: 15e3 }).should("be.visible");
+    return this;
+  }
+  // ============================================
+  // TABLE ACTIONS
+  // ============================================
+  /**
+   * Click the Add/Create button
+   */
+  clickAdd() {
+    cy.get(this.selectors.addButton).click();
+    return this;
+  }
+  /**
+   * Type in the search input
+   */
+  search(term) {
+    cy.get(this.selectors.search).clear().type(term);
+    return this;
+  }
+  /**
+   * Clear the search input
+   */
+  clearSearch() {
+    cy.get(this.selectors.searchClear).click();
+    return this;
+  }
+  /**
+   * Click a specific row by ID
+   */
+  clickRow(id) {
+    cy.get(this.selectors.row(id)).click();
+    return this;
+  }
+  /**
+   * Find and click a row containing specific text
+   */
+  clickRowByText(text) {
+    cy.contains(this.selectors.rowGeneric, text).click();
+    return this;
+  }
+  /**
+   * Select a row checkbox
+   */
+  selectRow(id) {
+    cy.get(this.selectors.rowSelect(id)).click();
+    return this;
+  }
+  /**
+   * Open the row menu (three dots)
+   */
+  openRowMenu(id) {
+    cy.get(this.selectors.rowMenu(id)).click();
+    return this;
+  }
+  /**
+   * Click an action in the row menu
+   */
+  clickRowAction(action, id) {
+    cy.get(this.selectors.rowAction(action, id)).click();
+    return this;
+  }
+  // ============================================
+  // FILTERS
+  // ============================================
+  /**
+   * Open a filter dropdown
+   */
+  openFilter(field) {
+    cy.get(this.selectors.filterTrigger(field)).click();
+    return this;
+  }
+  /**
+   * Select a filter option
+   */
+  selectFilterOption(field, value) {
+    cy.get(this.selectors.filterOption(field, value)).click();
+    return this;
+  }
+  /**
+   * Open filter and select option (convenience method)
+   */
+  selectFilter(field, value) {
+    this.openFilter(field);
+    this.selectFilterOption(field, value);
+    return this;
+  }
+  /**
+   * Remove a filter badge
+   */
+  removeFilterBadge(field, value) {
+    cy.get(this.selectors.filterRemoveBadge(field, value)).click();
+    return this;
+  }
+  /**
+   * Clear all values for a filter
+   */
+  clearFilter(field) {
+    cy.get(this.selectors.filterClearAll(field)).click();
+    return this;
+  }
+  // ============================================
+  // PAGINATION
+  // ============================================
+  /**
+   * Go to next page
+   */
+  nextPage() {
+    cy.get(this.selectors.pageNext).click();
+    return this;
+  }
+  /**
+   * Go to previous page
+   */
+  prevPage() {
+    cy.get(this.selectors.pagePrev).click();
+    return this;
+  }
+  /**
+   * Go to first page
+   */
+  firstPage() {
+    cy.get(this.selectors.pageFirst).click();
+    return this;
+  }
+  /**
+   * Go to last page
+   */
+  lastPage() {
+    cy.get(this.selectors.pageLast).click();
+    return this;
+  }
+  /**
+   * Change page size
+   */
+  setPageSize(size) {
+    cy.get(this.selectors.pageSize).click();
+    cy.get(this.selectors.pageSizeOption(size)).click();
+    return this;
+  }
+  // ============================================
+  // FORM ACTIONS
+  // ============================================
+  /**
+   * Fill a text input field
+   */
+  fillTextField(name, value) {
+    cy.get(this.selectors.field(name)).find("input").clear().type(value);
+    return this;
+  }
+  /**
+   * Fill a textarea field
+   */
+  fillTextarea(name, value) {
+    cy.get(this.selectors.field(name)).find("textarea").clear().type(value);
+    return this;
+  }
+  /**
+   * Select an option in a combobox/select field
+   */
+  selectOption(name, value) {
+    cy.get(this.selectors.field(name)).find('[role="combobox"]').click();
+    cy.get(`[data-cy="${this.slug}-field-${name}-option-${value}"]`).click();
+    return this;
+  }
+  /**
+   * Submit the form
+   */
+  submitForm() {
+    cy.get(this.selectors.submitButton).click();
+    return this;
+  }
+  // ============================================
+  // HEADER/DETAIL ACTIONS
+  // ============================================
+  /**
+   * Click back button
+   */
+  clickBack() {
+    cy.get(this.selectors.backButton).click();
+    return this;
+  }
+  /**
+   * Click edit button
+   */
+  clickEdit() {
+    cy.get(this.selectors.editButton).click();
+    return this;
+  }
+  /**
+   * Click delete button
+   */
+  clickDelete() {
+    cy.get(this.selectors.deleteButton).click();
+    return this;
+  }
+  /**
+   * Confirm delete in dialog
+   */
+  confirmDelete() {
+    cy.get(this.selectors.deleteConfirm).click();
+    return this;
+  }
+  /**
+   * Cancel delete in dialog
+   */
+  cancelDelete() {
+    cy.get(this.selectors.deleteCancel).click();
+    return this;
+  }
+  // ============================================
+  // BULK ACTIONS
+  // ============================================
+  /**
+   * Select all items using table header checkbox
+   */
+  selectAll() {
+    cy.get(this.selectors.selectAll).click();
+    return this;
+  }
+  /**
+   * Click bulk delete button
+   */
+  bulkDelete() {
+    cy.get(this.selectors.bulkDelete).click();
+    return this;
+  }
+  /**
+   * Confirm bulk delete
+   */
+  confirmBulkDelete() {
+    cy.get(this.selectors.bulkDeleteConfirm).click();
+    return this;
+  }
+  /**
+   * Cancel bulk delete
+   */
+  cancelBulkDelete() {
+    cy.get(this.selectors.bulkDeleteCancel).click();
+    return this;
+  }
+  /**
+   * Click bulk status button
+   */
+  bulkChangeStatus() {
+    cy.get(this.selectors.bulkStatus).click();
+    return this;
+  }
+  /**
+   * Select status in bulk status dialog
+   */
+  selectBulkStatus(value) {
+    cy.get(this.selectors.bulkStatusSelect).click();
+    cy.get(this.selectors.bulkStatusOption(value)).click();
+    return this;
+  }
+  /**
+   * Confirm bulk status change
+   */
+  confirmBulkStatus() {
+    cy.get(this.selectors.bulkStatusConfirm).click();
+    return this;
+  }
+  /**
+   * Clear selection
+   */
+  clearSelection() {
+    cy.get(this.selectors.bulkClear).click();
+    return this;
+  }
+  // ============================================
+  // ASSERTIONS
+  // ============================================
+  /**
+   * Assert text is visible in the list
+   */
+  assertInList(text) {
+    cy.contains(text).should("be.visible");
+    return this;
+  }
+  /**
+   * Assert text is not in the list
+   */
+  assertNotInList(text) {
+    cy.contains(text).should("not.exist");
+    return this;
+  }
+  /**
+   * Assert table is visible
+   */
+  assertTableVisible() {
+    cy.get(this.selectors.table).should("be.visible");
+    return this;
+  }
+  /**
+   * Assert form is visible
+   */
+  assertFormVisible() {
+    cy.get(this.selectors.form).should("be.visible");
+    return this;
+  }
+  /**
+   * Assert page title contains text
+   */
+  assertPageTitle(expected) {
+    cy.get(this.selectors.title).should("contain.text", expected);
+    return this;
+  }
+  /**
+   * Assert row exists
+   */
+  assertRowExists(id) {
+    cy.get(this.selectors.row(id)).should("exist");
+    return this;
+  }
+  /**
+   * Assert row does not exist
+   */
+  assertRowNotExists(id) {
+    cy.get(this.selectors.row(id)).should("not.exist");
+    return this;
+  }
+  /**
+   * Assert selection count
+   */
+  assertSelectionCount(count) {
+    cy.get(this.selectors.selectionCount).should("contain.text", count.toString());
+    return this;
+  }
+  /**
+   * Assert bulk bar is visible
+   */
+  assertBulkBarVisible() {
+    cy.get(this.selectors.bulkBar).should("be.visible");
+    return this;
+  }
+  /**
+   * Assert bulk bar is hidden
+   */
+  assertBulkBarHidden() {
+    cy.get(this.selectors.bulkBar).should("not.be.visible");
+    return this;
+  }
+};
+
+export { BasePOMCore, DashboardEntityPOMCore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map