transit-core-taf 1.0.4 → 1.0.5

package/dist/transit-core-taf/baseapi/apiutils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handles the response from the API.
+ * @param {Response} response - The response object from the fetch call.
+ * @returns {Promise<{status: number, responseBody: any}>} A promise that resolves to an object containing the status and response body.
+ */
+export declare function handleResponse(response: Response): Promise<{
+    status: number;
+    responseBody: any;
+}>;

package/dist/transit-core-taf/baseapi/apiutils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleResponse = handleResponse;
+/**
+ * Handles the response from the API.
+ * @param {Response} response - The response object from the fetch call.
+ * @returns {Promise<{status: number, responseBody: any}>} A promise that resolves to an object containing the status and response body.
+ */
+async function handleResponse(response) {
+    /** Handle cases where the response might not have a body (e.g., 204 No Content) */
+    const contentType = response.headers.get("content-type");
+    if (response.status === 204 || !contentType || !contentType.includes("application/json")) {
+        return {
+            status: response.status,
+            responseBody: await response.text()
+        };
+    }
+    const responseBody = await response.json();
+    return {
+        status: response.status,
+        responseBody: responseBody
+    };
+}

package/dist/transit-core-taf/baseapi/baseapihelpers.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from "../baseui/logger";
+export declare class BaseApi {
+    private logger;
+    constructor(logger: Logger);
+    get(url: string, options?: RequestInit): Promise<Response>;
+    post(url: string, options?: RequestInit): Promise<Response>;
+    put(url: string, options?: RequestInit): Promise<Response>;
+    delete(url: string, options?: RequestInit): Promise<Response>;
+    patch(url: string, options?: RequestInit): Promise<Response>;
+}

package/dist/transit-core-taf/baseapi/baseapihelpers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApi = void 0;
+class BaseApi {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async get(url, options) {
+        this.logger.info(`GET request to ${url}`);
+        return fetch(url, {
+            ...options,
+            method: 'GET',
+        });
+    }
+    async post(url, options) {
+        this.logger.info(`POST request to ${url}`);
+        return fetch(url, {
+            ...options,
+            method: 'POST',
+        });
+    }
+    async put(url, options) {
+        this.logger.info(`PUT request to ${url}`);
+        return fetch(url, {
+            ...options,
+            method: 'PUT',
+        });
+    }
+    async delete(url, options) {
+        this.logger.info(`DELETE request to ${url}`);
+        return fetch(url, {
+            ...options,
+            method: 'DELETE',
+        });
+    }
+    async patch(url, options) {
+        this.logger.info(`PATCH request to ${url}`);
+        return fetch(url, {
+            ...options,
+            method: 'PATCH',
+        });
+    }
+}
+exports.BaseApi = BaseApi;

package/dist/transit-core-taf/baseui/basepageactions.d.ts

@@ -0,0 +1,178 @@
+import { Locator, Page } from '@playwright/test';
+import { Logger } from './logger';
+export declare class BasePageActions {
+    private page;
+    private waits;
+    private logger;
+    constructor(page: Page, logger: Logger);
+    /**
+     * Waits for an element to be visible and clicks on it.
+     * Logs the action and provides an error message if the element isn't visible in time.
+     * @param element The locator of the element to click.
+     * @param timeout Optional timeout in ms to wait for visibility (default: 30s).
+     */
+    clickElement(element: Locator, timeout?: number): Promise<void>;
+    /**
+     * Clicks an element using its locator.
+     * @param {Locator} element - The Playwright locator of the element to click.
+     * @param {Object} [options={}] - Click options.
+     * @param {number} [options.timeout=120000] - Maximum time to wait for the element.
+     * @param {boolean} [options.force=false] - Whether to force the click (useful if the element is not interactable).
+     */
+    clickByLocator(element: Locator, options?: {
+        timeout?: number;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Locates a button with the specified text on the page.
+     *
+     * Note: This function currently only creates the locator but does not perform a click.
+     *
+     * @param buttonText - The visible text of the button to locate.
+    */
+    clickButtonByText(buttonText: string, timeout?: number): Promise<void>;
+    /**
+     * Locates a button with the specified text on the page.
+     *
+     * Note: This function currently only creates the locator but does not perform a click.
+     *
+     * @param buttonText - The visible text of the button to locate.
+    */
+    clickById(id: string, clickIfVisible?: boolean, timeout?: number): Promise<void>;
+    /**
+     * Fills an input element with a given value.
+     * @param element The locator of the input element.
+     * @param value The value to fill the input with.
+     */
+    fillInput(element: Locator, value: string): Promise<void>;
+    /**
+     * Clears the value of an input element.
+     * @param element The locator of the input element.
+     */
+    clearInput(element: Locator): Promise<void>;
+    /**
+     * Types a text into an element slowly, with a specified delay between keystrokes.
+     * @param element The locator of the element to type into.
+     * @param text The text to type.
+     * @param delay The delay between keystrokes in milliseconds (default is 100).
+     */
+    typeSlowly(element: Locator, text: string, delay?: number): Promise<void>;
+    /**
+     * Hovers over a given element.
+     * @param element The locator of the element to hover over.
+     */
+    hoverOverElement(element: Locator, timeout?: number): Promise<void>;
+    /**
+     * Presses a key on a given element.
+     * @param element The locator of the element.
+     * @param key The key to press (e.g., 'Enter', 'ArrowDown').
+     */
+    pressKey(element: Locator, key: string): Promise<void>;
+    /**
+     * Checks a checkbox if it is not already checked.
+     * @param element The locator of the checkbox element.
+     */
+    checkCheckbox(element: Locator): Promise<void>;
+    /**
+     * Unchecks a checkbox if it is already checked.
+     * @param element The locator of the checkbox element.
+     */
+    uncheckCheckbox(element: Locator): Promise<void>;
+    /**
+     * Selects an option from a dropdown element by its value.
+     * @param element The locator of the select element.
+     * @param value The value of the option to select.
+     */
+    selectOption(element: Locator, value: string): Promise<void>;
+    /**
+   * Retrieves the text content of an element by its ID.
+   *
+   * @param id - The ID of the HTML element to retrieve text from.
+   * @returns The text content of the specified element.
+   */
+    getElementTextById(id: string): Promise<string | undefined>;
+    /**
+     * Retrieves the text content of an element by its Locator.
+     * @param locator - The Locator of the HTML element to retrieve text from.
+     * @returns The text content of the specified element.
+     */
+    getElementTextByLocator(locator: Locator): Promise<string>;
+    /**Gets the specified attribute value of an element using its ID.
+     * @param id The ID of the element.
+     * @param attribute The attribute name (e.g., 'value', 'min', 'max')
+     */
+    getElementAttributeValueById(id: string, attribute: string): Promise<string | undefined>;
+    /**
+     * Gets the specified attribute value of an element using a Locator.
+     * @param locator The Playwright Locator for the element.
+     * @param attribute The attribute name (e.g., 'value', 'min', 'max').
+     * @returns The attribute value as a string (or undefined if not present).
+     */
+    getAttributeValueByLocator(locator: Locator, attribute: string): Promise<string | undefined>;
+    /** Fills an input element identified by its ID with a given value.
+    * - Waits for the input to be visible before filling.
+    *
+    * @param elementId - The ID of the input element.
+    * @param value - The value to fill the input with.
+    */
+    fillInputById(elementId: string, value: string): Promise<void>;
+    /**
+     * Clicks a tab by its text and validates that it's selected using accessibility and style attributes.
+     * @param tabText - Visible text of the tab (e.g., "Crop").
+     * @param timeout - Optional timeout for the click action.
+     */
+    validateCropTabSelected(tabLocator: Locator, timeout?: number): Promise<void>;
+    /**
+     * Counts the number of objects in the array where the given key is null or undefined.
+     * @param items - The array of items to check.
+     * @param key - The key to inspect on each item.
+     * @returns The number of items where the key is null or undefined.
+     */
+    getNullCountByType(items: any[], key: string): Promise<number>;
+    /**
+     * Sets the viewport size and waits for DOM content to be loaded.
+     * @param viewport - An object with width and height properties.
+     */
+    setViewport(viewport: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    /**
+     * Reloads the current page and waits until the DOM is fully loaded.
+     * @param options - Optional reload options (timeout, waitUntil).
+     */
+    reloadPage(options?: {
+        timeout?: number;
+        waitUntil?: 'load' | 'domcontentloaded' | 'networkidle';
+    }): Promise<void>;
+    /**
+     * Universal drag-and-drop method for builder elements (photos, layouts, backgrounds, stickers).
+     * Accepts either a string selector or a Playwright Locator for both source and target.
+     * @param source - Locator or string selector for the element to drag.
+     * @param target - Locator or string selector for the drop target.
+     * @param attribute - (Optional) Attribute to return from the dragged element (default: "data-id").
+     * @returns The attribute value if available, otherwise null.
+     */
+    dragElementToTarget(source: Locator | string, target: Locator | string, attribute?: string): Promise<string | null>;
+    /**
+     * Gives the textcontent of all elements .
+     * @param locator The ID of the element.
+     * Returns array of values of all the elements textcontent
+     */
+    getAllTextContents(locator: Locator): Promise<string[]>;
+    /**
+     * @param locator The ID of the element.
+     * Click on element if its not expanded
+     */
+    clickIfNotExpanded(locator: Locator): Promise<void>;
+    /**
+     * Performs a mouse click at the given screen coordinates.
+     * @param x - The x-coordinate for the click.
+     * @param y - The y-coordinate for the click.
+     * @param options - Optional click options like button or clickCount.
+     */
+    mouseClickAt(x: number, y: number, options?: {
+        button?: 'left' | 'right' | 'middle';
+        clickCount?: number;
+    }): Promise<void>;
+}

package/dist/transit-core-taf/baseui/basepageactions.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePageActions = void 0;
+const basepagewaits_1 = require("./basepagewaits");
+class BasePageActions {
+    page;
+    waits;
+    logger;
+    constructor(page, logger) {
+        this.page = page;
+        this.waits = new basepagewaits_1.BasePageWaits(page, logger);
+        this.logger = logger;
+    }
+    /**
+     * Waits for an element to be visible and clicks on it.
+     * Logs the action and provides an error message if the element isn't visible in time.
+     * @param element The locator of the element to click.
+     * @param timeout Optional timeout in ms to wait for visibility (default: 30s).
+     */
+    async clickElement(element, timeout = 30000) {
+        try {
+            this.logger.info(`[Action] Waiting for element to be visible before clicking: ${element}`);
+            await element.waitFor({ state: 'visible', timeout });
+            this.logger.info(`[Action] Clicking on element: ${element}`);
+            await element.click({ timeout });
+        }
+        catch (error) {
+            this.logger.error(`[Error] Failed to click element. It was not visible within ${timeout}ms: ${element}`);
+            throw error;
+        }
+    }
+    /**
+     * Clicks an element using its locator.
+     * @param {Locator} element - The Playwright locator of the element to click.
+     * @param {Object} [options={}] - Click options.
+     * @param {number} [options.timeout=120000] - Maximum time to wait for the element.
+     * @param {boolean} [options.force=false] - Whether to force the click (useful if the element is not interactable).
+     */
+    async clickByLocator(element, options = {}) {
+        const { timeout = 120000, force = false } = options;
+        this.logger.info(`Clicking by locator: ${element}`);
+        await element.waitFor({ state: 'visible', timeout });
+        await element.click({ timeout, force });
+        await this.waits.waitForDomContentLoad();
+    }
+    /**
+     * Locates a button with the specified text on the page.
+     *
+     * Note: This function currently only creates the locator but does not perform a click.
+     *
+     * @param buttonText - The visible text of the button to locate.
+    */
+    async clickButtonByText(buttonText, timeout = 60000) {
+        const button = this.page.locator('button', { hasText: buttonText });
+        await button.click({ timeout });
+        await this.waits.waitForPageLoad();
+    }
+    /**
+     * Locates a button with the specified text on the page.
+     *
+     * Note: This function currently only creates the locator but does not perform a click.
+     *
+     * @param buttonText - The visible text of the button to locate.
+    */
+    async clickById(id, clickIfVisible = false, timeout = 60000) {
+        this.logger.info(`Clicking by id: ${id}`);
+        const element = this.page.locator(`#${id}`);
+        try {
+            await element.waitFor({ state: 'visible', timeout });
+            if (clickIfVisible) {
+                if (await element.isVisible()) {
+                    await element.click({ timeout });
+                    await this.waits.waitForDomContentLoad();
+                }
+            }
+            else {
+                await element.click({ timeout });
+                await this.waits.waitForDomContentLoad();
+            }
+        }
+        catch (error) {
+            this.logger.error(`Element with ID '${id}' was not visible within ${timeout} ms.`);
+            throw error;
+        }
+    }
+    /**
+     * Fills an input element with a given value.
+     * @param element The locator of the input element.
+     * @param value The value to fill the input with.
+     */
+    async fillInput(element, value) {
+        await element.fill(value);
+    }
+    /**
+     * Clears the value of an input element.
+     * @param element The locator of the input element.
+     */
+    async clearInput(element) {
+        await element.fill('');
+    }
+    /**
+     * Types a text into an element slowly, with a specified delay between keystrokes.
+     * @param element The locator of the element to type into.
+     * @param text The text to type.
+     * @param delay The delay between keystrokes in milliseconds (default is 100).
+     */
+    async typeSlowly(element, text, delay = 100) {
+        await element.type(text, { delay });
+    }
+    /**
+     * Hovers over a given element.
+     * @param element The locator of the element to hover over.
+     */
+    async hoverOverElement(element, timeout = 20000) {
+        await element.waitFor({ state: 'visible', timeout });
+        await element.hover();
+    }
+    /**
+     * Presses a key on a given element.
+     * @param element The locator of the element.
+     * @param key The key to press (e.g., 'Enter', 'ArrowDown').
+     */
+    async pressKey(element, key) {
+        await element.press(key);
+    }
+    /**
+     * Checks a checkbox if it is not already checked.
+     * @param element The locator of the checkbox element.
+     */
+    async checkCheckbox(element) {
+        if (!(await element.isChecked())) {
+            await element.check();
+        }
+    }
+    /**
+     * Unchecks a checkbox if it is already checked.
+     * @param element The locator of the checkbox element.
+     */
+    async uncheckCheckbox(element) {
+        if (await element.isChecked()) {
+            await element.uncheck();
+        }
+    }
+    /**
+     * Selects an option from a dropdown element by its value.
+     * @param element The locator of the select element.
+     * @param value The value of the option to select.
+     */
+    async selectOption(element, value) {
+        await element.selectOption(value);
+    }
+    /**
+   * Retrieves the text content of an element by its ID.
+   *
+   * @param id - The ID of the HTML element to retrieve text from.
+   * @returns The text content of the specified element.
+   */
+    async getElementTextById(id) {
+        const text = (await this.page.locator(`#${id}`).textContent())?.toString();
+        return text;
+    }
+    /**
+     * Retrieves the text content of an element by its Locator.
+     * @param locator - The Locator of the HTML element to retrieve text from.
+     * @returns The text content of the specified element.
+     */
+    async getElementTextByLocator(locator) {
+        return (await locator.textContent()) ?? '';
+    }
+    /**Gets the specified attribute value of an element using its ID.
+     * @param id The ID of the element.
+     * @param attribute The attribute name (e.g., 'value', 'min', 'max')
+     */
+    async getElementAttributeValueById(id, attribute) {
+        const locator = await this.page.locator(`#${id}`);
+        const attributeValue = (await locator.getAttribute(attribute))?.toString();
+        return attributeValue;
+    }
+    /**
+     * Gets the specified attribute value of an element using a Locator.
+     * @param locator The Playwright Locator for the element.
+     * @param attribute The attribute name (e.g., 'value', 'min', 'max').
+     * @returns The attribute value as a string (or undefined if not present).
+     */
+    async getAttributeValueByLocator(locator, attribute) {
+        const attributeValue = (await locator.getAttribute(attribute))?.toString();
+        return attributeValue;
+    }
+    /** Fills an input element identified by its ID with a given value.
+    * - Waits for the input to be visible before filling.
+    *
+    * @param elementId - The ID of the input element.
+    * @param value - The value to fill the input with.
+    */
+    async fillInputById(elementId, value) {
+        const element = await this.page.locator(`#${elementId}`);
+        await element.waitFor({ state: 'visible' });
+        await element.fill(value);
+    }
+    /**
+     * Clicks a tab by its text and validates that it's selected using accessibility and style attributes.
+     * @param tabText - Visible text of the tab (e.g., "Crop").
+     * @param timeout - Optional timeout for the click action.
+     */
+    async validateCropTabSelected(tabLocator, timeout = 60000) {
+        await tabLocator.click({ timeout });
+        await this.waits.waitForPageLoad();
+    }
+    /**
+     * Counts the number of objects in the array where the given key is null or undefined.
+     * @param items - The array of items to check.
+     * @param key - The key to inspect on each item.
+     * @returns The number of items where the key is null or undefined.
+     */
+    async getNullCountByType(items, key) {
+        return items.filter((item) => item[key] == null).length;
+    }
+    /**
+     * Sets the viewport size and waits for DOM content to be loaded.
+     * @param viewport - An object with width and height properties.
+     */
+    async setViewport(viewport) {
+        await this.page.setViewportSize(viewport);
+        await this.page.waitForLoadState('domcontentloaded');
+    }
+    /**
+     * Reloads the current page and waits until the DOM is fully loaded.
+     * @param options - Optional reload options (timeout, waitUntil).
+     */
+    async reloadPage(options = { waitUntil: 'load' }) {
+        await this.page.reload(options);
+    }
+    /**
+     * Universal drag-and-drop method for builder elements (photos, layouts, backgrounds, stickers).
+     * Accepts either a string selector or a Playwright Locator for both source and target.
+     * @param source - Locator or string selector for the element to drag.
+     * @param target - Locator or string selector for the drop target.
+     * @param attribute - (Optional) Attribute to return from the dragged element (default: "data-id").
+     * @returns The attribute value if available, otherwise null.
+     */
+    async dragElementToTarget(source, target, attribute = 'data-id') {
+        const toLocator = (input) => {
+            if (typeof input !== 'string')
+                return input;
+            if (/^(#|\.|\[)/.test(input)) {
+                return this.page.locator(input);
+            }
+            return this.page.locator(`#${input}`);
+        };
+        const sourceLocator = toLocator(source);
+        const targetLocator = toLocator(target);
+        await sourceLocator.waitFor({ state: 'visible' });
+        await targetLocator.waitFor({ state: 'visible' });
+        const attrValue = await sourceLocator.getAttribute(attribute);
+        await sourceLocator.dragTo(targetLocator);
+        return attrValue;
+    }
+    /**
+     * Gives the textcontent of all elements .
+     * @param locator The ID of the element.
+     * Returns array of values of all the elements textcontent
+     */
+    async getAllTextContents(locator) {
+        const textContent = await locator.allTextContents();
+        return textContent;
+    }
+    /**
+     * @param locator The ID of the element.
+     * Click on element if its not expanded
+     */
+    async clickIfNotExpanded(locator) {
+        const isExpanded = await locator.getAttribute('aria-expanded');
+        if (isExpanded !== 'true') {
+            await locator.click();
+            await this.waits.waitForDomContentLoad();
+        }
+    }
+    /**
+     * Performs a mouse click at the given screen coordinates.
+     * @param x - The x-coordinate for the click.
+     * @param y - The y-coordinate for the click.
+     * @param options - Optional click options like button or clickCount.
+     */
+    async mouseClickAt(x, y, options = {}) {
+        await this.page.mouse.click(x, y, options);
+    }
+}
+exports.BasePageActions = BasePageActions;