playwright-cucumber-ts-steps 1.1.8 → 1.1.9

package/dist/backend/api/requests.js

@@ -33,27 +33,52 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const registry_1 = require("../../core/registry");
-const state_1 = require("./state");
+exports.MakePostRequestWithFile = exports.MakePostRequestWithTable = exports.MakeDeleteRequest = exports.MakeGetRequest = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// GET Request
-(0, registry_1.Step)("I make a GET request to {string}", async (page, url) => {
+const registry_1 = require("../../core/registry");
+const state_1 = require("./state");
+/**
+ * @module ApiActions
+ */
+/**
+ * Performs a standard HTTP GET request and stores the response in the global API state.
+ * * @example
+ * ```gherkin
+ * When I make a GET request to "[https://api.example.com/users](https://api.example.com/users)"
+ * ```
+ * * @param url - The full URL or endpoint path.
+ */
+exports.MakeGetRequest = (0, registry_1.Step)("I make a GET request to {string}", async (page, url) => {
     const response = await page.request.get(url);
     state_1.apiState.setResponse(response);
     console.log(`GET ${url} - Status: ${response.status()}`);
 });
-// DELETE Request
-(0, registry_1.Step)("I make a DELETE request to {string}", async (page, url) => {
+/**
+ * Performs a standard HTTP DELETE request and stores the response in the global API state.
+ * * @example
+ * ```gherkin
+ * When I make a DELETE request to "/api/users/1"
+ * ```
+ * * @param url - The endpoint path to delete.
+ */
+exports.MakeDeleteRequest = (0, registry_1.Step)("I make a DELETE request to {string}", async (page, url) => {
     const response = await page.request.delete(url);
     state_1.apiState.setResponse(response);
+    console.log(`DELETE ${url} - Status: ${response.status()}`);
 });
-// 1. POST with Data Table
-// Usage:
-// When I make a POST request to "/api/users" with data:
-//   | name | John |
-//   | job  | Dev  |
-(0, registry_1.Step)("I make a POST request to {string} with data", async (page, url, tableData) => {
+/**
+ * Performs an HTTP POST request using a Gherkin Data Table as the JSON payload.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/users" with data
+ * | name | John |
+ * | job  | Dev  |
+ * ```
+ * * @param url - The target endpoint.
+ * @param tableData - The Gherkin Data Table (automatically converted to a JSON object).
+ */
+exports.MakePostRequestWithTable = (0, registry_1.Step)("I make a POST request to {string} with data", async (page, url, tableData) => {
     if (!tableData)
         throw new Error("This step requires a Data Table.");
     // Convert Table [ ["key", "val"], ["k2", "v2"] ] -> Object { key: "val", k2: "v2" }
@@ -66,16 +91,22 @@ const path = __importStar(require("path"));
         headers: { "Content-Type": "application/json" },
     });
     state_1.apiState.setResponse(response);
+    console.log(`POST ${url} (Table) - Status: ${response.status()}`);
 });
-// 2. POST with File Payload
-// Usage: When I make a POST request to "/api/users" with payload from "data/user.json"
-(0, registry_1.Step)("I make a POST request to {string} with payload from {string}", async (page, url, filePath) => {
-    // Resolve file path (relative to root)
+/**
+ * Performs an HTTP POST request using the contents of a local JSON file as the payload.
+ * * @example
+ * ```gherkin
+ * When I make a POST request to "/api/users" with payload from "data/user.json"
+ * ```
+ * * @param url - The target endpoint.
+ * @param filePath - Path to the JSON file relative to the project root.
+ */
+exports.MakePostRequestWithFile = (0, registry_1.Step)("I make a POST request to {string} with payload from {string}", async (page, url, filePath) => {
     const fullPath = path.resolve(process.cwd(), filePath);
     if (!fs.existsSync(fullPath)) {
         throw new Error(`❌ Payload file not found at: ${fullPath}`);
     }
-    // Read and parse JSON
     const fileContent = fs.readFileSync(fullPath, "utf8");
     const payload = JSON.parse(fileContent);
     const response = await page.request.post(url, {
@@ -83,4 +114,5 @@ const path = __importStar(require("path"));
         headers: { "Content-Type": "application/json" },
     });
     state_1.apiState.setResponse(response);
+    console.log(`POST ${url} (File: ${filePath}) - Status: ${response.status()}`);
 });

package/dist/backend/assertions/pageState.d.ts

@@ -1,2 +1,41 @@
-export {};
+/**
+ * @module BrowserAssertions
+ */
+/**
+ * Asserts that the current browser URL contains a specific substring.
+ * Useful for verifying redirection to a general area (e.g., a dashboard).
+ * * @example
+ * ```gherkin
+ * Then I expect the url to contain "dashboard"
+ * ```
+ * * @param part - The substring to search for in the URL.
+ */
+export declare const ExpectUrlToContain: void;
+/**
+ * Asserts that the current browser URL exactly matches the provided string.
+ * * @example
+ * ```gherkin
+ * Then I expect the url to be "[https://example.com/login](https://example.com/login)"
+ * ```
+ * * @param url - The expected full URL.
+ */
+export declare const ExpectUrlToBe: void;
+/**
+ * Asserts that the page's `<title>` tag contains a specific substring.
+ * * @example
+ * ```gherkin
+ * Then I expect the title to contain "Welcome"
+ * ```
+ * * @param part - The substring expected within the page title.
+ */
+export declare const ExpectTitleToContain: void;
+/**
+ * Asserts that the page's `<title>` tag exactly matches the provided string.
+ * * @example
+ * ```gherkin
+ * Then I expect the title to be "My Application - Home"
+ * ```
+ * * @param title - The expected full page title.
+ */
+export declare const ExpectTitleToBe: void;
 //# sourceMappingURL=pageState.d.ts.map

package/dist/backend/assertions/pageState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pageState.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/pageState.ts"],"names":[],"mappings":""}
+{"version":3,"file":"pageState.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/pageState.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,MAM9B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,MAGxB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,MAMhC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,MAG1B,CAAC"}

package/dist/backend/assertions/pageState.js

@@ -1,36 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectTitleToBe = exports.ExpectTitleToContain = exports.ExpectUrlToBe = exports.ExpectUrlToContain = void 0;
 const test_1 = require("@playwright/test");
 const registry_1 = require("../../core/registry");
 /**
- * Checks if the URL contains a specific string.
- * Pattern: Then I expect the url to contain "dashboard"
+ * @module BrowserAssertions
  */
-(0, registry_1.Step)("I expect the url to contain {string}", async (page, part) => {
+/**
+ * Asserts that the current browser URL contains a specific substring.
+ * Useful for verifying redirection to a general area (e.g., a dashboard).
+ * * @example
+ * ```gherkin
+ * Then I expect the url to contain "dashboard"
+ * ```
+ * * @param part - The substring to search for in the URL.
+ */
+exports.ExpectUrlToContain = (0, registry_1.Step)("I expect the url to contain {string}", async (page, part) => {
     await (0, test_1.expect)(page).toHaveURL(new RegExp(part));
     console.log(`✅ URL contains "${part}"`);
 });
 /**
- * Checks if the URL is an exact match.
- * Pattern: Then I expect the url to be "https://google.com"
+ * Asserts that the current browser URL exactly matches the provided string.
+ * * @example
+ * ```gherkin
+ * Then I expect the url to be "[https://example.com/login](https://example.com/login)"
+ * ```
+ * * @param url - The expected full URL.
  */
-(0, registry_1.Step)("I expect the url to be {string}", async (page, url) => {
+exports.ExpectUrlToBe = (0, registry_1.Step)("I expect the url to be {string}", async (page, url) => {
     await (0, test_1.expect)(page).toHaveURL(url);
     console.log(`✅ URL is "${url}"`);
 });
 /**
- * Checks if the page title contains a string.
- * Pattern: Then I expect the title to contain "Welcome"
+ * Asserts that the page's `<title>` tag contains a specific substring.
+ * * @example
+ * ```gherkin
+ * Then I expect the title to contain "Welcome"
+ * ```
+ * * @param part - The substring expected within the page title.
  */
-(0, registry_1.Step)("I expect the title to contain {string}", async (page, part) => {
+exports.ExpectTitleToContain = (0, registry_1.Step)("I expect the title to contain {string}", async (page, part) => {
     await (0, test_1.expect)(page).toHaveTitle(new RegExp(part));
     console.log(`✅ Title contains "${part}"`);
 });
 /**
- * Checks if the page title is an exact match.
- * Pattern: Then I expect the title to be "Welcome Page"
+ * Asserts that the page's `<title>` tag exactly matches the provided string.
+ * * @example
+ * ```gherkin
+ * Then I expect the title to be "My Application - Home"
+ * ```
+ * * @param title - The expected full page title.
  */
-(0, registry_1.Step)("I expect the title to be {string}", async (page, title) => {
+exports.ExpectTitleToBe = (0, registry_1.Step)("I expect the title to be {string}", async (page, title) => {
     await (0, test_1.expect)(page).toHaveTitle(title);
     console.log(`✅ Title is "${title}"`);
 });

package/dist/backend/assertions/text.d.ts

@@ -1,2 +1,47 @@
-export {};
+/**
+ * @module ElementAssertions
+ */
+/**
+ * Asserts that an element exactly matches the specified text.
+ * * @example
+ * ```gherkin
+ * Then I expect "h1" to have text "Welcome Home"
+ * ```
+ * * @param selector - The CSS or Playwright selector for the element.
+ * @param text - The exact text string expected.
+ */
+export declare const ExpectElementToHaveText: void;
+/**
+ * Asserts that an element contains the specified substring.
+ * Useful for long paragraphs or dynamic content.
+ * * @example
+ * ```gherkin
+ * Then I expect ".error-msg" to contain text "invalid credentials"
+ * ```
+ * * @param selector - The CSS or Playwright selector for the element.
+ * @param text - The partial text string expected to be present.
+ */
+export declare const ExpectElementToContainText: void;
+/**
+ * Asserts that a form field (input, textarea, select) has a specific value.
+ * * @example
+ * ```gherkin
+ * Then I expect "#username" to have value "john_doe"
+ * ```
+ * * @param selector - The selector for the input element.
+ * @param value - The expected value of the field.
+ */
+export declare const ExpectElementToHaveValue: void;
+/**
+ * Asserts that a specific attribute of an element matches the expected value.
+ * Common use cases include checking `href` for links or `src` for images.
+ * * @example
+ * ```gherkin
+ * Then I expect "a#terms-link" to have attribute "href" with value "/terms-and-conditions"
+ * ```
+ * * @param selector - The selector for the element.
+ * @param attr - The name of the attribute (e.g., "class", "href", "data-testid").
+ * @param value - The expected value of that attribute.
+ */
+export declare const ExpectElementAttributeValue: void;
 //# sourceMappingURL=text.d.ts.map

package/dist/backend/assertions/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/text.ts"],"names":[],"mappings":""}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/text.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,MAMnC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,MAMtC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,MAMpC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,MAMvC,CAAC"}

package/dist/backend/assertions/text.js

@@ -1,20 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectElementAttributeValue = exports.ExpectElementToHaveValue = exports.ExpectElementToContainText = exports.ExpectElementToHaveText = void 0;
 const test_1 = require("@playwright/test");
 const registry_1 = require("../../core/registry");
-// Exact text match
-(0, registry_1.Step)("I expect {string} to have text {string}", async (page, selector, text) => {
+/**
+ * @module ElementAssertions
+ */
+/**
+ * Asserts that an element exactly matches the specified text.
+ * * @example
+ * ```gherkin
+ * Then I expect "h1" to have text "Welcome Home"
+ * ```
+ * * @param selector - The CSS or Playwright selector for the element.
+ * @param text - The exact text string expected.
+ */
+exports.ExpectElementToHaveText = (0, registry_1.Step)("I expect {string} to have text {string}", async (page, selector, text) => {
     await (0, test_1.expect)(page.locator(selector)).toHaveText(text);
+    console.log(`✅ Element "${selector}" has exact text "${text}"`);
 });
-// Partial text match (contains)
-(0, registry_1.Step)("I expect {string} to contain text {string}", async (page, selector, text) => {
+/**
+ * Asserts that an element contains the specified substring.
+ * Useful for long paragraphs or dynamic content.
+ * * @example
+ * ```gherkin
+ * Then I expect ".error-msg" to contain text "invalid credentials"
+ * ```
+ * * @param selector - The CSS or Playwright selector for the element.
+ * @param text - The partial text string expected to be present.
+ */
+exports.ExpectElementToContainText = (0, registry_1.Step)("I expect {string} to contain text {string}", async (page, selector, text) => {
     await (0, test_1.expect)(page.locator(selector)).toContainText(text);
+    console.log(`✅ Element "${selector}" contains text "${text}"`);
 });
-// Check input value (for form fields)
-(0, registry_1.Step)("I expect {string} to have value {string}", async (page, selector, value) => {
+/**
+ * Asserts that a form field (input, textarea, select) has a specific value.
+ * * @example
+ * ```gherkin
+ * Then I expect "#username" to have value "john_doe"
+ * ```
+ * * @param selector - The selector for the input element.
+ * @param value - The expected value of the field.
+ */
+exports.ExpectElementToHaveValue = (0, registry_1.Step)("I expect {string} to have value {string}", async (page, selector, value) => {
     await (0, test_1.expect)(page.locator(selector)).toHaveValue(value);
+    console.log(`✅ Input "${selector}" has value "${value}"`);
 });
-// Check an attribute (e.g., class, href, src)
-(0, registry_1.Step)("I expect {string} to have attribute {string} with value {string}", async (page, selector, attr, value) => {
+/**
+ * Asserts that a specific attribute of an element matches the expected value.
+ * Common use cases include checking `href` for links or `src` for images.
+ * * @example
+ * ```gherkin
+ * Then I expect "a#terms-link" to have attribute "href" with value "/terms-and-conditions"
+ * ```
+ * * @param selector - The selector for the element.
+ * @param attr - The name of the attribute (e.g., "class", "href", "data-testid").
+ * @param value - The expected value of that attribute.
+ */
+exports.ExpectElementAttributeValue = (0, registry_1.Step)("I expect {string} to have attribute {string} with value {string}", async (page, selector, attr, value) => {
     await (0, test_1.expect)(page.locator(selector)).toHaveAttribute(attr, value);
+    console.log(`✅ Element "${selector}" attribute "${attr}" is "${value}"`);
 });

package/dist/backend/assertions/visibility.d.ts

@@ -1,2 +1,103 @@
-export {};
+/**
+ * @module ActiveElementAssertions
+ */
+/**
+ * Asserts that the currently stored (active) element is visible in the viewport.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be visible
+ * ```
+ */
+export declare const ExpectActiveVisible: void;
+/**
+ * Asserts that an element with a given selector or description is visible in the viewport.
+ * * @example
+ * ```gherkin
+ * Then I expect "Submit Button" to be visible
+ * Then I expect ".login-form" to be visible
+ * ```
+ */
+export declare const ExpectStringVisible: void;
+/**
+ * Asserts that the currently stored (active) element is hidden or detached from the DOM.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be hidden
+ * ```
+ */
+export declare const ExpectActiveHidden: void;
+/**
+ * Asserts that the currently stored (active) element is enabled (not disabled).
+ * * @example
+ * ```gherkin
+ * Then I expect element to be enabled
+ * ```
+ */
+export declare const ExpectActiveEnabled: void;
+/**
+ * Asserts that the currently stored (active) element is disabled.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be disabled
+ * ```
+ */
+export declare const ExpectActiveDisabled: void;
+/**
+ * Asserts that the currently stored (active) element has the exact text specified.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have text "Submit Order"
+ * ```
+ */
+export declare const ExpectActiveText: void;
+/**
+ * Asserts that the currently stored (active) element contains the specified partial text.
+ * * @example
+ * ```gherkin
+ * Then I expect element to contain text "Order #"
+ * ```
+ */
+export declare const ExpectActiveContainText: void;
+/**
+ * Asserts that the currently stored (active) element (input/select) has a specific value.
+ * Supports aliases (e.g., `@orderId`) to compare against stored variables.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have value "12345"
+ * Then I expect element to have value "@savedUserEmail"
+ * ```
+ */
+export declare const ExpectActiveValue: void;
+/**
+ * Asserts that the currently stored (active) element possesses a specific attribute.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have attribute "required"
+ * ```
+ */
+export declare const ExpectActiveAttribute: void;
+/**
+ * Asserts that the currently stored (active) element has an attribute with a specific value.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have attribute "type" with value "password"
+ * ```
+ */
+export declare const ExpectActiveAttributeValue: void;
+/**
+ * Performs a visual comparison of the entire page against a baseline screenshot.
+ * * @example
+ * ```gherkin
+ * Then I expect the page screenshot to match "landing-page.png"
+ * ```
+ */
+export declare const ExpectPageScreenshotMatch: void;
+/**
+ * Performs a visual comparison of the active element against a baseline screenshot.
+ * * @example
+ * ```gherkin
+ * Then I expect the element screenshot to match "login-button.png"
+ * ```
+ */
+export declare const ExpectElementScreenshotMatch: void;
 //# sourceMappingURL=visibility.d.ts.map

package/dist/backend/assertions/visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/visibility.ts"],"names":[],"mappings":""}
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/backend/assertions/visibility.ts"],"names":[],"mappings":"AAIA;;GAEG;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,MAI9B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,MAI9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,MAI7B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,MAI9B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,MAI/B,CAAC;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,MAO5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,MAOnC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,MAa7B,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAOjC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,MAOtC,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,MAMrC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,MAOxC,CAAC"}

package/dist/backend/assertions/visibility.js

@@ -1,43 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectElementScreenshotMatch = exports.ExpectPageScreenshotMatch = exports.ExpectActiveAttributeValue = exports.ExpectActiveAttribute = exports.ExpectActiveValue = exports.ExpectActiveContainText = exports.ExpectActiveText = exports.ExpectActiveDisabled = exports.ExpectActiveEnabled = exports.ExpectActiveHidden = exports.ExpectStringVisible = exports.ExpectActiveVisible = void 0;
 const test_1 = require("@playwright/test");
 const registry_1 = require("../../core/registry");
 const state_1 = require("../utils/state");
+/**
+ * @module ActiveElementAssertions
+ */
 // ===============================
 // 1. VISIBILITY & STATE CHECKS
 // ===============================
 /**
- * Checks if the stored element is visible.
- * Pattern: Then I expect element to be visible
+ * Asserts that the currently stored (active) element is visible in the viewport.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be visible
+ * ```
  */
-(0, registry_1.Step)("I expect element to be visible", async (page) => {
+exports.ExpectActiveVisible = (0, registry_1.Step)("I expect element to be visible", async (page) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toBeVisible();
     console.log("✅ Element is visible");
 });
 /**
- * Checks if the stored element is hidden.
- * Pattern: Then I expect element to be hidden
+ * Asserts that an element with a given selector or description is visible in the viewport.
+ * * @example
+ * ```gherkin
+ * Then I expect "Submit Button" to be visible
+ * Then I expect ".login-form" to be visible
+ * ```
+ */
+exports.ExpectStringVisible = (0, registry_1.Step)("I expect {string} to be visible", async (page, selector) => {
+    const element = page.locator(selector);
+    await (0, test_1.expect)(element).toBeVisible();
+    console.log(`✅ "${selector}" is visible`);
+});
+/**
+ * Asserts that the currently stored (active) element is hidden or detached from the DOM.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be hidden
+ * ```
  */
-(0, registry_1.Step)("I expect element to be hidden", async (page) => {
+exports.ExpectActiveHidden = (0, registry_1.Step)("I expect element to be hidden", async (page) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toBeHidden();
     console.log("✅ Element is hidden");
 });
 /**
- * Checks if the stored element is enabled.
- * Pattern: Then I expect element to be enabled
+ * Asserts that the currently stored (active) element is enabled (not disabled).
+ * * @example
+ * ```gherkin
+ * Then I expect element to be enabled
+ * ```
  */
-(0, registry_1.Step)("I expect element to be enabled", async (page) => {
+exports.ExpectActiveEnabled = (0, registry_1.Step)("I expect element to be enabled", async (page) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toBeEnabled();
     console.log("✅ Element is enabled");
 });
 /**
- * Checks if the stored element is disabled.
- * Pattern: Then I expect element to be disabled
+ * Asserts that the currently stored (active) element is disabled.
+ * * @example
+ * ```gherkin
+ * Then I expect element to be disabled
+ * ```
  */
-(0, registry_1.Step)("I expect element to be disabled", async (page) => {
+exports.ExpectActiveDisabled = (0, registry_1.Step)("I expect element to be disabled", async (page) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toBeDisabled();
     console.log("✅ Element is disabled");
@@ -46,29 +75,39 @@ const state_1 = require("../utils/state");
 // 2. TEXT & VALUE CHECKS
 // ===============================
 /**
- * Checks if the element contains exact text.
- * Pattern: Then I expect element to have text "Submit"
+ * Asserts that the currently stored (active) element has the exact text specified.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have text "Submit Order"
+ * ```
  */
-(0, registry_1.Step)("I expect element to have text {string}", async (page, text) => {
+exports.ExpectActiveText = (0, registry_1.Step)("I expect element to have text {string}", async (page, text) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toHaveText(text);
     console.log(`✅ Element has text "${text}"`);
 });
 /**
- * Checks if the element contains partial text.
- * Pattern: Then I expect element to contain text "Sub"
+ * Asserts that the currently stored (active) element contains the specified partial text.
+ * * @example
+ * ```gherkin
+ * Then I expect element to contain text "Order #"
+ * ```
  */
-(0, registry_1.Step)("I expect element to contain text {string}", async (page, text) => {
+exports.ExpectActiveContainText = (0, registry_1.Step)("I expect element to contain text {string}", async (page, text) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toContainText(text);
     console.log(`✅ Element contains text "${text}"`);
 });
 /**
- * Checks if the element has a specific input value.
- * Pattern: Then I expect element to have value "123"
+ * Asserts that the currently stored (active) element (input/select) has a specific value.
+ * Supports aliases (e.g., `@orderId`) to compare against stored variables.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have value "12345"
+ * Then I expect element to have value "@savedUserEmail"
+ * ```
  */
-(0, registry_1.Step)("I expect element to have value {string}", async (page, value) => {
-    // Support aliases (e.g. @myVar)
+exports.ExpectActiveValue = (0, registry_1.Step)("I expect element to have value {string}", async (page, value) => {
     if (value.startsWith("@")) {
         const alias = value.slice(1);
         const stored = (0, state_1.getVariable)(page, alias);
@@ -84,40 +123,51 @@ const state_1 = require("../utils/state");
 // 3. ATTRIBUTE CHECKS
 // ===============================
 /**
- * Checks if the element has a specific attribute.
- * Pattern: Then I expect element to have attribute "data-test"
+ * Asserts that the currently stored (active) element possesses a specific attribute.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have attribute "required"
+ * ```
  */
-(0, registry_1.Step)("I expect element to have attribute {string}", async (page, attr) => {
+exports.ExpectActiveAttribute = (0, registry_1.Step)("I expect element to have attribute {string}", async (page, attr) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toHaveAttribute(attr);
     console.log(`✅ Element has attribute "${attr}"`);
 });
 /**
- * Checks if the element has a specific attribute value.
- * Pattern: Then I expect element to have attribute "type" with value "submit"
+ * Asserts that the currently stored (active) element has an attribute with a specific value.
+ * * @example
+ * ```gherkin
+ * Then I expect element to have attribute "type" with value "password"
+ * ```
  */
-(0, registry_1.Step)("I expect element to have attribute {string} with value {string}", async (page, attr, value) => {
+exports.ExpectActiveAttributeValue = (0, registry_1.Step)("I expect element to have attribute {string} with value {string}", async (page, attr, value) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toHaveAttribute(attr, value);
     console.log(`✅ Element has attribute "${attr}" = "${value}"`);
 });
 // ===============================
-// 4. VISUAL REGRESSION (Screenshots)
+// 4. VISUAL REGRESSION
 // ===============================
 /**
- * Verifies the ENTIRE page matches a stored screenshot.
- * Pattern: Then I expect the page screenshot to match "home-page.png"
- * Note: Screenshots are stored in 'tests/{feature-name}/' folder by default.
+ * Performs a visual comparison of the entire page against a baseline screenshot.
+ * * @example
+ * ```gherkin
+ * Then I expect the page screenshot to match "landing-page.png"
+ * ```
  */
-(0, registry_1.Step)("I expect the page screenshot to match {string}", async (page, filename) => {
+exports.ExpectPageScreenshotMatch = (0, registry_1.Step)("I expect the page screenshot to match {string}", async (page, filename) => {
     await (0, test_1.expect)(page).toHaveScreenshot(filename);
     console.log(`📸 Page matches screenshot: ${filename}`);
 });
 /**
- * Verifies the CURRENT ELEMENT matches a stored screenshot.
- * Pattern: Then I expect the element screenshot to match "submit-btn.png"
+ * Performs a visual comparison of the active element against a baseline screenshot.
+ * * @example
+ * ```gherkin
+ * Then I expect the element screenshot to match "login-button.png"
+ * ```
  */
-(0, registry_1.Step)("I expect the element screenshot to match {string}", async (page, filename) => {
+exports.ExpectElementScreenshotMatch = (0, registry_1.Step)("I expect the element screenshot to match {string}", async (page, filename) => {
     const element = (0, state_1.getActiveElement)(page);
     await (0, test_1.expect)(element).toHaveScreenshot(filename);
     console.log(`📸 Element matches screenshot: ${filename}`);