@sumaris-net/ngx-components 18.24.23 → 18.25.0

package/esm2022/testing/utils/auth.utils.mjs

@@ -0,0 +1,64 @@
+import { UiHelper } from './ui.utils';
+import { STARTUP_DATA_STORAGE_KEY } from './startup.constants';
+/**
+ * Helper for authentication in e2e tests.
+ */
+export class AuthHelper {
+    page;
+    ui;
+    constructor(page, ui) {
+        this.page = page;
+        this.ui = ui ?? new UiHelper(page);
+    }
+    /** Login with given test credentials */
+    async login(username, password) {
+        const ui = this.ui;
+        await this.page.goto('/');
+        // Wait for the app to fully load (backend connection can take time)
+        await ui.waitForAppReady(30_000);
+        await ui.waitForLoadingComplete(30_000);
+        // Click the login button on the home page
+        const loginButton = ui.button(/Se connecter|Log In/).first();
+        await ui.click(loginButton, 30_000);
+        // Wait for the auth modal to appear
+        const modal = ui.modal('app-auth-form');
+        await ui.waitForVisible(modal);
+        // Fill credentials (may or may not be pre-filled depending on the environment)
+        const usernameInput = modal.locator('input[formcontrolname="username"]');
+        await usernameInput.click({ force: true });
+        await usernameInput.fill(username);
+        const passwordInput = modal.locator('input[formcontrolname="password"]');
+        await passwordInput.click({ force: true });
+        await passwordInput.fill(password);
+        // Click the submit button in the modal footer
+        const ionModal = ui.pageObj.locator('ion-modal:has(app-auth-form)');
+        const submitButton = ionModal.locator('ion-footer ion-button[color="tertiary"]');
+        await submitButton.waitFor({ state: 'visible', timeout: 10_000 });
+        // Wait for the button to be enabled (form valid)
+        await ui.pageObj.waitForFunction((btn) => !btn.hasAttribute('disabled'), await submitButton.elementHandle(), { timeout: 5_000 });
+        await submitButton.click();
+        // Wait for the modal to close and verify the user is logged in
+        await ui.waitForHidden(modal, 30_000);
+        // After login, the login button should no longer be visible (replaced by user menu)
+        await loginButton.waitFor({ state: 'hidden', timeout: 10_000 });
+    }
+    /** Wait until the user is logged in and return the email shown in the side menu */
+    async waitForLoggedIn() {
+        const emailEl = this.page.locator('ion-menu h4').first();
+        await emailEl.waitFor({ state: 'visible', timeout: 30_000 });
+        return emailEl.textContent();
+    }
+    /** Setup startup data with provided credentials or environment variables */
+    async loginByEnv(opts) {
+        const username = opts?.username ?? process.env.E2E_USERNAME;
+        const password = opts?.password ?? process.env.E2E_PASSWORD;
+        const offline = opts?.offline ?? process.env.E2E_OFFLINE === 'true';
+        const peerUrl = opts?.peerUrl ?? process.env.E2E_PEER_URL;
+        if (!username && !password && !peerUrl)
+            return;
+        await this.page.addInitScript(({ key, username, password, offline, peerUrl }) => {
+            window[key] = { username, password, offline, peerUrl };
+        }, { key: STARTUP_DATA_STORAGE_KEY, username, password, offline, peerUrl });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.utils.js","sourceRoot":"","sources":["../../../../testing/utils/auth.utils.ts"],"names":[],"mappings":"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","sourcesContent":["// GPL v3 License\nimport { Page } from 'playwright';\nimport { UiHelper } from './ui.utils';\nimport { STARTUP_DATA_STORAGE_KEY } from './startup.constants';\n\n/**\n * Helper for authentication in e2e tests.\n */\nexport class AuthHelper {\n  protected ui: UiHelper;\n\n  constructor(\n    private page: Page,\n    ui?: UiHelper\n  ) {\n    this.ui = ui ?? new UiHelper(page);\n  }\n\n  /** Login with given test credentials */\n  async login(username: string, password: string): Promise<void> {\n    const ui = this.ui;\n\n    await this.page.goto('/');\n\n    // Wait for the app to fully load (backend connection can take time)\n    await ui.waitForAppReady(30_000);\n    await ui.waitForLoadingComplete(30_000);\n\n    // Click the login button on the home page\n    const loginButton = ui.button(/Se connecter|Log In/).first();\n    await ui.click(loginButton, 30_000);\n\n    // Wait for the auth modal to appear\n    const modal = ui.modal('app-auth-form');\n    await ui.waitForVisible(modal);\n\n    // Fill credentials (may or may not be pre-filled depending on the environment)\n    const usernameInput = modal.locator('input[formcontrolname=\"username\"]');\n    await usernameInput.click({ force: true });\n    await usernameInput.fill(username);\n    const passwordInput = modal.locator('input[formcontrolname=\"password\"]');\n    await passwordInput.click({ force: true });\n    await passwordInput.fill(password);\n\n    // Click the submit button in the modal footer\n    const ionModal = ui.pageObj.locator('ion-modal:has(app-auth-form)');\n    const submitButton = ionModal.locator('ion-footer ion-button[color=\"tertiary\"]');\n    await submitButton.waitFor({ state: 'visible', timeout: 10_000 });\n    // Wait for the button to be enabled (form valid)\n    await ui.pageObj.waitForFunction(\n      (btn) => !btn.hasAttribute('disabled'),\n      await submitButton.elementHandle(),\n      { timeout: 5_000 }\n    );\n    await submitButton.click();\n\n    // Wait for the modal to close and verify the user is logged in\n    await ui.waitForHidden(modal, 30_000);\n\n    // After login, the login button should no longer be visible (replaced by user menu)\n    await loginButton.waitFor({ state: 'hidden', timeout: 10_000 });\n  }\n\n  /** Wait until the user is logged in and return the email shown in the side menu */\n  async waitForLoggedIn(): Promise<string | null> {\n    const emailEl = this.page.locator('ion-menu h4').first();\n    await emailEl.waitFor({ state: 'visible', timeout: 30_000 });\n    return emailEl.textContent();\n  }\n\n  /** Setup startup data with provided credentials or environment variables */\n  async loginByEnv(opts?: { username?: string; password?: string; offline?: boolean; peerUrl?: string }): Promise<void> {\n    const username = opts?.username ?? process.env.E2E_USERNAME;\n    const password = opts?.password ?? process.env.E2E_PASSWORD;\n    const offline = opts?.offline ?? process.env.E2E_OFFLINE === 'true';\n    const peerUrl = opts?.peerUrl ?? process.env.E2E_PEER_URL;\n\n    if (!username && !password && !peerUrl) return;\n\n    await this.page.addInitScript(\n      ({ key, username, password, offline, peerUrl }) => {\n        (window as any)[key] = { username, password, offline, peerUrl };\n      },\n      { key: STARTUP_DATA_STORAGE_KEY, username, password, offline, peerUrl }\n    );\n  }\n}\n"]}

package/esm2022/testing/utils/ionic.utils.mjs

@@ -0,0 +1,66 @@
+/**
+ * Utility selectors and helpers for Ionic components in e2e tests.
+ */
+export const IonicSelectors = {
+    /** Ionic button */
+    button: 'ion-button',
+    /** Ionic modal */
+    modal: 'ion-modal',
+    /** Ionic content area */
+    content: 'ion-content',
+    /** Ionic item */
+    item: 'ion-item',
+    /** Ionic label */
+    label: 'ion-label',
+    /** Ionic spinner */
+    spinner: 'ion-spinner',
+    /** Ionic skeleton text (loading placeholder) */
+    skeletonText: 'ion-skeleton-text',
+    /** Ionic back button */
+    backButton: 'ion-back-button',
+    /** Ionic toolbar */
+    toolbar: 'ion-toolbar',
+    /** Ionic footer */
+    footer: 'ion-footer',
+    /** Ionic header */
+    header: 'ion-header',
+};
+/**
+ * Helper functions for interacting with Ionic components.
+ */
+export class IonicHelper {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /** Get an Ionic button by text content */
+    buttonByText(text) {
+        return this.page.locator(IonicSelectors.button, { hasText: text });
+    }
+    /** Get an Ionic button by CSS selector */
+    button(selector, options) {
+        const fullSelector = selector ? `${IonicSelectors.button}${selector}` : IonicSelectors.button;
+        return this.page.locator(fullSelector, options);
+    }
+    /**
+     * Get an Ionic modal by its inner component selector (e.g. 'app-auth-form').
+     * Automatically wraps the selector in `ion-modal:has(...)` so callers
+     * only need to provide the component tag name.
+     */
+    modal(selector) {
+        const fullSelector = selector.startsWith('ion-modal') ? selector : `ion-modal:has(${selector})`;
+        return this.page.locator(fullSelector);
+    }
+    /** Wait for the Ionic app to be ready */
+    async waitForAppReady(timeout = 15_000) {
+        // Wait for ion-app to be attached (Angular bootstrap complete)
+        await this.page.waitForSelector('ion-app', { state: 'attached', timeout });
+    }
+    /** Wait for loading spinners to disappear */
+    async waitForLoadingComplete(timeout = 15_000) {
+        await this.page.locator(IonicSelectors.spinner).waitFor({ state: 'hidden', timeout }).catch(() => {
+            // Spinner may not appear at all — that's fine
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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":"AAGA;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,yBAAyB;IACzB,GAAG,EAAE,sBAAsB;IAC3B,0BAA0B;IAC1B,SAAS,EAAE,oCAAoC;IAC/C,oBAAoB;IACpB,IAAI,EAAE,wBAAwB;IAC9B,0BAA0B;IAC1B,SAAS,EAAE,gBAAgB;IAC3B,qBAAqB;IACrB,KAAK,EAAE,iBAAiB;IACxB,yBAAyB;IACzB,QAAQ,EAAE,eAAe;IACzB,yBAAyB;IACzB,QAAQ,EAAE,cAAc;IACxB,yBAAyB;IACzB,SAAS,EAAE,eAAe;IAC1B,oBAAoB;IACpB,IAAI,EAAE,UAAU;IAChB,kCAAkC;IAClC,iBAAiB,EAAE,6BAA6B;IAChD,mCAAmC;IACnC,kBAAkB,EAAE,YAAY;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,OAAO,cAAc;IACL;IAApB,YAAoB,IAAU;QAAV,SAAI,GAAJ,IAAI,CAAM;IAAG,CAAC;IAElC,wEAAwE;IACxE,SAAS,CAAC,KAAe;QACvB,MAAM,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;QAChC,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAC7C,CAAC;IAED,uFAAuF;IACvF,QAAQ,CAAC,KAAa,EAAE,KAAe;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,qFAAqF;IACrF,KAAK,CAAC,QAAQ,CAAC,KAAa,EAAE,KAAe;QAC3C,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC;IAC5C,CAAC;IAED,kCAAkC;IAClC,UAAU,CAAC,IAAqB;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,oCAAoC;IACpC,KAAK,CAAC,QAAQ,CAAC,IAAqB;QAClC,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;IAED;kIAC8H;IAC9H,KAAK,CAAC,eAAe,CAAC,eAAuB,EAAE,KAAa;QAC1D,qEAAqE;QACrE,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,iBAAiB,CAAC,SAAS,2BAA2B,eAAe,IAAI,CAAC,CAAC;QACpH,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,qBAAqB,eAAe,UAAU,CAAC,CAAC;QACvF,MAAM,KAAK,GAAG,CAAC,MAAM,WAAW,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC;QAC3E,oEAAoE;QACpE,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QAClE,IAAI,CAAC,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC;QAClC,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,KAAK,CAAC,iBAAiB,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,qBAAqB,CAAC,eAAuB,EAAE,UAA2B;QAC9E,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,+BAA+B,eAAe,IAAI,CAAC,CAAC;QACrF,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,sFAAsF;QACtF,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;QACnE,MAAM,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5D,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,qDAAqD;QACrD,MAAM,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,2EAA2E;IAC3E,KAAK,CAAC,wBAAwB,CAAC,eAAuB,EAAE,UAAkB,EAAE,UAA2B;QACrG,MAAM,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;QACrE,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3D,MAAM,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IAC7F,CAAC;IAED,yGAAyG;IACzG,KAAK,CAAC,gBAAgB,CAAC,OAAO,GAAG,MAAM,EAAE,KAAe;QACtD,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;IAC7E,CAAC;CACF","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}"]}