transit-core-taf 1.0.2

package/dist/transit-core-taf/base/basepagevalidations.js

@@ -0,0 +1,459 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePageValidations = void 0;
+const test_1 = require("@playwright/test");
+class BasePageValidations {
+    page;
+    logger;
+    constructor(page, logger) {
+        this.page = page;
+        this.logger = logger;
+    }
+    /**
+     * Validates that a given element is visible.
+     * @param element The locator of the element to validate.
+     */
+    async validateElementToBeVisible(element) {
+        this.logger.info(`Validating element is visible: ${element}`);
+        await (0, test_1.expect)(element).toBeVisible();
+    }
+    /**
+     * Validates that a given element is not visible.
+     * This method asserts that the element exists in the DOM but is not currently visible.
+     * Visibility is determined based on factors such as CSS properties like `display: none`,
+     * `visibility: hidden`, or being off-screen.
+     * @param element The locator of the element to validate.
+     * @throws Will throw an assertion error if the element is visible.
+     */
+    async validateElementNotToBeVisible(element) {
+        this.logger.info(`Validating element is not visible: ${element}`);
+        await (0, test_1.expect)(element).not.toBeVisible();
+    }
+    /**
+     * Validates that the number of elements matching the locator is equal to the expected count.
+     * @param locator - The Playwright Locator pointing to the elements.
+     * @param expectedCount - The expected number of elements.
+     * Example:
+     * await validateElementCountToBe(page.locator('.item'), 3);
+     * */
+    async validateElementCountToBe(locator, expectedCount) {
+        await (0, test_1.expect)(locator).toHaveCount(expectedCount);
+    }
+    /**
+     * Validates that two elements are not overlapping.
+     * @param element1 The first locator.
+     * @param element2 The second locator.
+     */
+    async validateElementsDoNotOverlap(element1, element2) {
+        const box1 = await element1.boundingBox();
+        const box2 = await element2.boundingBox();
+        if (!box1 || !box2) {
+            throw new Error("Unable to get bounding boxes for overlap validation.");
+        }
+        const overlapping = !(box1.x + box1.width < box2.x ||
+            box2.x + box2.width < box1.x ||
+            box1.y + box1.height < box2.y ||
+            box2.y + box2.height < box1.y);
+        (0, test_1.expect)(overlapping).toBe(false);
+    }
+    /**
+     * Waits for an element with the given ID to appear in the DOM within the specified timeout,
+     * and then validates that the element is visible.
+     *
+     * @param id - The ID of the element to validate visibility for.
+     * @param timeout - Maximum time to wait for the element to appear (in milliseconds). Defaults to 10 seconds.
+     */
+    async validateElementToBeVisibleById(id, timeout = 10000) {
+        await this.page.locator(`#${id}`).waitFor({ timeout });
+        await (0, test_1.expect)(this.page.locator(`#${id}`)).toBeVisible();
+    }
+    /** Validates that a given element is visible and contains the expected text.
+     * @param element - The Playwright Locator for the element to validate.
+     * @param expectedText - The exact text expected to be present in the element.
+     * @param timeout - Optional timeout (in ms) to wait for visibility and text match. Default is 60 seconds.
+     * await validations.validateElementToHaveText(page.locator('.success-message'), 'Upload Complete');
+     */
+    async validateElementToHaveText(element, expectedText, timeout = 60000) {
+        this.logger.info(`Validating element to have text: ${expectedText}`);
+        const locator = typeof element === 'string' ? this.page.locator(`#${element}`) : element;
+        await (0, test_1.expect)(locator).toBeVisible({ timeout });
+        await (0, test_1.expect)(locator).toHaveText(expectedText, { timeout });
+    }
+    /**
+     * Validates that a given element has the expected text.
+     * @param element The locator of the element to validate.
+     * @param expectedText The expected text of the element.
+     */
+    async validateText(actualText, expectedText) {
+        this.logger.info(`Validating text: ${actualText} to be ${expectedText}`);
+        await (0, test_1.expect)(actualText).toBe(expectedText);
+    }
+    /**
+     * Validates that a given element has the expected text.
+     * @param element The locator of the element to validate.
+     * @param expectedText The expected text of the element.
+     */
+    async validateTextNotToBe(actualText, expectedText) {
+        await (0, test_1.expect)(actualText).not.toBe(expectedText);
+    }
+    /**
+     * Validates that a given element is enabled.
+     * @param element The locator of the element to validate.
+     */
+    async validateElementToBeEnabled(element) {
+        await (0, test_1.expect)(element).toBeEnabled();
+    }
+    /**
+     * Validates that a given element is hidden.
+     * @param element The locator of the element to validate.
+     */
+    async validateElementToBeHidden(element) {
+        await (0, test_1.expect)(element).toBeHidden();
+    }
+    /**
+     * Validates that multiple elements are hidden.
+     * @param elements Array of Playwright locators to validate.
+     */
+    async validateElementsToBeHidden(elements) {
+        for (const element of elements) {
+            await (0, test_1.expect)(element).toBeHidden();
+        }
+    }
+    /**
+     * Validates that a given element (Locator or string ID) has a specific attribute with a specific value.
+     * @param element - The element to validate (Playwright Locator or string ID).
+     * @param attr - The attribute to check.
+     * @param value - The expected value of the attribute.
+     * @param timeout - Optional timeout in milliseconds (default: 10s).
+     */
+    async validateElementToHaveAttribute(element, attr, value, timeout = 10000) {
+        const target = typeof element === 'string' ? this.page.locator(`#${element}`) : element;
+        await (0, test_1.expect)(target).toBeVisible({ timeout });
+        await (0, test_1.expect)(target).toHaveAttribute(attr, value, { timeout });
+    }
+    /**
+    * Validates that a given element contains the expected text (partial or regex).
+    * @param element The locator or string ID of the element.
+    * @param expectedText The expected partial text or RegExp to be found in the element.
+    * @param timeout Maximum time to wait for the element to become visible and contain the text (default: 60s).
+    */
+    async validateElementToContainText(element, expectedText, timeout = 60000) {
+        const locator = typeof element === 'string' ? this.page.locator(`#${element}`) : element;
+        await (0, test_1.expect)(locator).toBeVisible({ timeout });
+        await (0, test_1.expect)(locator).toContainText(expectedText, { timeout });
+    }
+    /**
+     * Checks if an element with the given ID is visible on the page.
+     * This method runs inside the browser context using `page.evaluate` to:
+     * - Find the DOM element using `getElementById`.
+     * - Return false if the element doesn't exist.
+     * - Otherwise, check if the element's `display` style is not set to `"none"`,
+     *   which indicates whether the element is visible or hidden via CSS.
+     * @param elementId - The ID of the element to check visibility for.
+     * @returns A promise that resolves to `true` if the element is visible,
+     * or `false` if it's hidden or not found.
+     */
+    async isElementVisible(elementId) {
+        return await this.page.evaluate((id) => {
+            const element = document.getElementById(id);
+            if (!element)
+                return false;
+            return window.getComputedStyle(element).display !== "none";
+        }, elementId);
+    }
+    /**
+     * Checks if an element with the given ID is visible on the page using Playwright commands.
+     * It asserts that the element is visible within the given timeout.
+     *
+     * @param elementId - The ID of the element to check.
+     * @param timeout - The maximum time to wait for the element to become visible (in ms). Default is 5000 ms.
+     */
+    async validateElementVisibleById(elementId, timeout = 60000) {
+        const locator = this.page.locator(`#${elementId}`);
+        await (0, test_1.expect)(locator).toBeVisible({ timeout });
+    }
+    /**
+    * Validates that a value is null.
+    * @param actual The actual value to check.
+    */
+    async validateValueToBeNull(actual) {
+        await (0, test_1.expect)(actual).toBeNull();
+    }
+    /**
+     * Validates that a value is not null.
+     * @param actual The actual value to check.
+     */
+    async validateValueNotToBeNull(actual) {
+        await (0, test_1.expect)(actual).not.toBeNull();
+    }
+    /**
+     * Validates that a value is greater than the expected value.
+     * @param actual The actual number.
+     * @param expected The number to compare against.
+     */
+    async validateValueToBeGreaterThan(actual, expected) {
+        this.logger.info(`Validating value ${actual} is greater than ${expected}`);
+        await (0, test_1.expect)(actual).toBeGreaterThan(expected);
+    }
+    /**
+     * Validates that a value is less than or equal to the expected value.
+     * @param actual The actual number.
+     * @param expected The number to compare against.
+     */
+    async validateValueToBeLessThanOrEqual(actual, expected) {
+        await (0, test_1.expect)(actual).toBeLessThanOrEqual(expected);
+    }
+    /**
+    * Validates that the actual value is equal to the expected value.
+    * @param actual - The actual value.
+    * @param expected - The expected value to compare.
+    * @param message - Optional custom message for assertion failure.
+    */
+    async validateValueToEqual(actual, expected, message) {
+        await (0, test_1.expect)(actual, message).toEqual(expected);
+    }
+    /**
+     * Validates that the actual value is NOT equal to the expected value.
+     * @param actual - The actual value.
+     * @param expected - The value that should not match.
+     * @param message - Optional custom message for assertion failure.
+     */
+    async validateValueNotToEqual(actual, expected, message) {
+        await (0, test_1.expect)(actual, message).not.toEqual(expected);
+    }
+    /**
+     * Validates that the actual number is less than the expected number.
+     * @param actual - The actual number.
+     * @param expected - The number to compare against.
+     */
+    async validateValueToBeLessThan(actual, expected) {
+        this.logger.info(`Validating value ${actual} is less than ${expected}`);
+        await (0, test_1.expect)(actual).toBeLessThan(expected);
+    }
+    /**
+     * Validates that the actual value is truthy.
+     * @param actual - The value to validate.
+     */
+    async validateValueToBeTruthy(actual) {
+        this.logger.info(`Validating value is truthy: ${actual}`);
+        await (0, test_1.expect)(actual).toBeTruthy();
+    }
+    /**
+     * Validates that the actual value is falsy.
+     * @param actual - The value to validate.
+     */
+    async validateValueToBeFalsy(actual) {
+        await (0, test_1.expect)(actual).toBeFalsy();
+    }
+    /**
+     * Validates that the actual array or string contains the expected item or substring.
+     * @param actual - The array or string.
+     * @param expected - The item or substring to check for.
+     */
+    async validateValueToContain(actual, expected) {
+        this.logger.info(`Validating value contains: ${expected}`);
+        await (0, test_1.expect)(actual).toContain(expected);
+    }
+    /**
+     * Validates that the actual string matches the given regular expression or substring.
+     * @param actual - The string to validate.
+     * @param expected - The regular expression or substring.
+     */
+    async validateValueToMatch(actual, expected) {
+        await (0, test_1.expect)(actual).toMatch(expected);
+    }
+    /**
+     * Compares two arrays for equality (order-sensitive) using Playwright's expect.
+     * @param expected The expected array values.
+     * @param actual The actual array values.
+     * @param message Optional message for error context.
+     */
+    async validateArrayTextValues(expected, actual, message = 'Array mismatch') {
+        test_1.expect.soft(actual.length, `${message} - length`).toBe(expected.length);
+        for (let i = 0; i < expected.length; i++) {
+            test_1.expect.soft(actual[i], `${message} - index ${i}`).toBe(expected[i]);
+        }
+    }
+    /**
+     * Compares two objects containing arrays (order-sensitive) using Playwright's expect.
+     * Each key in the object is compared individually with soft assertions.
+     * @param expected The expected object with array values.
+     * @param actual The actual object with array values.
+     * @param message Optional message for error context.
+     */
+    async validateObjectOfArrayTextValues(expected, actual, message = 'Object of arrays mismatch') {
+        for (const key of Object.keys(expected)) {
+            const expectedArray = expected[key];
+            const actualArray = actual[key];
+            test_1.expect.soft(actualArray.length, `${message} - '${key}' length`).toBe(expectedArray.length);
+            for (let i = 0; i < expectedArray.length; i++) {
+                const expectedText = expectedArray[i].replace(/\s+/g, ' ').trim();
+                const actualText = actualArray[i].replace(/\s+/g, ' ').trim();
+                test_1.expect.soft(actualText, `${message} - '${key}' index ${i}`).toBe(expectedText);
+            }
+        }
+    }
+    /**
+     * Validates that the current page URL contains the expected string.
+     * Useful when the URL may include dynamic query parameters or fragments.
+     * @param expectedUrl - The expected substring to be present in the current URL.
+     */
+    async validateUrlToMatch(endpoint) {
+        await (0, test_1.expect)(this.page).toHaveURL(endpoint);
+    }
+    /**
+     * Validates that the current page URL starts with the expected string.
+     * Useful when the URL has dynamic query parameters.
+     * @param expectedUrl - The expected base URL (without query params).
+     */
+    async validateUrlToContain(expectedUrl) {
+        const currentUrl = this.page.url();
+        await (0, test_1.expect)(currentUrl.includes(expectedUrl)).toBeTruthy();
+    }
+    /**
+     * Validates that the element has the expected class name.
+     * @param locator - The element locator.
+     * @param expected - The class name to match (string or RegExp).
+     */
+    async validateLocatorToHaveClass(locator, expected) {
+        await (0, test_1.expect)(locator).toHaveClass(expected);
+    }
+    /** Validates all visible crop drag handles have correct accessibility attributes.
+     * Skips any handles that are not currently visible.
+     * @param page - Playwright Page instance
+     */
+    async validateCropDragHandles(page) {
+        const directions = ['nw', 'n', 'ne', 'e', 'se', 's', 'sw', 'w'];
+        for (const dir of directions) {
+            const handle = page.locator(`.ReactCrop__drag-handle.ord-${dir}`);
+            await handle.isVisible();
+            await handle.getAttribute('role');
+        }
+    }
+    /**
+     * Validates if a given value is true or false.
+     * @param actual - The actual boolean value or a function that returns a boolean.
+     * @param expected - Expected boolean value (true or false).
+     * @param message - Optional custom error message on failure.
+     */
+    async validateToBeBoolean(actual, expected, message) {
+        const resolvedActual = typeof actual === 'function' ? await actual() : actual;
+        if (expected) {
+            (0, test_1.expect)(resolvedActual, message ?? 'Expected value to be true').toBeTruthy();
+        }
+        else {
+            (0, test_1.expect)(resolvedActual, message ?? 'Expected value to be false').toBeFalsy();
+        }
+    }
+    /**
+     * Validates that a given element has the specified class or matches the given class pattern.
+     * @param element The locator of the element to validate.
+     * @param expectedClass The expected class name or regex pattern.
+     */
+    async validateElementToHaveClass(element, expected) {
+        this.logger.info(`Validating element has class: ${expected}`);
+        let locator;
+        if (typeof element === 'string') {
+            locator = this.page.locator(`#${element}`);
+        }
+        else {
+            locator = element;
+        }
+        await locator.waitFor({ state: 'visible' });
+        await (0, test_1.expect)(locator).toHaveClass(expected);
+    }
+    /**
+     * Validates that a given element has the expected CSS class.
+     * @param element The locator of the element to validate.
+     * @param expectedClass The class name expected to be present on the element.
+     */
+    async validateElementToContainClass(element, expectedClass) {
+        const classAttr = await element.getAttribute('class');
+        (0, test_1.expect)(classAttr).toContain(expectedClass);
+    }
+    /**
+    * Validates that an asynchronous condition passes within a given timeout.
+    * @param condition A function that returns a promise to be resolved.
+    * @param timeout The timeout for the condition to pass.
+    */
+    async validateAsyncCondition(condition, timeout) {
+        await (0, test_1.expect)(condition).toPass({ timeout });
+    }
+    /**
+     * Validates that a given element has the expected CSS property and value.
+     * @param locator The locator of the element to validate.
+     * @param cssProperty The CSS property to check.
+     * @param expectedValue The expected value of the CSS property.
+     */
+    async validateElementToHaveCSS(locator, cssProperty, expectedValue) {
+        await (0, test_1.expect)(locator).toHaveCSS(cssProperty, expectedValue);
+    }
+    /**
+     * Validates that the actual value is equal to the expected value.
+     * @param actual - The actual value.
+     * @param expected - The expected value to compare.
+     */
+    async validateValueToBe(actual, expected) {
+        await (0, test_1.expect)(actual).toBe(expected);
+    }
+    /**
+     * Gets the value of a given attribute from a locator.
+     * @param locator - Playwright Locator for the element.
+     * @param attributeName - The attribute name to fetch (e.g., "aria-checked", "data-id").
+     * @returns Promise resolving to the attribute value or null if not present.
+     */
+    async getAttributeValueByLocator(locator, attributeName) {
+        return await locator.getAttribute(attributeName);
+    }
+    /**
+     * Validates that the given element does NOT have the specified attribute value.
+     * If the attribute is missing, the check passes.
+     * If the attribute exists, its value must not equal the provided one.
+     * @param element Locator of the element to validate
+     * @param attr Attribute name to check (e.g., "class", "disabled")
+     * @param value Attribute value that should NOT be present
+     */
+    async validateElementNotToHaveAttributeValue(element, attr, value) {
+        await (0, test_1.expect)(element).not.toHaveAttribute(attr, value);
+    }
+    /**
+     * Validates that all layered file names exist in the photo tray file names.
+     * @param photoTrayFileNames - Array of file names currently available in the photo tray.
+     * @param layeredFileNames   - Array of file names that are layered/applied on the canvas.
+     * The function ensures integrity between the canvas and the photo tray,
+     * by checking that every layered file originates from the photo tray.
+     */
+    async validateValuesToContain(photoTrayFileNames, layeredFileNames) {
+        for (const fileName of layeredFileNames) {
+            await (0, test_1.expect)(photoTrayFileNames).toContain(fileName);
+        }
+    }
+    /**
+     * Validates that multiple elements are visible on the page.
+     * @param {Locator[]} elements - Array of Playwright locators to validate.
+     * @returns {Promise<void>} Resolves when all elements are confirmed visible.
+     */
+    async validateElementsToBeVisible(elements) {
+        for (const element of elements) {
+            await (0, test_1.expect)(element).toBeVisible();
+        }
+    }
+    /** Waits until a given element is visible in the DOM.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in ms (default: 10s).
+     */
+    async waitForElementVisible(element, timeout = 10000) {
+        await element.waitFor({ state: 'visible', timeout });
+    }
+    /**
+     * Checks if given elements have expected text.
+     * Accepts either locator or string ID.
+     */
+    async validateElementsToHaveText(locators, expectedTexts) {
+        for (let i = 0; i < locators.length; i++) {
+            const locator = locators[i];
+            await this.validateElementToHaveText(locator, expectedTexts[i]);
+        }
+    }
+}
+exports.BasePageValidations = BasePageValidations;

package/dist/transit-core-taf/base/basepagewaits.d.ts

@@ -0,0 +1,54 @@
+import { Page, Locator } from 'playwright';
+import { Logger } from './logger';
+export declare class BasePageWaits {
+    private page;
+    private logger;
+    constructor(page: Page, logger: Logger);
+    /**
+     * Waits for the page to be fully loaded.
+     */
+    waitForPageLoad(timeout?: number): Promise<void>;
+    waitForDomContentLoad(): Promise<void>;
+    waitForNetworkIdle(): Promise<void>;
+    /**
+     * Waits for either DOM content to load or the full page to load, based on the provided flag.
+     * @param {boolean} [waitForDomOnly=false] -
+     * If true, waits only for DOM content to be loaded using `waitForDomContentLoad()`.
+     * If false (default), waits for the full page load using `waitForPageLoad()`.
+     * This method is useful when navigating between pages or clicking links where
+     * you want to optimize waiting time based on the expected load behavior.
+     */
+    waitForPageLoadOnCondition(waitForDomOnly?: boolean): Promise<void>;
+    /**
+     * Waits for a specified number of seconds.
+     * @param seconds The number of seconds to wait.
+     */
+    waitForSeconds(seconds: number): Promise<void>;
+    /**
+     * Navigates to a URL and waits for the page to load.
+     * @param url The URL to navigate to.
+     */
+    goto(url: string): Promise<void>;
+    /**
+     * Checks if an element is visible on the page.
+     * @param selector The selector of the element to check.
+     * @returns A promise that resolves to true if the element is visible, and false otherwise.
+     */
+    isElementVisible(selector: string): Promise<boolean>;
+    /**
+     * Waits for the progress spinner to become invisible.
+     * The spinner is identified by the '#progress-status' selector, and this method
+     * is robust against the changing text within the spinner.
+     */
+    waitForProgressSpinnerInvisibility(): Promise<void>;
+    waitFoPhotosUploadingSpinnerInvisibility(): Promise<void>;
+    waitForLeftWellSpinnerInvisibility(): Promise<void>;
+    waitForSaveToBeSuccessful(timeout: 20000): Promise<void>;
+    waitForApplyLayoutsToAllPages(): Promise<void>;
+    /**
+     * Waits for a given element to be visible on the page.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in milliseconds (default: 5000).
+     */
+    waitForElementToBeVisible(element: Locator, timeout?: number): Promise<void>;
+}

package/dist/transit-core-taf/base/basepagewaits.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePageWaits = void 0;
+class BasePageWaits {
+    page;
+    logger;
+    constructor(page, logger) {
+        this.page = page;
+        this.logger = logger;
+    }
+    /**
+     * Waits for the page to be fully loaded.
+     */
+    async waitForPageLoad(timeout = 240000) {
+        this.logger.info("Waiting for page to load...");
+        await this.page.waitForLoadState('domcontentloaded', { timeout });
+        try {
+            // await this.page.waitForLoadState('networkidle', { timeout });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Network idle state not reached within ${timeout / 1000}s. Continuing...`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForDomContentLoad() {
+        this.logger.info("Waiting for DOM content to load...");
+        await this.page.waitForLoadState('domcontentloaded');
+    }
+    async waitForNetworkIdle() {
+        await this.page.waitForLoadState('networkidle');
+    }
+    /**
+     * Waits for either DOM content to load or the full page to load, based on the provided flag.
+     * @param {boolean} [waitForDomOnly=false] -
+     * If true, waits only for DOM content to be loaded using `waitForDomContentLoad()`.
+     * If false (default), waits for the full page load using `waitForPageLoad()`.
+     * This method is useful when navigating between pages or clicking links where
+     * you want to optimize waiting time based on the expected load behavior.
+     */
+    async waitForPageLoadOnCondition(waitForDomOnly = false) {
+        if (waitForDomOnly) {
+            await this.waitForDomContentLoad();
+        }
+        else {
+            await this.waitForPageLoad();
+        }
+    }
+    /**
+     * Waits for a specified number of seconds.
+     * @param seconds The number of seconds to wait.
+     */
+    async waitForSeconds(seconds) {
+        this.logger.info(`Waiting for ${seconds} seconds...`);
+        await this.page.waitForTimeout(seconds * 1000);
+    }
+    /**
+     * Navigates to a URL and waits for the page to load.
+     * @param url The URL to navigate to.
+     */
+    async goto(url) {
+        await this.page.goto(url);
+        await this.waitForPageLoad();
+    }
+    /**
+     * Checks if an element is visible on the page.
+     * @param selector The selector of the element to check.
+     * @returns A promise that resolves to true if the element is visible, and false otherwise.
+     */
+    async isElementVisible(selector) {
+        return await this.page.locator(selector).isVisible();
+    }
+    /**
+     * Waits for the progress spinner to become invisible.
+     * The spinner is identified by the '#progress-status' selector, and this method
+     * is robust against the changing text within the spinner.
+     */
+    async waitForProgressSpinnerInvisibility() {
+        const spinnerSelector = '#progress-status';
+        try {
+            await this.page.waitForSelector(spinnerSelector, { state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Progress spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitFoPhotosUploadingSpinnerInvisibility() {
+        const preparingPhotosSelector = this.page.getByText(/Preparing Photos...Uploading \d+ Photos/);
+        try {
+            await preparingPhotosSelector.waitFor({ state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Uploading spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForLeftWellSpinnerInvisibility() {
+        const spinnerSelector = '#transparent-well-overlay';
+        try {
+            await this.page.waitForSelector(spinnerSelector, { state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Left well spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForSaveToBeSuccessful(timeout) {
+        const saveTooltip = this.page.locator('#save-tooltip');
+        await saveTooltip.waitFor({ state: 'visible', timeout });
+        const message = this.page.locator('div.tooltip-gl__box:has-text("Your project was successfully saved")');
+        await message.waitFor({ state: 'visible', timeout });
+        await saveTooltip.waitFor({ state: 'hidden', timeout });
+    }
+    async waitForApplyLayoutsToAllPages() {
+        const overlaySelector = '#transparent-page-overlay';
+        try {
+            // Wait for the overlay to disappear (opacity = 0)
+            await this.page.waitForFunction((selector) => {
+                const element = document.querySelector(selector);
+                if (element) {
+                    const style = window.getComputedStyle(element);
+                    return parseFloat(style.opacity) === 0;
+                }
+                return true; // If element is gone, it's also considered "disappeared"
+            }, overlaySelector, { timeout: 240000 } // 4 minutes timeout for it to disappear
+            );
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Apply layouts to all pages overlay did not become transparent within the timeout.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Waits for a given element to be visible on the page.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in milliseconds (default: 5000).
+     */
+    async waitForElementToBeVisible(element, timeout = 10000) {
+        try {
+            this.logger.info(`🔍 Waiting for element to be visible: ${element.toString()} (timeout: ${timeout}ms)`);
+            await element.waitFor({ state: 'visible', timeout });
+        }
+        catch (error) {
+            this.logger.error(`❌ Failed to find visible element: ${element.toString()} within ${timeout}ms`);
+            throw error;
+        }
+    }
+}
+exports.BasePageWaits = BasePageWaits;