playwright-cucumber-ts-steps 0.1.6 → 1.0.0

package/src/helpers/utils/fakerUtils.ts

@@ -0,0 +1,64 @@
+import { faker } from "@faker-js/faker";
+import dayjs from "dayjs";
+
+// Supports optional parameters
+type FakerMapping = Record<string, ((param?: string) => string) | (() => string)>;
+
+const fakerMapping: FakerMapping = {
+  "First Name": () => faker.person.middleName(),
+  Name: () => faker.person.middleName(),
+  "Last Name": () => faker.person.middleName(),
+  Email: () => faker.internet.email(),
+  "Phone Number": () => faker.string.numeric(10),
+  Number: () => faker.string.numeric(11),
+  "Complete Number": () => faker.string.numeric(11),
+  "App Colour": () => faker.color.rgb(),
+  "App Name": () => faker.commerce.productName(),
+  "Role Name": () => faker.person.jobTitle(),
+  "Company Name": () => faker.company.name(),
+  "Full Name": () => faker.person.fullName(),
+  "Disposable Email": () => faker.internet.email({ provider: "inboxkitten.com" }),
+  "ALpha Numeric": () => faker.string.numeric(11) + "e",
+  "Lorem Word": () => faker.lorem.sentences({ min: 1, max: 3 }),
+  Word: () => faker.lorem.word({ length: { min: 5, max: 11 } }),
+  "Current Date": () => dayjs().format("YYYY-MM-DD"),
+  "Current Date2": () => new Date().toISOString().split("T")[0],
+
+  MonthsFromNow: (months?: string) => {
+    const monthsToAdd = parseInt(months || "0", 10);
+    return dayjs().add(monthsToAdd, "month").format("YYYY-MM-DD");
+  },
+  MonthsAgo: (months?: string) => {
+    const monthsToSubtract = parseInt(months || "0", 10);
+    return dayjs().subtract(monthsToSubtract, "month").format("YYYY-MM-DD");
+  },
+
+  WeeksFromNow: (weeks?: string) => {
+    const weeksToAdd = parseInt(weeks || "0", 10);
+    return dayjs().add(weeksToAdd, "week").format("YYYY-MM-DD");
+  },
+  WeeksAgo: (weeks?: string) => {
+    const weeksToSubtract = parseInt(weeks || "0", 10);
+    return dayjs().subtract(weeksToSubtract, "week").format("YYYY-MM-DD");
+  },
+
+  DaysFromNow: (days?: string) => {
+    const daysToAdd = parseInt(days || "0", 10);
+    return dayjs().add(daysToAdd, "day").format("YYYY-MM-DD");
+  },
+  DaysAgo: (days?: string) => {
+    const daysToSubtract = parseInt(days || "0", 10);
+    return dayjs().subtract(daysToSubtract, "day").format("YYYY-MM-DD");
+  },
+};
+
+export function evaluateFaker(value: string): string {
+  const [key, param] = value.split(":");
+
+  const fn = fakerMapping[key];
+  if (typeof fn === "function") {
+    return fn(param);
+  }
+
+  return value; // fallback to raw value if not mapped
+}

package/src/helpers/utils/optionsUtils.ts

@@ -0,0 +1,104 @@
+//optionsUtils.ts
+import type { DataTable } from "@cucumber/cucumber";
+import type { Locator } from "@playwright/test";
+
+type ClickOptions = Parameters<Locator["click"]>[0];
+type DblClickOptions = Parameters<Locator["dblclick"]>[0];
+type HoverOptions = Parameters<Locator["hover"]>[0];
+type FillOptions = Parameters<Locator["fill"]>[1];
+type TypeOptions = Parameters<Locator["type"]>[1];
+type CheckOptions = Parameters<Locator["check"]>[0];
+type UncheckOptions = Parameters<Locator["uncheck"]>[0];
+type SelectOptionOptions = Parameters<Locator["selectOption"]>[1];
+
+type KeyboardModifier = NonNullable<NonNullable<ClickOptions>["modifiers"]>[number];
+
+export function parseClickOptions(table?: DataTable): Partial<ClickOptions> {
+  return parseGenericOptions(table) as Partial<ClickOptions>;
+}
+
+export function parseDblClickOptions(table?: DataTable): Partial<DblClickOptions> {
+  return parseGenericOptions(table) as Partial<DblClickOptions>;
+}
+
+export function parseHoverOptions(table?: DataTable): Partial<HoverOptions> {
+  return parseGenericOptions(table) as Partial<HoverOptions>;
+}
+
+export function parseTypeOptions(table?: DataTable): Partial<TypeOptions> {
+  return parseGenericOptions(table) as unknown as Partial<TypeOptions>;
+}
+
+export function parseFillOptions(table?: DataTable): Partial<FillOptions> {
+  return parseGenericOptions(table) as Partial<FillOptions>;
+}
+
+export function parseCheckOptions(table?: DataTable): Partial<CheckOptions> {
+  return parseGenericOptions(table) as Partial<CheckOptions>;
+}
+
+export function parseUncheckOptions(table?: DataTable): Partial<UncheckOptions> {
+  return parseGenericOptions(table) as Partial<UncheckOptions>;
+}
+
+export function parseSelectOptions(table?: DataTable): Partial<SelectOptionOptions> {
+  return parseGenericOptions(table) as Partial<SelectOptionOptions>;
+}
+
+export function parseGenericOptions(table?: DataTable): Record<string, any> {
+  if (!table) return {};
+
+  const options: Record<string, any> = {};
+  const rows = table.raw();
+
+  for (const [key, value] of rows) {
+    switch (key) {
+      case "timeout":
+      case "delay":
+      case "clickCount":
+        options[key] = Number(value);
+        break;
+
+      case "force":
+      case "noWaitAfter":
+      case "strict":
+      case "trial":
+        options[key] = value === "true";
+        break;
+
+      case "modifiers":
+        options.modifiers = value.split(",").map((v) => v.trim() as KeyboardModifier);
+        break;
+
+      case "button":
+        if (["left", "middle", "right"].includes(value)) {
+          options.button = value;
+        } else {
+          throw new Error(`Invalid button option: "${value}"`);
+        }
+        break;
+
+      case "position":
+        const [x, y] = value.split(",").map((n) => Number(n.trim()));
+        if (isNaN(x) || isNaN(y)) {
+          throw new Error(`Invalid position format: "${value}"`);
+        }
+        options.position = { x, y };
+        break;
+
+      default:
+        console.warn(`[⚠️ parseGenericOptions] Unknown option "${key}"`);
+        break;
+    }
+  }
+
+  return options;
+}
+export function parseExpectOptions(table?: DataTable): { timeout?: number; log?: boolean } {
+  if (!table) return {};
+  const obj = Object.fromEntries(table.rows());
+  return {
+    timeout: obj.timeout ? Number(obj.timeout) : undefined,
+    log: obj.log === "true",
+  };
+}

package/src/helpers/utils/resolveUtils.ts

@@ -0,0 +1,74 @@
+// src/helpers/utils/resolveUtils.ts
+import fs from "fs";
+import path from "path";
+import { devices } from "@playwright/test";
+import type { CustomWorld } from "../world";
+// Dynamic resolver
+export function resolveValue(input: string): string {
+  // Uppercase = environment variable (e.g. TEST_USER)
+  if (/^[A-Z0-9_]+$/.test(input)) {
+    const envVal = process.env[input];
+    if (!envVal) {
+      throw new Error(`Environment variable ${input} not found.`);
+    }
+    return envVal;
+  }
+
+  // Dot = JSON reference (e.g. userData.email)
+  if (input.includes(".")) {
+    const [fileName, fieldName] = input.split(".");
+    const jsonPath = path.resolve("e2e/support/helper/test-data", `${fileName}.json`);
+    if (fs.existsSync(jsonPath)) {
+      const json = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      const value = json[fieldName];
+      if (value !== undefined) return value;
+      throw new Error(`Field "${fieldName}" not found in ${fileName}.json`);
+    }
+  }
+
+  // Default to hardcoded value
+  return input;
+}
+
+export function resolveLoginValue(raw: string, world: CustomWorld): string | undefined {
+  // ✅ Alias: @aliasName
+  if (raw.startsWith("@")) {
+    return world.data[raw.slice(1)];
+  }
+
+  // ✅ JSON: user.json:key
+  if (raw.includes(".json:")) {
+    const [filename, key] = raw.split(".json:");
+    const filePath = path.resolve("test-data", `${filename}.json`);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`JSON fixture not found: ${filename}.json`);
+    }
+    const fileData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return fileData[key];
+  }
+
+  // ✅ Fallback to raw value
+  return raw;
+}
+// Determine session name from email or username
+export function deriveSessionName(emailOrUser: string, fallback = "default"): string {
+  if (!emailOrUser) return `${fallback}User`;
+
+  const base = emailOrUser.includes("@") ? emailOrUser.split("@")[0] : emailOrUser;
+
+  return `${base}User`;
+}
+
+export function resolveSessionPath(world: CustomWorld, name: string) {
+  const dir = path.resolve(world.data.artifactDir || "test-artifacts", "auth-cookies");
+  fs.mkdirSync(dir, { recursive: true });
+  return path.resolve(dir, name.endsWith(".json") ? name : `${name}.json`);
+}
+export function normalizeDeviceName(name: string): string {
+  return (
+    Object.keys(devices).find(
+      (device) =>
+        device.toLowerCase().replace(/\s+/g, "") === name.toLowerCase().replace(/[-_\s]+/g, "")
+    ) || ""
+  );
+}

package/src/helpers/utils/sessionUtils.ts

@@ -0,0 +1,36 @@
+//sessionUtils.ts
+import fs from "fs";
+import path from "path";
+import { BrowserContext } from "playwright";
+
+export async function injectStorage(world: any, type: string, key: string, value: string) {
+  const page = world.page;
+
+  if (type === "localStorage") {
+    await page.evaluate(([k, v]: [string, string]) => localStorage.setItem(k, v), [key, value]);
+  } else if (type === "sessionStorage") {
+    await page.evaluate(([k, v]: [string, string]) => sessionStorage.setItem(k, v), [key, value]);
+  } else if (type === "cookie") {
+    await page.context.addCookies([
+      {
+        name: key,
+        value,
+        domain: new URL(page.url()).hostname,
+        path: "/",
+        httpOnly: false,
+        secure: true,
+        sameSite: "Lax",
+      },
+    ]);
+  }
+}
+
+export async function saveSessionData(context: BrowserContext, file: string) {
+  const storageState = await context.storageState();
+  const outDir = "test-artifacts/auth-cookies";
+  const outPath = path.resolve(outDir, file);
+
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(outPath, JSON.stringify(storageState, null, 2));
+  console.log(`💾 Saved session to ${outPath}`);
+}

package/src/helpers/world.ts

@@ -0,0 +1,119 @@
+import { setWorldConstructor, World, ITestCaseHookParameter } from "@cucumber/cucumber";
+import { Browser, Page, BrowserContext, Locator, FrameLocator, devices } from "@playwright/test";
+import * as dotenv from "dotenv";
+import { chromium } from "playwright";
+
+dotenv.config();
+
+const isHeadless = process.env.HEADLESS !== "false";
+const slowMo = process.env.SLOWMO ? Number(process.env.SLOWMO) : 0;
+
+// Define a minimal interface for the clock object you expect
+// This is to help TypeScript understand the shape of context.clock
+// interface PlaywrightClock {
+//   setFixedTime(time: number | Date): Promise<void>;
+//   tick(ms: number): Promise<void>;
+//   restore(): Promise<void>;
+// }
+
+// If you need to extend the Clock type, do it via module augmentation with compatible types.
+// Otherwise, do not redeclare the 'clock' property to avoid type conflicts.
+// Remove the BrowserContext augmentation for 'clock' to resolve the type error.
+
+export interface TestConfig {
+  enableScreenshots: boolean;
+  enableVisualTest: boolean;
+  artifactDir: string;
+}
+
+export class CustomWorld extends World {
+  browser!: Browser;
+  context!: BrowserContext;
+  page!: Page;
+
+  elements?: Locator;
+  element?: Locator;
+  frame?: FrameLocator;
+  currentLocator?: Locator;
+
+  data: Record<string, any> = {};
+  logs: string[] = [];
+  testName?: string;
+
+  fakeTimersActive: boolean;
+
+  config: TestConfig = {
+    enableScreenshots: true,
+    enableVisualTest: false,
+    artifactDir: "test-artifacts",
+  };
+
+  constructor(options: import("@cucumber/cucumber").IWorldOptions) {
+    super(options);
+    this.fakeTimersActive = false;
+  }
+
+  async init(testInfo?: ITestCaseHookParameter) {
+    const info =
+      testInfo ?? ((this as any).parameters?.testInfo as ITestCaseHookParameter | undefined);
+    const isMobile = info?.pickle.tags.some((tag) => tag.name === "@mobile");
+    const device = isMobile ? devices["Pixel 5"] : undefined;
+
+    this.browser = await chromium.launch({ headless: isHeadless, slowMo });
+
+    this.context = await this.browser.newContext({
+      ...(device || {}),
+      recordVideo: { dir: `${this.config.artifactDir}/videos` },
+    });
+
+    // Important: Initialize clock mocking *before* navigating or interacting with the page
+    // if you intend to use page.clock. This typically involves addInitScript.
+    // However, the context.clock API does not usually require an init script for its methods.
+    // If you explicitly loaded a mocking library, you'd do it here.
+    // For just context.clock methods, they should be available.
+
+    this.page = await this.context.newPage();
+    this.testName = info?.pickle.name;
+    this.log(`🧪 Initialized context${isMobile ? " (mobile)" : ""}`);
+  }
+
+  /**
+   * Returns the current interaction scope: either the main page or active frame.
+   */
+  getScope(): Page | FrameLocator {
+    return this.frame ?? this.page;
+  }
+
+  /**
+   * Returns a Locator scoped to the current iframe or page.
+   */
+  getLocator(selector: string): Locator {
+    return this.getScope().locator(selector);
+  }
+
+  exitIframe() {
+    this.frame = undefined;
+    this.log("⬅️ Exited iframe, scope is now main page");
+  }
+
+  log = (message: string) => {
+    this.logs.push(message);
+    console.log(`[LOG] ${message}`);
+  };
+
+  async cleanup(testInfo?: ITestCaseHookParameter) {
+    try {
+      await this.page?.close();
+    } catch (err) {
+      this.log(`⚠️ Error closing page: ${(err as Error).message}`);
+    }
+
+    try {
+      await this.context?.close();
+    } catch (err) {
+      this.log(`⚠️ Error closing context: ${(err as Error).message}`);
+    }
+  }
+}
+
+setWorldConstructor(CustomWorld);

package/src/iframes/frames.ts

@@ -0,0 +1,15 @@
+import { When } from "@cucumber/cucumber";
+// import { expect } from "@playwright/test";
+import type { CustomWorld } from "../helpers/world";
+
+When(
+  "I find href in iframe {string} and store as {string}",
+  async function (this: CustomWorld, iframeSelector: string, key: string) {
+    const iframe = this.page.frameLocator(iframeSelector);
+    const link = await iframe.locator("a[href]").first();
+    const href = await link.getAttribute("href");
+
+    if (!href) throw new Error("No link found in iframe.");
+    this.data[key] = href;
+  }
+);

package/src/index.ts

@@ -0,0 +1,18 @@
+// Iframes
+export * from "./iframes/frames";
+
+// Setup (custom hooks, login, etc.)
+export * from "./custom_setups/loginHooks";
+
+// Core helpers and utilities
+export * from "./helpers/compareSnapshots";
+export * from "./helpers/hooks";
+export * from "./helpers/utils";
+export * from "./helpers/world";
+
+// Types
+export type { CustomWorld } from "./helpers/world";
+
+export * from "./actions";
+export * from "./assertions";
+export * from "./custom_setups/loginHooks";

package/src/register.ts

@@ -0,0 +1,4 @@
+// src/register.ts
+import { checkPeerDependencies } from "./helpers/checkPeerDeps";
+checkPeerDependencies(["@cucumber/cucumber", "@playwright/test", "@faker-js/faker"]);
+import "./index";

package/lib/actions/clickSteps.d.ts

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

package/lib/actions/clickSteps.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// e2e/step_definitions/common/actions/clickSteps.ts
-const cucumber_1 = require("@cucumber/cucumber");
-const optionsUtils_1 = require("../helpers/utils/optionsUtils");
-(0, cucumber_1.When)("I click", async function (...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    if (!this.element)
-        throw new Error("❌ No stored element to click.");
-    await this.element.click(options);
-    this.log?.("🖱️ Clicked on stored element");
-});
-(0, cucumber_1.When)("I click on element {string}", async function (selector, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const element = this.getLocator(selector);
-    await element.click(options);
-    this.element = element;
-    this.log?.(`🖱️ Clicked on element "${selector}"`);
-});
-(0, cucumber_1.When)("I click on button {string}", async function (label, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const button = await this.page.getByRole("button", { name: label });
-    await button.click(options);
-    this.element = button;
-    this.log?.(`🖱️ Clicked on button "${label}"`);
-});
-(0, cucumber_1.When)("I click on link {string}", async function (text, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const link = await this.page.getByRole("link", { name: text });
-    await link.click(options);
-    this.element = link;
-    this.log?.(`✅ Clicked on link "${text}"`);
-});
-(0, cucumber_1.When)("I click on label {string}", async function (labelText, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const label = await this.page.getByLabel(labelText);
-    await label.click(options);
-    this.element = label;
-    this.log?.(`🏷️ Clicked on label "${labelText}"`);
-});
-(0, cucumber_1.When)("I click on text {string}", async function (rawText, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.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();
-    this.log?.(`🖱️ Clicked on text "${text}"`);
-});
-(0, cucumber_1.When)("I click on exact text {string}", async function (exactText, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const locator = this.page.getByText(exactText, { exact: true });
-    await locator.waitFor({ state: "visible", timeout: 5000 });
-    await locator.click(options);
-    this.element = locator;
-    this.log?.(`🖱️ Clicked on exact text "${exactText}"`);
-});
-(0, cucumber_1.When)("I click all", async function (...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.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);
-        this.log?.(`🖱️ Clicked element #${i + 1}`);
-    }
-    this.log?.(`✅ Clicked all ${count} elements.`);
-});
-(0, cucumber_1.When)("I double click on text {string}", async function (text, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const element = this.element || this.page.getByText(text);
-    await element.dblclick(options);
-    this.log?.(`🖱️ Double-clicked on text "${text}"`);
-});
-(0, cucumber_1.When)("I double click position {int} {int}", async function (x, y, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    await this.page.mouse.dblclick(x, y, options);
-    this.log?.(`🖱️ Double-clicked at (${x}, ${y})`);
-});
-(0, cucumber_1.When)("I double click", async function (...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    if (!this.element)
-        throw new Error("❌ No stored element to double-click.");
-    await this.element.dblclick(options);
-    this.log?.("🖱️ Double-clicked on stored element");
-});
-(0, cucumber_1.When)("I right click", async function (...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    if (!this.element)
-        throw new Error("❌ No stored element to right-click.");
-    await this.element.click({ button: "right", ...options });
-    this.log?.("🖱️ Right-clicked on stored element");
-});
-(0, cucumber_1.When)("I right click on text {string}", async function (text, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    const element = this.page.getByText(text);
-    await element.click({ button: "right", ...options });
-    this.log?.(`🖱️ Right-clicked on text "${text}"`);
-});
-(0, cucumber_1.When)("I right click position {int} {int}", async function (x, y, ...rest) {
-    const maybeTable = rest[0];
-    const options = maybeTable?.rowsHash ? (0, optionsUtils_1.parseClickOptions)(maybeTable) : {};
-    await this.page.mouse.click(x, y, { button: "right", ...options });
-    this.log?.(`🖱️ Right-clicked at (${x}, ${y})`);
-});
-(0, cucumber_1.When)("I blur", async function () {
-    await this.page.evaluate(() => {
-        const active = document.activeElement;
-        if (active && typeof active.blur === "function") {
-            active.blur();
-        }
-    });
-    this.log?.("🌀 Blurred active element");
-});
-(0, cucumber_1.When)("I focus", async function () {
-    if (!this.element)
-        throw new Error("❌ No stored element to focus.");
-    await this.element.focus();
-    this.log?.("🎯 Focused stored element");
-});
-(0, cucumber_1.When)("I click all", async function (dataTable) {
-    const options = (0, optionsUtils_1.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);
-        this.log?.(`🖱️ Clicked element #${i + 1}`);
-    }
-    this.log?.(`✅ Clicked all ${count} stored elements.`);
-});
-(0, cucumber_1.When)(/^I click on selector "([^"]+)"$/, async function (selector) {
-    const locator = this.getLocator(selector);
-    await locator.click();
-    this.log?.(`🖱️ Clicked on selector: ${selector}`);
-});

package/lib/actions/cookieSteps.d.ts

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

package/lib/actions/cookieSteps.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// e2e/step_definitions/common/actions/cookieSteps.ts
-const cucumber_1 = require("@cucumber/cucumber");
-(0, cucumber_1.When)("I clear all cookies", async function () {
-    await this.page.context().clearCookies();
-    this.log("Cleared all cookies");
-});
-(0, cucumber_1.When)("I clear cookies", async function () {
-    await this.page.context().clearCookies();
-    this.log("Cleared cookies (alias)");
-});
-(0, cucumber_1.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}`);
-});
-(0, cucumber_1.When)("I log all cookies", async function () {
-    const cookies = await this.page.context().cookies();
-    console.log("Cookies:", cookies);
-});

package/lib/actions/debugSteps.d.ts

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

package/lib/actions/debugSteps.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// e2e/step_definitions/common/actions/debugSteps.ts
-const cucumber_1 = require("@cucumber/cucumber");
-(0, cucumber_1.When)("I debug with message {string}", async function (message) {
-    await this.page.pause();
-    this.log(`Paused test for debugging: ${message}`);
-});

package/lib/actions/elementFindSteps.d.ts

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