playwright-cucumber-ts-steps 1.1.7 → 1.1.8

package/dist/backend/actions/click.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=click.d.ts.map

package/dist/backend/actions/click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/click.ts"],"names":[],"mappings":""}

package/dist/backend/actions/click.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+/**
+ * Clicks on the previously stored element.
+ * Pattern: When I click
+ */
+(0, registry_1.Step)("I click", async (page, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = (0, state_1.getActiveElement)(page);
+    await element.click(options);
+    console.log("🖱️ Clicked on stored element");
+});
+/**
+ * Clicks on an element matching the given selector.
+ * Pattern: When I click on element {string}
+ */
+(0, registry_1.Step)("I click on element {string}", async (page, selector, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = page.locator(selector);
+    await element.click(options);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🖱️ Clicked on element "${selector}"`);
+});
+/**
+ * Clicks on a button with the given label.
+ * Pattern: When I click on button {string}
+ */
+(0, registry_1.Step)("I click on button {string}", async (page, label, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const button = page.getByRole("button", { name: label });
+    await button.click(options);
+    (0, state_1.setActiveElement)(page, button);
+    console.log(`🖱️ Clicked on button "${label}"`);
+});
+/**
+ * Clicks on a link with the given text.
+ * Pattern: When I click on link {string}
+ */
+(0, registry_1.Step)("I click on link {string}", async (page, text, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const link = page.getByRole("link", { name: text });
+    await link.click(options);
+    (0, state_1.setActiveElement)(page, link);
+    console.log(`✅ Clicked on link "${text}"`);
+});
+/**
+ * Clicks on a label with the given text.
+ * Pattern: When I click on label {string}
+ */
+(0, registry_1.Step)("I click on label {string}", async (page, labelText, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const label = page.getByLabel(labelText);
+    await label.click(options);
+    (0, state_1.setActiveElement)(page, label);
+    console.log(`🏷️ Clicked on label "${labelText}"`);
+});
+/**
+ * Clicks on an element containing the given text (fuzzy match).
+ * Supports aliasing with @alias.
+ * Pattern: When I click on text {string}
+ */
+(0, registry_1.Step)("I click on text {string}", async (page, rawText, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    let text = rawText;
+    // Handle Alias (e.g., "@username")
+    if (rawText.startsWith("@")) {
+        const aliasKey = rawText.slice(1);
+        const storedValue = (0, state_1.getVariable)(page, aliasKey);
+        if (!storedValue) {
+            throw new Error(`❌ No value found for alias "@${aliasKey}"`);
+        }
+        text = storedValue;
+    }
+    const locator = page.getByText(text, { exact: false }).first();
+    await locator.waitFor({ state: "visible", timeout: 5000 });
+    await locator.click(options);
+    (0, state_1.setActiveElement)(page, locator);
+    console.log(`🖱️ Clicked on text "${text}"`);
+});
+/**
+ * Clicks on an element containing the exact given text.
+ * Pattern: When I click on exact text {string}
+ */
+(0, registry_1.Step)("I click on exact text {string}", async (page, exactText, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const locator = page.getByText(exactText, { exact: true });
+    await locator.waitFor({ state: "visible", timeout: 5000 });
+    await locator.click(options);
+    (0, state_1.setActiveElement)(page, locator);
+    console.log(`🖱️ Clicked on exact text "${exactText}"`);
+});
+/**
+ * Clicks all previously stored elements.
+ * Pattern: When I click all
+ */
+(0, registry_1.Step)("I click all", async (page, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const elements = (0, state_1.getActiveElements)(page);
+    const count = await elements.count();
+    if (count === 0)
+        throw new Error("⚠️ No elements found to click.");
+    for (let i = 0; i < count; i++) {
+        const el = elements.nth(i);
+        await el.waitFor({ state: "visible", timeout: 5000 });
+        await el.click(options);
+        console.log(`🖱️ Clicked element #${i + 1}`);
+    }
+    console.log(`✅ Clicked all ${count} elements.`);
+});
+/**
+ * Double-clicks on the previously stored element.
+ * Pattern: When I double click
+ */
+(0, registry_1.Step)("I double click", async (page, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = (0, state_1.getActiveElement)(page);
+    await element.dblclick(options);
+    console.log("🖱️ Double-clicked on stored element");
+});
+/**
+ * Double-clicks on an element containing the given text.
+ * Pattern: When I double click on text {string}
+ */
+(0, registry_1.Step)("I double click on text {string}", async (page, text, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = page.getByText(text).first();
+    await element.dblclick(options);
+    console.log(`🖱️ Double-clicked on text "${text}"`);
+});
+/**
+ * Double-clicks at the given page coordinates.
+ * Pattern: When I double click position {int} {int}
+ */
+(0, registry_1.Step)("I double click position {int} {int}", async (page, x, y, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    await page.mouse.dblclick(x, y, options);
+    console.log(`🖱️ Double-clicked at (${x}, ${y})`);
+});
+/**
+ * Right-clicks on the previously stored element.
+ * Pattern: When I right click
+ */
+(0, registry_1.Step)("I right click", async (page, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = (0, state_1.getActiveElement)(page);
+    await element.click({ button: "right", ...options });
+    console.log("🖱️ Right-clicked on stored element");
+});
+/**
+ * Right-clicks on an element containing the given text.
+ * Pattern: When I right click on text {string}
+ */
+(0, registry_1.Step)("I right click on text {string}", async (page, text, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    const element = page.getByText(text).first();
+    await element.click({ button: "right", ...options });
+    console.log(`🖱️ Right-clicked on text "${text}"`);
+});
+/**
+ * Right-clicks at the given page coordinates.
+ * Pattern: When I right click position {int} {int}
+ */
+(0, registry_1.Step)("I right click position {int} {int}", async (page, x, y, table) => {
+    const options = (0, state_1.parseClickOptions)(table);
+    await page.mouse.click(x, y, { button: "right", ...options });
+    console.log(`🖱️ Right-clicked at (${x}, ${y})`);
+});
+/**
+ * Clicks on an element matching the given selector (Regex Version).
+ * Pattern: I click on selector "..."
+ */
+(0, registry_1.Step)(/^I click on selector "([^"]+)"$/, async (page, selector) => {
+    const locator = page.locator(selector);
+    await locator.click();
+    (0, state_1.setActiveElement)(page, locator);
+    console.log(`🖱️ Clicked on selector: ${selector}`);
+});

package/dist/backend/actions/find.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=find.d.ts.map

package/dist/backend/actions/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/find.ts"],"names":[],"mappings":""}

package/dist/backend/actions/find.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+// =============================
+// 1. GENERAL FINDING (Single)
+// =============================
+/**
+ * Finds an element by CSS selector.
+ * Pattern: When I find element by selector ".my-class"
+ */
+(0, registry_1.Step)("I find element by selector {string}", async (page, selector) => {
+    const element = page.locator(selector);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by selector: "${selector}"`);
+});
+/**
+ * Finds an element by exact text.
+ * Pattern: When I find element by text "Submit"
+ */
+(0, registry_1.Step)("I find element by text {string}", async (page, text) => {
+    const element = page.getByText(text, { exact: true });
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by exact text: "${text}"`);
+});
+/**
+ * Finds an element by title attribute.
+ * Pattern: When I find element by title "Tooltip"
+ */
+(0, registry_1.Step)("I find element by title {string}", async (page, title) => {
+    const element = page.getByTitle(title);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by title: "${title}"`);
+});
+/**
+ * Finds an element by test id (data-testid).
+ * Pattern: When I find element by testid "submit-btn"
+ */
+(0, registry_1.Step)("I find element by testid {string}", async (page, testid) => {
+    const element = page.getByTestId(testid);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by testid: "${testid}"`);
+});
+/**
+ * Finds an element by ARIA role.
+ * Pattern: When I find element by role "button"
+ */
+(0, registry_1.Step)("I find element by role {string}", async (page, role) => {
+    const element = page.getByRole(role);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by role: "${role}"`);
+});
+/**
+ * Finds an element by placeholder.
+ * Pattern: When I find element by placeholder text "Search..."
+ */
+(0, registry_1.Step)("I find element by placeholder text {string}", async (page, text) => {
+    const element = page.getByPlaceholder(text);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by placeholder: "${text}"`);
+});
+/**
+ * Finds an element by label.
+ * Pattern: When I find element by label text "Username"
+ */
+(0, registry_1.Step)("I find element by label text {string}", async (page, label) => {
+    const element = page.getByLabel(label);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by label: "${label}"`);
+});
+/**
+ * Finds an element by alt text (images).
+ * Pattern: When I find element by alt text "Logo"
+ */
+(0, registry_1.Step)("I find element by alt text {string}", async (page, alt) => {
+    const element = page.getByAltText(alt);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by alt text: "${alt}"`);
+});
+// =============================
+// 2. SPECIFIC ELEMENTS (Link/Heading/Name)
+// =============================
+/**
+ * Finds a link by text.
+ * Pattern: When I find link by text "Home"
+ */
+(0, registry_1.Step)("I find link by text {string}", async (page, text) => {
+    const element = page.getByRole("link", { name: text });
+    // We use .first() here because links often have duplicates (e.g. footer/header)
+    // but strict mode usually prefers uniqueness.
+    (0, state_1.setActiveElement)(page, element.first());
+    console.log(`🔍 Found link by text: "${text}"`);
+});
+/**
+ * Finds a heading by text.
+ * Pattern: When I find heading by text "Welcome"
+ */
+(0, registry_1.Step)("I find heading by text {string}", async (page, text) => {
+    const element = page.getByRole("heading", { name: text });
+    (0, state_1.setActiveElement)(page, element.first());
+    console.log(`🔍 Found heading by text: "${text}"`);
+});
+/**
+ * Finds an element by name attribute.
+ * Pattern: When I find element by name "email"
+ */
+(0, registry_1.Step)("I find element by name {string}", async (page, name) => {
+    // Broad selector for name attribute
+    const element = page.locator(`[name="${name}"]`);
+    await (0, test_1.expect)(element).toHaveCount(1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found element by name: "${name}"`);
+});
+// =============================
+// 3. GENERAL FINDING (Multiple)
+// =============================
+/**
+ * Finds all elements by selector.
+ * Pattern: When I find elements by selector ".items"
+ */
+(0, registry_1.Step)("I find elements by selector {string}", async (page, selector) => {
+    const elements = page.locator(selector);
+    const count = await elements.count();
+    (0, state_1.setActiveElements)(page, elements);
+    console.log(`🔍 Found ${count} elements with selector: "${selector}"`);
+});
+/**
+ * Finds all headings by text.
+ * Pattern: When I find headings by text "Chapter"
+ */
+(0, registry_1.Step)("I find headings by text {string}", async (page, text) => {
+    const elements = page.getByRole("heading", { name: text });
+    (0, state_1.setActiveElements)(page, elements);
+    console.log(`🔍 Found headings matching "${text}"`);
+});
+/**
+ * Finds all buttons by text (supports alias).
+ * Pattern: When I find buttons by text "Save"
+ */
+(0, registry_1.Step)("I find buttons by text {string}", async (page, text) => {
+    let searchText = text;
+    // Handle Alias
+    if (text.startsWith("@")) {
+        const alias = text.slice(1);
+        const val = (0, state_1.getVariable)(page, alias);
+        if (!val)
+            throw new Error(`❌ No value found for alias "@${alias}"`);
+        searchText = val;
+    }
+    const elements = page.getByRole("button", { name: searchText });
+    (0, state_1.setActiveElements)(page, elements);
+    console.log(`🔍 Found buttons matching "${searchText}"`);
+});
+// =============================
+// 4. GET / REFINE SELECTION
+// =============================
+/**
+ * Gets the first element from a stored list.
+ * Pattern: When I get first element
+ */
+(0, registry_1.Step)("I get first element", async (page) => {
+    const elements = (0, state_1.getActiveElements)(page);
+    const element = elements.first();
+    (0, state_1.setActiveElement)(page, element);
+    console.log("👉 Selected FIRST element");
+});
+/**
+ * Gets the last element from a stored list.
+ * Pattern: When I get last element
+ */
+(0, registry_1.Step)("I get last element", async (page) => {
+    const elements = (0, state_1.getActiveElements)(page);
+    const element = elements.last();
+    (0, state_1.setActiveElement)(page, element);
+    console.log("👉 Selected LAST element");
+});
+/**
+ * Gets the nth element (1-based index).
+ * Pattern: When I get 2nd element
+ */
+(0, registry_1.Step)(/^I get (\d+)(?:st|nd|rd|th) element$/, async (page, indexStr) => {
+    const index = parseInt(indexStr, 10);
+    const elements = (0, state_1.getActiveElements)(page);
+    const count = await elements.count();
+    if (index < 1 || index > count) {
+        throw new Error(`❌ Cannot get element #${index} — only ${count} found.`);
+    }
+    // Playwright is 0-based, Gherkin is 1-based
+    const element = elements.nth(index - 1);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`👉 Selected element #${index}`);
+});
+/**
+ * Gets the currently focused element.
+ * Pattern: When I get focused element
+ */
+(0, registry_1.Step)("I get focused element", async (page) => {
+    // Use CSS selector for focused element
+    const element = page.locator("*:focus");
+    (0, state_1.setActiveElement)(page, element);
+    console.log("👉 Selected FOCUSED element");
+});
+// =============================
+// 5. INPUTS & TEXTAREAS SPECIFICS
+// =============================
+/**
+ * Finds input by ID.
+ * Pattern: When I find input by ID "username"
+ */
+(0, registry_1.Step)("I find input by ID {string}", async (page, id) => {
+    const element = page.locator(`input#${id}`);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found input by ID: "${id}"`);
+});
+/**
+ * Finds input by name.
+ * Pattern: When I find input by name "email"
+ */
+(0, registry_1.Step)("I find input by name {string}", async (page, name) => {
+    const element = page.locator(`input[name="${name}"]`);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found input by name: "${name}"`);
+});
+/**
+ * Finds input by placeholder.
+ * Pattern: When I find input by placeholder text "Enter email"
+ */
+(0, registry_1.Step)("I find input by placeholder text {string}", async (page, placeholder) => {
+    const element = page.locator(`input[placeholder="${placeholder}"]`);
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found input by placeholder: "${placeholder}"`);
+});
+/**
+ * Finds input by display value (supports alias).
+ * Pattern: When I find input by display value "John Doe"
+ */
+(0, registry_1.Step)("I find input by display value {string}", async (page, value) => {
+    let searchValue = value;
+    if (value.startsWith("@")) {
+        const alias = value.slice(1);
+        const val = (0, state_1.getVariable)(page, alias);
+        if (!val)
+            throw new Error(`❌ No value found for alias "@${alias}"`);
+        searchValue = val;
+    }
+    const element = page.locator(`input[value="${searchValue}"]`);
+    await (0, test_1.expect)(element).toBeVisible();
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🔍 Found input with value: "${searchValue}"`);
+});
+/**
+ * Finds textarea by label.
+ * Pattern: When I find textarea by label text "Comments"
+ */
+(0, registry_1.Step)("I find textarea by label text {string}", async (page, label) => {
+    const element = page.getByLabel(label).locator("textarea").first();
+    // Fallback if strict label matching fails, try locator strategy
+    const count = await element.count();
+    if (count === 0) {
+        // Try generic label finding
+        const altElement = page.getByLabel(label);
+        (0, state_1.setActiveElement)(page, altElement);
+    }
+    else {
+        (0, state_1.setActiveElement)(page, element);
+    }
+    console.log(`🔍 Found textarea by label: "${label}"`);
+});
+// =============================
+// 6. UTILITIES (Store Text)
+// =============================
+/**
+ * Stores the text of the current element into a variable.
+ * Pattern: When I store element text as "myVar"
+ */
+(0, registry_1.Step)("I store element text as {string}", async (page, alias) => {
+    const element = (0, state_1.getActiveElement)(page);
+    const text = await element.textContent();
+    const cleanText = text?.trim() || "";
+    (0, state_1.setVariable)(page, alias, cleanText);
+    console.log(`💾 Stored text "${cleanText}" as variable "@${alias}"`);
+});

package/dist/backend/actions/form.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=form.d.ts.map

package/dist/backend/actions/form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/form.ts"],"names":[],"mappings":""}

package/dist/backend/actions/form.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const test_1 = require("@playwright/test");
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+/**
+ * Helper to convert raw runner table into Objects (ActionRow[])
+ * Handles whitespace in headers (e.g., "| Target |" -> "Target")
+ */
+function parseDataTable(table) {
+    // Debug Log: See exactly what the runner is passing
+    // console.log("DEBUG: Raw Table Input:", JSON.stringify(table, null, 2));
+    // 1. If it's a Cucumber object (Legacy)
+    if (table && typeof table.hashes === "function") {
+        return table.hashes();
+    }
+    // 2. If it's a raw Array of Arrays (Custom Runner)
+    if (Array.isArray(table) && Array.isArray(table[0])) {
+        // Trim headers to ensure " Target " becomes "Target"
+        const headers = table[0].map((h) => h.trim());
+        const rows = table.slice(1);
+        return rows.map((row) => {
+            const obj = {};
+            headers.forEach((header, index) => {
+                // Map header to row value (and trim the value too for safety)
+                obj[header] = row[index] ? row[index].trim() : "";
+            });
+            return obj;
+        });
+    }
+    return [];
+}
+function resolveValue(page, rawValue) {
+    if (!rawValue)
+        return "";
+    const trimmed = rawValue.trim();
+    // Handle Alias (e.g. @adminPassword)
+    if (trimmed.startsWith("@")) {
+        const alias = trimmed.slice(1);
+        const stored = (0, state_1.getVariable)(page, alias);
+        if (stored === undefined) {
+            console.warn(`⚠️ Warning: Alias @${alias} not found. Using literal value.`);
+            return trimmed;
+        }
+        return typeof stored === "object" ? JSON.stringify(stored) : String(stored);
+    }
+    return trimmed;
+}
+(0, registry_1.Step)("I fill the following {string} form data", async (page, formName, table) => {
+    console.log(`📝 Processing Form: "${formName}"`);
+    // Parse the table
+    const rows = parseDataTable(table);
+    if (rows.length === 0) {
+        console.warn("⚠️ Form data table appears empty or invalid.");
+        return;
+    }
+    for (const row of rows) {
+        // Guard clause: If Target is missing/undefined, skip or throw useful error
+        if (!row.Target) {
+            console.error("❌ Invalid Row Detected (Missing Target):", JSON.stringify(row));
+            continue;
+        }
+        const target = row.Target; // Already trimmed in parser
+        const rawValue = row.Value || "";
+        const resolvedValue = resolveValue(page, rawValue);
+        // ============================================
+        // 1. SPECIAL ACTIONS
+        // ============================================
+        if (target.startsWith("request:")) {
+            const parts = target.replace("request:", "").split(":");
+            const method = parts[0].toUpperCase();
+            const url = parts.slice(1).join(":");
+            const payloadFile = rawValue;
+            const payloadDir = row.PayloadDir || "payload";
+            const filePath = path.resolve(process.cwd(), payloadDir, payloadFile);
+            if (!fs.existsSync(filePath)) {
+                throw new Error(`❌ Payload file not found: ${filePath}`);
+            }
+            const payload = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            console.log(`📞 API ${method} -> ${url}`);
+            const response = await page.request.fetch(url, {
+                method: method,
+                data: payload,
+            });
+            const responseBody = await response.json();
+            (0, state_1.setVariable)(page, "lastApiResponse", responseBody);
+            (0, state_1.setVariable)(page, "lastStatusCode", response.status());
+            console.log(`✅ Status: ${response.status()}`);
+            if (row.SaveAs) {
+                (0, state_1.setVariable)(page, row.SaveAs, responseBody);
+            }
+            continue;
+        }
+        if (target.startsWith("set:localStorage:")) {
+            const key = target.split(":")[2];
+            await page.evaluate(({ k, v }) => localStorage.setItem(k, v), {
+                k: key,
+                v: resolvedValue,
+            });
+            console.log(`📦 localStorage: Set "${key}"`);
+            continue;
+        }
+        if (target === "wait") {
+            const time = parseInt(rawValue.replace("wait:", ""), 10);
+            if (!isNaN(time)) {
+                console.log(`⏳ Waiting ${time}ms`);
+                await page.waitForTimeout(time);
+            }
+            continue;
+        }
+        // ============================================
+        // 2. UI ELEMENT ACTIONS
+        // ============================================
+        const locator = page.locator(target);
+        // ✅ Assertions
+        if (rawValue.startsWith("assert:")) {
+            const parts = rawValue.split(":");
+            const type = parts[1];
+            const expected = parts.slice(2).join(":");
+            if (type === "visible") {
+                await (0, test_1.expect)(locator).toBeVisible();
+                console.log(`🔎 Asserted visible: ${target}`);
+            }
+            else if (type === "text") {
+                await (0, test_1.expect)(locator).toHaveText(expected || "");
+                console.log(`🔎 Asserted text: ${target}`);
+            }
+            continue;
+        }
+        // ✅ Interactions
+        if (rawValue === "click") {
+            await locator.click();
+            console.log(`👆 Clicked: ${target}`);
+            continue;
+        }
+        if (rawValue === "check") {
+            await locator.check();
+            console.log(`☑️ Checked: ${target}`);
+            continue;
+        }
+        if (rawValue === "select") {
+            await locator.selectOption({ index: 0 });
+            console.log(`🔽 Selected index 0: ${target}`);
+            continue;
+        }
+        // ✅ Default: Fill
+        await locator.fill(resolvedValue);
+        console.log(`✍️ Filled ${target} with "${resolvedValue}"`);
+    }
+});

package/dist/backend/actions/formTable.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const registry_1 = require("../../core/registry");
 const test_1 = require("@playwright/test");
 // CHANGE: Removed the ':' at the end of the string below
-(0, registry_1.Step)("I fill the following {string} form data", async (page, formName, tableData) => {
+(0, registry_1.Step)("I fill the following {string} test form data", async (page, formName, tableData) => {
     console.log(`📝 Processing Form: ${formName}`);
     // The runner passes the table data as the last argument
     // tableData = [ ['#username', 'tomsmith'], ['#password', '...'] ]