playwright-cucumber-ts-steps 0.0.3 → 0.0.5

package/dist/actions/Interception & Requests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/Interception & Requests.js

@@ -0,0 +1,39 @@
+import { When, Then } from "@cucumber/cucumber";
+When("I intercept URL {string}", async function (url) {
+    await this.page.route(url, async (route) => {
+        await route.continue();
+    });
+});
+When("I intercept URL {string} and stub body {string}", async function (url, body) {
+    await this.page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "application/json",
+            body,
+        });
+    });
+});
+When("I make a request to {string}", async function (url) {
+    const response = await this.page.request.get(url);
+    this.data.lastResponse = response;
+});
+Then("I see response status {int}", async function (status) {
+    const res = this.data.lastResponse;
+    if (!res)
+        throw new Error("No response available");
+    const actual = res.status();
+    if (actual !== status)
+        throw new Error(`Expected status ${status}, got ${actual}`);
+});
+Then("I see response body {string}", async function (expected) {
+    const res = this.data.lastResponse;
+    const body = await res.text();
+    if (body !== expected)
+        throw new Error(`Expected body "${expected}", got "${body}"`);
+});
+Then("I see response body contains {string}", async function (part) {
+    const res = this.data.lastResponse;
+    const body = await res.text();
+    if (!body.includes(part))
+        throw new Error(`Body does not contain "${part}"`);
+});

package/dist/actions/clickSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/clickSteps.js

@@ -0,0 +1,173 @@
+// e2e/step_definitions/common/actions/clickSteps.ts
+import { When } from "@cucumber/cucumber";
+import { parseClickOptions } from "../helpers/utils/optionsUtils";
+When("I click", async function (...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    if (!this.element)
+        throw new Error("❌ No stored element to click.");
+    await this.element.click(options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🖱️ Clicked on stored element");
+});
+When("I click on button {string}", async function (label, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const button = await this.page.getByRole("button", { name: label });
+    await button.click(options);
+    this.element = button;
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked on button "${label}"`);
+});
+When("I click on link {string}", async function (text, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const link = await this.page.getByRole("link", { name: text });
+    await link.click(options);
+    this.element = link;
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `✅ Clicked on link "${text}"`);
+});
+When("I click on label {string}", async function (labelText, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const label = await this.page.getByLabel(labelText);
+    await label.click(options);
+    this.element = label;
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🏷️ Clicked on label "${labelText}"`);
+});
+When("I click on text {string}", async function (rawText, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    let text = rawText;
+    if (rawText.startsWith("@")) {
+        const alias = rawText.slice(1);
+        text = this.data[alias];
+        if (!text)
+            throw new Error(`❌ No value found for alias "@${alias}"`);
+    }
+    const locator = this.page.getByText(text, { exact: false });
+    await locator.first().waitFor({ state: "visible", timeout: 5000 });
+    await locator.first().click(options);
+    this.element = locator.first();
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked on text "${text}"`);
+});
+When("I click on exact text {string}", async function (exactText, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const locator = this.page.getByText(exactText, { exact: true });
+    await locator.waitFor({ state: "visible", timeout: 5000 });
+    await locator.click(options);
+    this.element = locator;
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked on exact text "${exactText}"`);
+});
+When("I click all", async function (...rest) {
+    var _a, _b;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    if (!this.elements)
+        throw new Error("❌ No stored elements to click.");
+    const count = await this.elements.count();
+    if (count === 0)
+        throw new Error("⚠️ No elements found to click.");
+    for (let i = 0; i < count; i++) {
+        const el = this.elements.nth(i);
+        await el.waitFor({ state: "visible", timeout: 5000 });
+        await el.click(options);
+        (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked element #${i + 1}`);
+    }
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `✅ Clicked all ${count} elements.`);
+});
+When("I double click on text {string}", async function (text, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const element = this.element || this.page.getByText(text);
+    await element.dblclick(options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Double-clicked on text "${text}"`);
+});
+When("I double click position {int} {int}", async function (x, y, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    await this.page.mouse.dblclick(x, y, options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Double-clicked at (${x}, ${y})`);
+});
+When("I double click", async function (...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    if (!this.element)
+        throw new Error("❌ No stored element to double-click.");
+    await this.element.dblclick(options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🖱️ Double-clicked on stored element");
+});
+When("I right click", async function (...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    if (!this.element)
+        throw new Error("❌ No stored element to right-click.");
+    await this.element.click({ button: "right", ...options });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🖱️ Right-clicked on stored element");
+});
+When("I right click on text {string}", async function (text, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    const element = this.page.getByText(text);
+    await element.click({ button: "right", ...options });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Right-clicked on text "${text}"`);
+});
+When("I right click position {int} {int}", async function (x, y, ...rest) {
+    var _a;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseClickOptions(maybeTable) : {};
+    await this.page.mouse.click(x, y, { button: "right", ...options });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Right-clicked at (${x}, ${y})`);
+});
+When("I blur", async function () {
+    var _a;
+    await this.page.evaluate(() => {
+        const active = document.activeElement;
+        if (active && typeof active.blur === "function") {
+            active.blur();
+        }
+    });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🌀 Blurred active element");
+});
+When("I focus", async function () {
+    var _a;
+    if (!this.element)
+        throw new Error("❌ No stored element to focus.");
+    await this.element.focus();
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🎯 Focused stored element");
+});
+When("I click all", async function (dataTable) {
+    var _a, _b;
+    const options = parseClickOptions(dataTable);
+    if (!this.elements) {
+        throw new Error("❌ No elements stored. Use a 'find' step before 'I click all'.");
+    }
+    const count = await this.elements.count();
+    if (count === 0) {
+        throw new Error("⚠️ Stored elements are empty. Nothing to click.");
+    }
+    for (let i = 0; i < count; i++) {
+        const element = this.elements.nth(i);
+        await element.waitFor({ state: "visible", timeout: 5000 });
+        await element.click(options);
+        (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked element #${i + 1}`);
+    }
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `✅ Clicked all ${count} stored elements.`);
+});
+When(/^I click on selector "([^"]+)"$/, async function (selector) {
+    var _a;
+    const scope = this.getScope();
+    const element = scope.locator(selector);
+    await element.click();
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked on selector: ${selector}`);
+});

package/dist/actions/cookieSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/cookieSteps.js

@@ -0,0 +1,26 @@
+// e2e/step_definitions/common/actions/cookieSteps.ts
+import { When } from "@cucumber/cucumber";
+When("I clear all cookies", async function () {
+    await this.page.context().clearCookies();
+    this.log("Cleared all cookies");
+});
+When("I clear cookies", async function () {
+    await this.page.context().clearCookies();
+    this.log("Cleared cookies (alias)");
+});
+When("I clear cookie {string}", async function (name) {
+    await this.page.context().addCookies([
+        {
+            name,
+            value: "",
+            domain: new URL(this.page.url()).hostname,
+            path: "/",
+            expires: 0,
+        },
+    ]);
+    this.log(`Cleared cookie: ${name}`);
+});
+When("I log all cookies", async function () {
+    const cookies = await this.page.context().cookies();
+    console.log("Cookies:", cookies);
+});

package/dist/actions/debugSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/debugSteps.js

@@ -0,0 +1,9 @@
+// e2e/step_definitions/common/actions/debugSteps.ts
+import { When } from "@cucumber/cucumber";
+When("I debug", async function () {
+    await this.page.pause();
+    this.log("Paused test for debugging");
+});
+When("I log {string}", async function (msg) {
+    this.log(msg);
+});

package/dist/actions/elementFindSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/elementFindSteps.js

@@ -0,0 +1,239 @@
+import { When } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+// =============================
+// WHEN I FIND ELEMENT(S)
+// =============================
+When("I find element by selector {string}", async function (selector) {
+    this.element = this.page.locator(selector);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find elements by selector {string}", async function (selector) {
+    var _a;
+    this.elements = this.page.locator(selector);
+    const count = await this.elements.count();
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Found ${count} elements with selector ${selector}`);
+});
+When("I find element by text {string}", async function (text) {
+    this.element = this.page.getByText(text, { exact: true });
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by title {string}", async function (title) {
+    this.element = this.page.getByTitle(title);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by testid {string}", async function (testid) {
+    this.element = this.page.getByTestId(testid);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by role {string}", async function (role) {
+    this.element = this.page.getByRole(role);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by placeholder text {string}", async function (text) {
+    this.element = this.page.getByPlaceholder(text);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by label text {string}", async function (label) {
+    this.element = this.page.getByLabel(label);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by alt text {string}", async function (alt) {
+    this.element = this.page.getByAltText(alt);
+    await expect(this.element).toHaveCount(1);
+});
+When("I find element by name {string}", async function (name) {
+    this.element = this.page.getByRole("textbox", { name });
+    await expect(this.element).toHaveCount(1);
+});
+When("I find buttons by text {string}", async function (buttonText) {
+    var _a, _b;
+    // 🧠 Resolve alias
+    if (buttonText.startsWith("@")) {
+        const alias = buttonText.slice(1);
+        buttonText = (_a = this.data) === null || _a === void 0 ? void 0 : _a[alias];
+        if (!buttonText) {
+            throw new Error(`No value found for alias "@${alias}"`);
+        }
+    }
+    // 🔍 Locate all matching buttons
+    this.elements = this.page.getByRole("button", {
+        name: buttonText,
+        exact: false,
+    });
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `🔘 Stored all buttons matching text "${buttonText}"`);
+});
+// =============================
+// WHEN I GET ELEMENT(S)
+// =============================
+When("I get element by selector {string}", async function (selector) {
+    this.element = this.page.locator(selector).first();
+});
+When("I get elements by selector {string}", async function (selector) {
+    this.elements = this.page.locator(selector);
+});
+When("I get first element", async function () {
+    if (!this.elements)
+        throw new Error("No element collection found");
+    this.element = this.elements.first();
+});
+When("I get last element", async function () {
+    if (!this.elements)
+        throw new Error("No element collection found");
+    this.element = this.elements.last();
+});
+When(/^I get (\d+)(?:st|nd|rd|th) element$/, async function (index) {
+    var _a;
+    if (!this.elements)
+        throw new Error("No elements stored to pick from");
+    const count = await this.elements.count();
+    if (index < 1 || index > count) {
+        throw new Error(`Cannot get element ${index} — only ${count} found`);
+    }
+    this.element = this.elements.nth(index - 1);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Selected ${index} element from stored elements`);
+});
+When("I find elements by role {string}", async function (role) {
+    var _a;
+    const locator = this.page.getByRole(role);
+    const count = await locator.count();
+    if (count === 0) {
+        throw new Error(`No elements found with role "${role}"`);
+    }
+    this.elements = locator;
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored ${count} elements with role "${role}"`);
+});
+// When(
+//   "I get {int}{ordinal} element",
+//   async function (this: CustomWorld, index: number) {
+//     if (!this.elements) {
+//       throw new Error(
+//         "No element collection found. Did you call 'find elements by' first?"
+//       );
+//     }
+//     const total = await this.elements.count();
+//     if (index < 1 || index > total) {
+//       throw new Error(
+//         `Index ${index} out of bounds. Found only ${total} elements.`
+//       );
+//     }
+//     this.element = this.elements.nth(index - 1);
+//     this.log?.(`Stored ${index}th element from collection`);
+//   }
+// );
+When("I get {int}rd element", async function (index) {
+    if (!this.elements)
+        throw new Error("No element collection found");
+    this.element = this.elements.nth(index);
+});
+When("I get focused element", async function () {
+    this.element = (await this.page.evaluateHandle(() => document.activeElement));
+});
+When("I store element text as {string}", async function (alias) {
+    var _a;
+    const element = this.element;
+    if (!element)
+        throw new Error("No element selected");
+    const text = await element.textContent();
+    this.data[alias] = text === null || text === void 0 ? void 0 : text.trim();
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored text "${text}" as "${alias}"`);
+});
+When("I find textarea by label text {string}", async function (label) {
+    var _a;
+    this.element = this.page.getByLabel(label);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored textarea with label "${label}"`);
+});
+When("I find textarea by placeholder text {string}", async function (placeholder) {
+    var _a;
+    this.element = this.page.getByPlaceholder(placeholder);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored textarea with placeholder "${placeholder}"`);
+});
+When("I find textareas by label text {string}", async function (label) {
+    var _a;
+    this.elements = this.page.locator(`label:has-text("${label}") + textarea`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple textareas with label "${label}"`);
+});
+When("I find textarea by name {string}", async function (name) {
+    var _a;
+    this.element = this.page.locator(`textarea[name="${name}"]`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored textarea with name "${name}"`);
+});
+When("I find textareas by ID {string}", async function (id) {
+    var _a;
+    this.elements = this.page.locator(`textarea#${id}`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple textareas with ID "${id}"`);
+});
+When("I find input by ID {string}", async function (id) {
+    var _a;
+    this.element = this.page.locator(`input#${id}`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored input with ID "${id}"`);
+});
+When("I find inputs by ID {string}", async function (id) {
+    var _a;
+    this.elements = this.page.locator(`input#${id}`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple inputs with ID "${id}"`);
+});
+When("I find textareas by placeholder text {string}", async function (placeholder) {
+    var _a;
+    this.elements = this.page.locator(`textarea[placeholder="${placeholder}"]`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple textareas with placeholder "${placeholder}"`);
+});
+When("I find input by label text {string}", async function (label) {
+    var _a;
+    this.element = this.page.getByLabel(label);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored input with label "${label}"`);
+});
+When("I find input by name {string}", async function (name) {
+    var _a;
+    this.element = this.page.locator(`input[name="${name}"]`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored input with name "${name}"`);
+});
+When("I find input by placeholder text {string}", async function (placeholder) {
+    var _a;
+    this.element = this.page.getByPlaceholder(placeholder);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored input with placeholder "${placeholder}"`);
+});
+When("I find inputs by name {string}", async function (name) {
+    var _a;
+    this.elements = this.page.locator(`input[name="${name}"]`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple inputs with name "${name}"`);
+});
+When("I find inputs by placeholder text {string}", async function (placeholder) {
+    var _a;
+    this.elements = this.page.locator(`input[placeholder="${placeholder}"]`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple inputs with placeholder "${placeholder}"`);
+});
+When("I find inputs by label text {string}", async function (label) {
+    var _a;
+    this.elements = this.page.locator(`label:has-text("${label}") + input`);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `Stored multiple inputs with label "${label}"`);
+});
+When("I find inputs by display value {string}", async function (value) {
+    var _a, _b;
+    // 🧠 Handle alias
+    if (value.startsWith("@")) {
+        const alias = value.slice(1);
+        value = (_a = this.data) === null || _a === void 0 ? void 0 : _a[alias];
+        if (!value) {
+            throw new Error(`No value found for alias "@${alias}"`);
+        }
+    }
+    // 🔍 Find all matching inputs
+    this.elements = this.page.locator(`input[value="${value}"]`);
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `📦 Stored multiple inputs with display value "${value}"`);
+});
+When("I find input by display value {string}", async function (value) {
+    var _a, _b;
+    // 🧠 Handle alias
+    if (value.startsWith("@")) {
+        const alias = value.slice(1);
+        value = (_a = this.data) === null || _a === void 0 ? void 0 : _a[alias];
+        if (!value) {
+            throw new Error(`No value found for alias "@${alias}"`);
+        }
+    }
+    // 🎯 Try to find input element with matching display value
+    const locator = this.page.locator(`input[value="${value}"]`);
+    await expect(locator).toBeVisible({ timeout: 5000 });
+    this.element = locator;
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `🔍 Found input with value: "${value}"`);
+});

package/dist/actions/inputSteps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/inputSteps.js

@@ -0,0 +1,166 @@
+// e2e/step_definitions/common/actions/inputSteps.ts
+import { When } from "@cucumber/cucumber";
+import { expect } from "@playwright/test";
+import path from "path";
+import fs from "fs";
+import { evaluateFaker } from "../helpers/utils/fakerUtils";
+import { parseClickOptions, parseCheckOptions, parseFillOptions, parseSelectOptions, } from "../helpers/utils/optionsUtils";
+When("I check", async function (...rest) {
+    var _a, _b;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseCheckOptions(maybeTable) : {};
+    await ((_a = this.element) === null || _a === void 0 ? void 0 : _a.check(options));
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, "✅ Checked stored checkbox");
+});
+When("I uncheck", async function (...rest) {
+    var _a, _b;
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseCheckOptions(maybeTable) : {};
+    await ((_a = this.element) === null || _a === void 0 ? void 0 : _a.uncheck(options));
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, "✅ Unchecked stored checkbox");
+});
+When("I check input", async function (...rest) {
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseCheckOptions(maybeTable) : {};
+    if (!this.element)
+        throw new Error("No input selected");
+    await this.element.check(options);
+});
+When("I uncheck input", async function (...rest) {
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseCheckOptions(maybeTable) : {};
+    if (!this.element)
+        throw new Error("No input selected");
+    await this.element.uncheck(options);
+});
+When("I fill the following {string} form data:", async function (_formName, tableData, ...rest) {
+    var _a, _b, _c, _d;
+    const maybeOptionsTable = rest[0];
+    const globalOptions = (maybeOptionsTable === null || maybeOptionsTable === void 0 ? void 0 : maybeOptionsTable.rowsHash)
+        ? parseClickOptions(maybeOptionsTable)
+        : {};
+    const rows = tableData.raw().slice(1); // Remove header row
+    for (const [rawTarget, rawValue] of rows) {
+        let element;
+        let resolvedValue;
+        if (rawTarget.startsWith("@")) {
+            element = this.data[rawTarget.slice(1)];
+            if (!element)
+                throw new Error(`No element found for alias: ${rawTarget}`);
+        }
+        else if (await this.page.locator(rawTarget).count()) {
+            element = this.page.locator(rawTarget);
+        }
+        else {
+            element = this.page.getByText(rawTarget, { exact: true }).first();
+        }
+        if (!element)
+            throw new Error(`Unable to resolve element for target: ${rawTarget}`);
+        await element.waitFor({ state: "visible", timeout: 7000 });
+        if (rawValue.startsWith("@")) {
+            resolvedValue = this.data[rawValue.slice(1)];
+            if (!resolvedValue)
+                throw new Error(`No value found for alias: ${rawValue}`);
+        }
+        else {
+            resolvedValue = evaluateFaker(rawValue);
+        }
+        if (resolvedValue === "Click") {
+            await element.click(globalOptions);
+            (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🖱️ Clicked on "${rawTarget}"`);
+        }
+        else if (rawTarget.includes('input[type="file"]')) {
+            const filePath = path.resolve("test-data", resolvedValue);
+            if (!fs.existsSync(filePath))
+                throw new Error(`File not found: ${filePath}`);
+            await element.setInputFiles(filePath);
+            (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `📁 Uploaded file to "${rawTarget}": ${resolvedValue}`);
+        }
+        else {
+            const keyPattern = /{(\w+)}/g;
+            const matches = [...resolvedValue.matchAll(keyPattern)];
+            const keys = matches.map((m) => m[1]);
+            const inputText = resolvedValue.replace(keyPattern, "").trim();
+            const fillOptions = (maybeOptionsTable === null || maybeOptionsTable === void 0 ? void 0 : maybeOptionsTable.rowsHash)
+                ? parseFillOptions(maybeOptionsTable)
+                : {};
+            if (inputText) {
+                await element.fill(inputText, fillOptions);
+                (_c = this.log) === null || _c === void 0 ? void 0 : _c.call(this, `⌨️ Filled "${rawTarget}" with: ${inputText}`);
+            }
+            for (const key of keys) {
+                await element.focus();
+                await this.page.waitForTimeout(200);
+                await element.press(key);
+                (_d = this.log) === null || _d === void 0 ? void 0 : _d.call(this, `🎹 Pressed {${key}} on "${rawTarget}"`);
+            }
+        }
+        await expect(element).toBeVisible();
+    }
+});
+const typeStep = async function (textOrAlias, ...rest) {
+    var _a, _b;
+    if (!this.element)
+        throw new Error("No element selected");
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseFillOptions(maybeTable) : {};
+    const text = textOrAlias.startsWith("@")
+        ? (_a = this.data[textOrAlias.slice(1)]) !== null && _a !== void 0 ? _a : (() => {
+            throw new Error(`No value found for alias "${textOrAlias}"`);
+        })()
+        : evaluateFaker(textOrAlias);
+    await this.element.fill("");
+    await this.element.fill(text, options);
+    this.data.lastTyped = text;
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `⌨️ Typed "${text}" into selected element`);
+};
+When("I type {string}", typeStep);
+When("I type stored {string}", typeStep);
+When("I type random {string}", typeStep);
+When("I set value {string}", async function (valueOrAlias, ...rest) {
+    var _a, _b;
+    if (!this.element)
+        throw new Error("No element selected");
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseFillOptions(maybeTable) : {};
+    const value = valueOrAlias.startsWith("@")
+        ? (_a = this.data[valueOrAlias.slice(1)]) !== null && _a !== void 0 ? _a : (() => {
+            throw new Error(`No value found for alias "${valueOrAlias}"`);
+        })()
+        : evaluateFaker(valueOrAlias);
+    await this.element.fill(value, options);
+    this.data.lastValueSet = value;
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `📝 Set value to "${value}"`);
+});
+When("I clear", async function () {
+    var _a;
+    if (!this.element)
+        throw new Error("No element selected");
+    await this.element.fill("");
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "🧼 Cleared value of selected element");
+});
+When("I submit", async function (...rest) {
+    var _a, _b;
+    const maybeTable = rest[0];
+    const form = (_a = this.element) !== null && _a !== void 0 ? _a : this.page.locator("form");
+    await form.evaluate((f) => f.submit());
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, "📨 Submitted form");
+});
+When("I select option {string}", async function (option, ...rest) {
+    var _a;
+    if (!this.element)
+        throw new Error("No select element stored");
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseSelectOptions(maybeTable) : {};
+    await this.element.selectOption({ label: option }, options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `🔽 Selected option "${option}"`);
+});
+When("I select file {string}", async function (filePath, ...rest) {
+    var _a;
+    if (!this.element)
+        throw new Error("No file input selected");
+    const maybeTable = rest[0];
+    const options = (maybeTable === null || maybeTable === void 0 ? void 0 : maybeTable.rowsHash) ? parseSelectOptions(maybeTable) : {};
+    await this.element.setInputFiles(filePath, options);
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `📁 Set input file to "${filePath}"`);
+});