@sumaris-net/ngx-components 18.24.24 → 18.25.0

package/esm2022/testing/utils/material.utils.mjs

@@ -0,0 +1,100 @@
+/**
+ * Utility selectors and helpers for Angular Material components in e2e tests.
+ */
+export const MaterialSelectors = {
+    /** Material table row */
+    row: 'mat-row, tr[mat-row]',
+    /** Material header row */
+    headerRow: 'mat-header-row, tr[mat-header-row]',
+    /** Material cell */
+    cell: 'mat-cell, td[mat-cell]',
+    /** Material form field */
+    formField: 'mat-form-field',
+    /** Material input */
+    input: 'input[matInput]',
+    /** Material tab group */
+    tabGroup: 'mat-tab-group',
+    /** Material tab label */
+    tabLabel: '.mat-mdc-tab',
+    /** Material paginator */
+    paginator: 'mat-paginator',
+    /** Material icon */
+    icon: 'mat-icon',
+    /** Material autocomplete panel */
+    autocompletePanel: '.mat-mdc-autocomplete-panel',
+    /** Material autocomplete option */
+    autocompleteOption: 'mat-option',
+};
+/**
+ * Helper functions for interacting with Angular Material components.
+ */
+export class MaterialHelper {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /** Get all visible table rows, optionally scoped to a parent locator */
+    tableRows(scope) {
+        const root = scope ?? this.page;
+        return root.locator(MaterialSelectors.row);
+    }
+    /** Get a single table row by index (0-based), optionally scoped to a parent locator */
+    tableRow(index, scope) {
+        return this.tableRows(scope).nth(index);
+    }
+    /** Click on a table row by index (0-based), optionally scoped to a parent locator */
+    async clickRow(index, scope) {
+        await this.tableRow(index, scope).click();
+    }
+    /** Get a tab by its label text */
+    tabByLabel(text) {
+        return this.page.locator(MaterialSelectors.tabLabel, { hasText: text });
+    }
+    /** Click a tab by its label text */
+    async clickTab(text) {
+        await this.tabByLabel(text).click();
+    }
+    /** Fill a mat-form-field input identified by its formControlName.
+     *  Supports both native inputs with formcontrolname and custom components (e.g. mat-autocomplete-field) wrapping an input. */
+    async fillFormControl(formControlName, value) {
+        // Try native input first, then fall back to custom component wrapper
+        const nativeInput = this.page.locator(`${MaterialSelectors.formField} input[formcontrolname="${formControlName}"]`);
+        const wrappedInput = this.page.locator(`[formcontrolname="${formControlName}"] input`);
+        const input = (await nativeInput.count()) > 0 ? nativeInput : wrappedInput;
+        // Click the parent mat-form-field to ensure focus reaches the input
+        const formField = input.locator('xpath=ancestor::mat-form-field');
+        if ((await formField.count()) > 0) {
+            await formField.first().click();
+        }
+        else {
+            await input.click({ force: true });
+        }
+        await input.pressSequentially(value, { delay: 50 });
+    }
+    /**
+     * Select an option from a mat-select dropdown by formControlName.
+     * Opens the dropdown, waits for options to render, clicks the matching option, then waits for the dropdown to close.
+     */
+    async selectMatSelectOption(formControlName, optionText) {
+        const select = this.page.locator(`mat-select[formcontrolname="${formControlName}"]`);
+        await select.click();
+        // Use role-based selector: mat-select renders options with role="option" in a listbox
+        const option = this.page.getByRole('option', { name: optionText });
+        await option.waitFor({ state: 'visible', timeout: 10_000 });
+        await option.click();
+        // Wait for the option to disappear (dropdown closed)
+        await option.waitFor({ state: 'hidden', timeout: 5_000 });
+    }
+    /** Select an autocomplete option by text after typing in a form control */
+    async selectAutocompleteOption(formControlName, searchText, optionText) {
+        await this.fillFormControl(formControlName, searchText);
+        const panel = this.page.locator(MaterialSelectors.autocompletePanel);
+        await panel.waitFor({ state: 'visible', timeout: 10_000 });
+        await panel.locator(MaterialSelectors.autocompleteOption, { hasText: optionText }).click();
+    }
+    /** Wait for table rows to be loaded (at least one row visible), optionally scoped to a parent locator */
+    async waitForTableRows(timeout = 15_000, scope) {
+        await this.tableRows(scope).first().waitFor({ state: 'visible', timeout });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.utils.js","sourceRoot":"","sources":["../../../../testing/utils/material.utils.ts"],"names":[],"mappings":"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","sourcesContent":["// GPL v3 License\nimport { Locator, Page } from 'playwright';\n\n/**\n * Utility selectors and helpers for Angular Material components in e2e tests.\n */\nexport const MaterialSelectors = {\n  /** Material table row */\n  row: 'mat-row, tr[mat-row]',\n  /** Material header row */\n  headerRow: 'mat-header-row, tr[mat-header-row]',\n  /** Material cell */\n  cell: 'mat-cell, td[mat-cell]',\n  /** Material form field */\n  formField: 'mat-form-field',\n  /** Material input */\n  input: 'input[matInput]',\n  /** Material tab group */\n  tabGroup: 'mat-tab-group',\n  /** Material tab label */\n  tabLabel: '.mat-mdc-tab',\n  /** Material paginator */\n  paginator: 'mat-paginator',\n  /** Material icon */\n  icon: 'mat-icon',\n  /** Material autocomplete panel */\n  autocompletePanel: '.mat-mdc-autocomplete-panel',\n  /** Material autocomplete option */\n  autocompleteOption: 'mat-option',\n};\n\n/**\n * Helper functions for interacting with Angular Material components.\n */\nexport class MaterialHelper {\n  constructor(private page: Page) {}\n\n  /** Get all visible table rows, optionally scoped to a parent locator */\n  tableRows(scope?: Locator): Locator {\n    const root = scope ?? this.page;\n    return root.locator(MaterialSelectors.row);\n  }\n\n  /** Get a single table row by index (0-based), optionally scoped to a parent locator */\n  tableRow(index: number, scope?: Locator): Locator {\n    return this.tableRows(scope).nth(index);\n  }\n\n  /** Click on a table row by index (0-based), optionally scoped to a parent locator */\n  async clickRow(index: number, scope?: Locator): Promise<void> {\n    await this.tableRow(index, scope).click();\n  }\n\n  /** Get a tab by its label text */\n  tabByLabel(text: string | RegExp): Locator {\n    return this.page.locator(MaterialSelectors.tabLabel, { hasText: text });\n  }\n\n  /** Click a tab by its label text */\n  async clickTab(text: string | RegExp): Promise<void> {\n    await this.tabByLabel(text).click();\n  }\n\n  /** Fill a mat-form-field input identified by its formControlName.\n   *  Supports both native inputs with formcontrolname and custom components (e.g. mat-autocomplete-field) wrapping an input. */\n  async fillFormControl(formControlName: string, value: string): Promise<void> {\n    // Try native input first, then fall back to custom component wrapper\n    const nativeInput = this.page.locator(`${MaterialSelectors.formField} input[formcontrolname=\"${formControlName}\"]`);\n    const wrappedInput = this.page.locator(`[formcontrolname=\"${formControlName}\"] input`);\n    const input = (await nativeInput.count()) > 0 ? nativeInput : wrappedInput;\n    // Click the parent mat-form-field to ensure focus reaches the input\n    const formField = input.locator('xpath=ancestor::mat-form-field');\n    if ((await formField.count()) > 0) {\n      await formField.first().click();\n    } else {\n      await input.click({ force: true });\n    }\n    await input.pressSequentially(value, { delay: 50 });\n  }\n\n  /**\n   * Select an option from a mat-select dropdown by formControlName.\n   * Opens the dropdown, waits for options to render, clicks the matching option, then waits for the dropdown to close.\n   */\n  async selectMatSelectOption(formControlName: string, optionText: string | RegExp): Promise<void> {\n    const select = this.page.locator(`mat-select[formcontrolname=\"${formControlName}\"]`);\n    await select.click();\n    // Use role-based selector: mat-select renders options with role=\"option\" in a listbox\n    const option = this.page.getByRole('option', { name: optionText });\n    await option.waitFor({ state: 'visible', timeout: 10_000 });\n    await option.click();\n    // Wait for the option to disappear (dropdown closed)\n    await option.waitFor({ state: 'hidden', timeout: 5_000 });\n  }\n\n  /** Select an autocomplete option by text after typing in a form control */\n  async selectAutocompleteOption(formControlName: string, searchText: string, optionText: string | RegExp): Promise<void> {\n    await this.fillFormControl(formControlName, searchText);\n    const panel = this.page.locator(MaterialSelectors.autocompletePanel);\n    await panel.waitFor({ state: 'visible', timeout: 10_000 });\n    await panel.locator(MaterialSelectors.autocompleteOption, { hasText: optionText }).click();\n  }\n\n  /** Wait for table rows to be loaded (at least one row visible), optionally scoped to a parent locator */\n  async waitForTableRows(timeout = 15_000, scope?: Locator): Promise<void> {\n    await this.tableRows(scope).first().waitFor({ state: 'visible', timeout });\n  }\n}"]}

package/esm2022/testing/utils/startup.constants.mjs

@@ -0,0 +1,4 @@
+// Standalone startup constants for the testing package.
+// Must be kept in sync with src/app/core/services/startup.constants.ts
+export const STARTUP_DATA_STORAGE_KEY = '__appStartupData';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnR1cC5jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90ZXN0aW5nL3V0aWxzL3N0YXJ0dXAuY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdEQUF3RDtBQUN4RCx1RUFBdUU7QUFDdkUsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTdGFuZGFsb25lIHN0YXJ0dXAgY29uc3RhbnRzIGZvciB0aGUgdGVzdGluZyBwYWNrYWdlLlxuLy8gTXVzdCBiZSBrZXB0IGluIHN5bmMgd2l0aCBzcmMvYXBwL2NvcmUvc2VydmljZXMvc3RhcnR1cC5jb25zdGFudHMudHNcbmV4cG9ydCBjb25zdCBTVEFSVFVQX0RBVEFfU1RPUkFHRV9LRVkgPSAnX19hcHBTdGFydHVwRGF0YSc7XG4iXX0=

package/esm2022/testing/utils/ui.utils.mjs

@@ -0,0 +1,139 @@
+import { IonicHelper, IonicSelectors } from './ionic.utils';
+import { MaterialHelper, MaterialSelectors } from './material.utils';
+/**
+ * Common UI helper functions to improve readability of e2e tests.
+ * This helper centralizes access to Ionic and Material specific helpers.
+ */
+export class UiHelper {
+    page;
+    ionic;
+    mat;
+    constructor(page) {
+        this.page = page;
+        this.ionic = new IonicHelper(page);
+        this.mat = new MaterialHelper(page);
+    }
+    /**
+     * Click an element and wait for it to be ready.
+     * @param locator The locator to click.
+     * @param timeout The maximum time to wait.
+     */
+    async click(locator, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+        // force: true bypasses Ionic overlay elements (ion-col, ion-toolbar) that intercept pointer events
+        await locator.click({ force: true });
+    }
+    /**
+     * Fill an input and wait for it to be ready.
+     * @param locator The locator to fill.
+     * @param value The value to enter.
+     * @param timeout The maximum time to wait.
+     */
+    async fill(locator, value, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+        await locator.fill(value);
+    }
+    /**
+     * Wait for an element to be visible.
+     * @param locator The locator to wait for.
+     * @param timeout The maximum time to wait.
+     */
+    async waitForVisible(locator, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+    }
+    /**
+     * Wait for an element to be hidden.
+     * @param locator The locator to wait for.
+     * @param timeout The maximum time to wait.
+     */
+    async waitForHidden(locator, timeout = 15_000) {
+        await locator.waitFor({ state: 'hidden', timeout });
+    }
+    /* --- Unified Selectors --- */
+    /**
+     * Get a button by its text content.
+     * Supports both Ionic and Material buttons.
+     * @param text The text content to match.
+     * @param scope Optional locator to scope the search within.
+     */
+    button(text, scope) {
+        // Combine selectors for both Ionic and Material buttons
+        const selectors = [
+            IonicSelectors.button,
+            'button[mat-button]',
+            'button[mat-raised-button]',
+            'button[mat-flat-button]',
+            'button[mat-stroked-button]',
+            'button[mat-icon-button]',
+            'button[mat-fab]',
+            'button[mat-mini-fab]',
+        ].join(', ');
+        const root = scope ?? this.page;
+        return root.locator(selectors, { hasText: text });
+    }
+    /**
+     * Get an icon button by its icon name.
+     * Supports both Ionic and Material icon buttons.
+     * @param iconName The icon name (e.g. 'mail', 'search', 'ellipsis-horizontal').
+     * @param scope Optional locator to scope the search within.
+     */
+    iconButton(iconName, scope) {
+        const matIconSelector = `${MaterialSelectors.icon}:has-text("${iconName}")`;
+        const ionIconSelector = `ion-icon[name="${iconName}"]`;
+        const root = scope ?? this.page;
+        return root.locator(`button, ion-button`).filter({
+            has: this.page.locator(`${matIconSelector}, ${ionIconSelector}`),
+        });
+    }
+    /**
+     * Access to the underlying Playwright Page object.
+     */
+    get pageObj() {
+        return this.page;
+    }
+    /** Get a modal by its selector */
+    modal(selector) {
+        return this.ionic.modal(selector);
+    }
+    /** Get a tab by its label text */
+    tab(text) {
+        return this.mat.tabByLabel(text);
+    }
+    /* --- Specialized Helpers (delegated) --- */
+    /** Wait for the app to be ready */
+    async waitForAppReady(timeout = 15_000) {
+        await this.ionic.waitForAppReady(timeout);
+    }
+    /** Wait for loading spinners to disappear */
+    async waitForLoadingComplete(timeout = 15_000) {
+        await this.ionic.waitForLoadingComplete(timeout);
+    }
+    /** Wait for table rows to be loaded, optionally scoped to a parent locator */
+    async waitForTableRows(timeout = 15_000, scope) {
+        await this.mat.waitForTableRows(timeout, scope);
+    }
+    /** Get a single table row by index (0-based), optionally scoped to a parent locator */
+    tableRow(index, scope) {
+        return this.mat.tableRow(index, scope);
+    }
+    /** Click on a table row by index, optionally scoped to a parent locator */
+    async clickRow(index, scope) {
+        await this.click(this.tableRow(index, scope));
+    }
+    /** Fill a mat-form-field input identified by its formControlName */
+    async fillFormControl(formControlName, value) {
+        await this.mat.fillFormControl(formControlName, value);
+    }
+    /** Select an autocomplete option */
+    async selectAutocompleteOption(formControlName, searchText, optionText) {
+        await this.mat.selectAutocompleteOption(formControlName, searchText, optionText);
+    }
+    /**
+     * Select an option from a mat-select dropdown.
+     * Opens the dropdown, waits for options, clicks the matching one, then waits for the dropdown to close.
+     */
+    async selectOption(formControlName, optionText) {
+        await this.mat.selectMatSelectOption(formControlName, optionText);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui.utils.js","sourceRoot":"","sources":["../../../../testing/utils/ui.utils.ts"],"names":[],"mappings":"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","sourcesContent":["// GPL v3 License\nimport { Locator, Page } from 'playwright';\nimport { IonicHelper, IonicSelectors } from './ionic.utils';\nimport { MaterialHelper, MaterialSelectors } from './material.utils';\n\n/**\n * Common UI helper functions to improve readability of e2e tests.\n * This helper centralizes access to Ionic and Material specific helpers.\n */\nexport class UiHelper {\n  protected ionic: IonicHelper;\n  protected mat: MaterialHelper;\n\n  constructor(protected page: Page) {\n    this.ionic = new IonicHelper(page);\n    this.mat = new MaterialHelper(page);\n  }\n\n  /**\n   * Click an element and wait for it to be ready.\n   * @param locator The locator to click.\n   * @param timeout The maximum time to wait.\n   */\n  async click(locator: Locator, timeout = 10_000): Promise<void> {\n    await locator.waitFor({ state: 'visible', timeout });\n    // force: true bypasses Ionic overlay elements (ion-col, ion-toolbar) that intercept pointer events\n    await locator.click({ force: true });\n  }\n\n  /**\n   * Fill an input and wait for it to be ready.\n   * @param locator The locator to fill.\n   * @param value The value to enter.\n   * @param timeout The maximum time to wait.\n   */\n  async fill(locator: Locator, value: string, timeout = 10_000): Promise<void> {\n    await locator.waitFor({ state: 'visible', timeout });\n    await locator.fill(value);\n  }\n\n  /**\n   * Wait for an element to be visible.\n   * @param locator The locator to wait for.\n   * @param timeout The maximum time to wait.\n   */\n  async waitForVisible(locator: Locator, timeout = 10_000): Promise<void> {\n    await locator.waitFor({ state: 'visible', timeout });\n  }\n\n  /**\n   * Wait for an element to be hidden.\n   * @param locator The locator to wait for.\n   * @param timeout The maximum time to wait.\n   */\n  async waitForHidden(locator: Locator, timeout = 15_000): Promise<void> {\n    await locator.waitFor({ state: 'hidden', timeout });\n  }\n\n  /* --- Unified Selectors --- */\n\n  /**\n   * Get a button by its text content.\n   * Supports both Ionic and Material buttons.\n   * @param text The text content to match.\n   * @param scope Optional locator to scope the search within.\n   */\n  button(text: string | RegExp, scope?: Locator): Locator {\n    // Combine selectors for both Ionic and Material buttons\n    const selectors = [\n      IonicSelectors.button,\n      'button[mat-button]',\n      'button[mat-raised-button]',\n      'button[mat-flat-button]',\n      'button[mat-stroked-button]',\n      'button[mat-icon-button]',\n      'button[mat-fab]',\n      'button[mat-mini-fab]',\n    ].join(', ');\n\n    const root = scope ?? this.page;\n    return root.locator(selectors, { hasText: text });\n  }\n\n  /**\n   * Get an icon button by its icon name.\n   * Supports both Ionic and Material icon buttons.\n   * @param iconName The icon name (e.g. 'mail', 'search', 'ellipsis-horizontal').\n   * @param scope Optional locator to scope the search within.\n   */\n  iconButton(iconName: string, scope?: Locator): Locator {\n    const matIconSelector = `${MaterialSelectors.icon}:has-text(\"${iconName}\")`;\n    const ionIconSelector = `ion-icon[name=\"${iconName}\"]`;\n    const root = scope ?? this.page;\n    return root.locator(`button, ion-button`).filter({\n      has: this.page.locator(`${matIconSelector}, ${ionIconSelector}`),\n    });\n  }\n\n  /**\n   * Access to the underlying Playwright Page object.\n   */\n  get pageObj(): Page {\n    return this.page;\n  }\n\n  /** Get a modal by its selector */\n  modal(selector: string): Locator {\n    return this.ionic.modal(selector);\n  }\n\n  /** Get a tab by its label text */\n  tab(text: string | RegExp): Locator {\n    return this.mat.tabByLabel(text);\n  }\n\n  /* --- Specialized Helpers (delegated) --- */\n\n  /** Wait for the app to be ready */\n  async waitForAppReady(timeout = 15_000): Promise<void> {\n    await this.ionic.waitForAppReady(timeout);\n  }\n\n  /** Wait for loading spinners to disappear */\n  async waitForLoadingComplete(timeout = 15_000): Promise<void> {\n    await this.ionic.waitForLoadingComplete(timeout);\n  }\n\n  /** Wait for table rows to be loaded, optionally scoped to a parent locator */\n  async waitForTableRows(timeout = 15_000, scope?: Locator): Promise<void> {\n    await this.mat.waitForTableRows(timeout, scope);\n  }\n\n  /** Get a single table row by index (0-based), optionally scoped to a parent locator */\n  tableRow(index: number, scope?: Locator): Locator {\n    return this.mat.tableRow(index, scope);\n  }\n\n  /** Click on a table row by index, optionally scoped to a parent locator */\n  async clickRow(index: number, scope?: Locator): Promise<void> {\n    await this.click(this.tableRow(index, scope));\n  }\n\n  /** Fill a mat-form-field input identified by its formControlName */\n  async fillFormControl(formControlName: string, value: string): Promise<void> {\n    await this.mat.fillFormControl(formControlName, value);\n  }\n\n  /** Select an autocomplete option */\n  async selectAutocompleteOption(formControlName: string, searchText: string, optionText: string | RegExp): Promise<void> {\n    await this.mat.selectAutocompleteOption(formControlName, searchText, optionText);\n  }\n\n  /**\n   * Select an option from a mat-select dropdown.\n   * Opens the dropdown, waits for options, clicks the matching one, then waits for the dropdown to close.\n   */\n  async selectOption(formControlName: string, optionText: string | RegExp): Promise<void> {\n    await this.mat.selectMatSelectOption(formControlName, optionText);\n  }\n}"]}