playwright-cucumber-ts-steps 0.1.6 → 0.1.7

package/src/helpers/hooks.ts

@@ -0,0 +1,212 @@
+import fs from "fs";
+import path from "path";
+import {
+  Before,
+  After,
+  BeforeAll,
+  AfterAll,
+  ITestCaseHookParameter,
+  setDefaultTimeout,
+} from "@cucumber/cucumber";
+import * as dotenv from "dotenv";
+import { chromium, devices, Browser, BrowserContextOptions } from "playwright";
+import { compareSnapshots } from "./compareSnapshots";
+import { CustomWorld } from "./world";
+
+// Set to 30 seconds
+setDefaultTimeout(30 * 1000);
+dotenv.config();
+
+let sharedBrowser: Browser;
+
+BeforeAll(async () => {
+  sharedBrowser = await chromium.launch({
+    headless: process.env.HEADLESS !== "false",
+  });
+  console.log("🚀 Launched shared browser for all scenarios");
+});
+
+AfterAll(async () => {
+  await sharedBrowser?.close();
+  console.log("🧹 Closed shared browser after all scenarios");
+});
+
+Before(async function (this: CustomWorld, scenario: ITestCaseHookParameter) {
+  const params = this.parameters || {};
+  const ARTIFACT_DIR = params.artifactDir || process.env.TEST_ARTIFACT_DIR || "test-artifacts";
+  const SCREENSHOT_DIR = path.resolve(ARTIFACT_DIR, "screenshots");
+  const VIDEO_DIR = path.resolve(ARTIFACT_DIR, "videos");
+  const TRACE_DIR = path.resolve(ARTIFACT_DIR, "traces");
+  const SESSION_FILE = path.resolve(ARTIFACT_DIR, "auth-cookies", "session.json");
+
+  this.data.artifactDir = ARTIFACT_DIR;
+  this.data.screenshotDir = SCREENSHOT_DIR;
+  this.data.videoDir = VIDEO_DIR;
+  this.data.traceDir = TRACE_DIR;
+  this.data.sessionFile = SESSION_FILE;
+
+  // Modes: "false" | "fail" | "all"
+  const traceMode = (params.enableTrace || process.env.ENABLE_TRACE || "false").toLowerCase();
+  const screenshotMode = (
+    params.enableScreenshots ||
+    process.env.ENABLE_SCREENSHOTS ||
+    "false"
+  ).toLowerCase();
+  const videoMode = (params.enableVideos || process.env.ENABLE_VIDEOS || "false").toLowerCase();
+
+  this.data.traceMode = traceMode;
+  this.data.screenshotMode = screenshotMode;
+  this.data.videoMode = videoMode;
+
+  const isMobileTag = scenario.pickle.tags.some((t) => t.name === "@mobile");
+  const deviceName =
+    params.device || process.env.MOBILE_DEVICE || (isMobileTag ? "iPhone 13 Pro" : null);
+  const deviceSettings = deviceName ? devices[deviceName] : undefined;
+
+  if (deviceName && !deviceSettings) {
+    throw new Error(`🚫 Invalid MOBILE_DEVICE: "${deviceName}" is not recognized by Playwright.`);
+  }
+
+  const isVisualTest =
+    params.enableVisualTest ??
+    (process.env.ENABLE_VISUAL_TEST === "true" ||
+      scenario.pickle.tags.some((t) => t.name === "@visual"));
+
+  this.data.enableVisualTest = isVisualTest;
+  if (isVisualTest) process.env.VISUAL_TEST = "true";
+
+  const contextOptions: BrowserContextOptions = {
+    ...(videoMode !== "false" ? { recordVideo: { dir: VIDEO_DIR } } : {}),
+    ...(deviceSettings || {}),
+  };
+
+  if (fs.existsSync(SESSION_FILE)) {
+    contextOptions.storageState = SESSION_FILE;
+    this.log?.("✅ Reusing session from saved file.");
+  }
+
+  const context = await sharedBrowser.newContext(contextOptions);
+  const page = await context.newPage();
+
+  this.browser = sharedBrowser;
+  this.context = context;
+  this.page = page;
+
+  if (traceMode !== "false") {
+    await context.tracing.start({
+      screenshots: true,
+      snapshots: true,
+      sources: true,
+    });
+    this.data.tracingStarted = true;
+    this.log?.(`🧪 Tracing started (${traceMode})`);
+  }
+
+  if (deviceName) this.log?.(`📱 Mobile emulation enabled (${deviceName})`);
+});
+
+After(async function (this: CustomWorld, scenario: ITestCaseHookParameter) {
+  const name = scenario.pickle.name.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
+  const failed = scenario.result?.status === "FAILED";
+  const mode = (value: string | undefined) => value?.toLowerCase();
+
+  const screenshotMode = mode(this.parameters?.enableScreenshots || process.env.ENABLE_SCREENSHOTS);
+  const videoMode = mode(this.parameters?.enableVideos || process.env.ENABLE_VIDEOS);
+  const traceMode = mode(this.parameters?.enableTrace || process.env.ENABLE_TRACE);
+
+  const shouldSaveScreenshot = screenshotMode === "all" || (screenshotMode === "fail" && failed);
+  const shouldSaveVideo = videoMode === "all" || (videoMode === "fail" && failed);
+  const shouldSaveTrace = traceMode === "all" || (traceMode === "fail" && failed);
+
+  // 📸 Screenshot
+  if (shouldSaveScreenshot && this.page) {
+    const screenshotPath = path.join(
+      this.data.screenshotDir,
+      `${failed ? "failed-" : ""}${name}.png`
+    );
+    try {
+      fs.mkdirSync(this.data.screenshotDir, { recursive: true });
+      await this.page.screenshot({ path: screenshotPath, fullPage: true });
+      console.log(`🖼️ Screenshot saved: ${screenshotPath}`);
+    } catch (err) {
+      console.warn("❌ Failed to save screenshot:", err);
+    }
+  }
+
+  // 🎥 Video
+  if (this.page && videoMode !== "false") {
+    try {
+      const video = this.page.video();
+      if (video) {
+        const rawPath = await video.path();
+        if (fs.existsSync(rawPath)) {
+          const finalPath = path.join(this.data.videoDir, `${failed ? "failed-" : ""}${name}.webm`);
+          fs.mkdirSync(this.data.videoDir, { recursive: true });
+          shouldSaveVideo ? fs.renameSync(rawPath, finalPath) : fs.unlinkSync(rawPath);
+          console.log(`${shouldSaveVideo ? "🎥 Video saved" : "🧹 Deleted video"}: ${finalPath}`);
+        }
+      }
+    } catch (err) {
+      console.warn(`⚠️ Video error: ${(err as Error).message}`);
+    }
+  }
+
+  // 🧪 Tracing
+  if (this.context && this.data.tracingStarted) {
+    const tracePath = path.join(this.data.artifactDir, "traces", `${name}.zip`);
+    try {
+      fs.mkdirSync(path.dirname(tracePath), { recursive: true });
+      await this.context.tracing.stop({ path: tracePath });
+      shouldSaveTrace
+        ? console.log(`📦 Trace saved: ${tracePath}`)
+        : (fs.existsSync(tracePath) && fs.unlinkSync(tracePath),
+          console.log(`🧹 Trace discarded: ${tracePath}`));
+    } catch (err) {
+      console.warn("❌ Trace handling error:", err);
+    }
+  }
+
+  // 🧪 Visual regression
+  if (this.page && this.data.enableVisualTest) {
+    const BASELINE_DIR = path.resolve(this.data.artifactDir, "snapshots/baseline");
+    const DIFF_DIR = path.resolve(this.data.artifactDir, "snapshots/diff");
+
+    fs.mkdirSync(BASELINE_DIR, { recursive: true });
+    fs.mkdirSync(DIFF_DIR, { recursive: true });
+
+    const baselinePath = path.join(BASELINE_DIR, `${name}.png`);
+    const actualPath = path.join(DIFF_DIR, `${name}.actual.png`);
+    const diffPath = path.join(DIFF_DIR, `${name}.diff.png`);
+
+    await this.page.screenshot({ path: actualPath, fullPage: true });
+
+    if (!fs.existsSync(baselinePath)) {
+      fs.copyFileSync(actualPath, baselinePath);
+      console.log(`📸 Created baseline image: ${baselinePath}`);
+    } else {
+      try {
+        const diffPixels = compareSnapshots({
+          actualPath,
+          baselinePath,
+          diffPath,
+          threshold: 0.1,
+        });
+
+        console.log(
+          diffPixels > 0
+            ? `⚠️ Visual diff found (${diffPixels} pixels): ${diffPath}`
+            : "✅ No visual changes detected"
+        );
+      } catch (err) {
+        console.warn("❌ Snapshot comparison failed:", err);
+      }
+    }
+  }
+
+  // Cleanup
+  try {
+    await this.cleanup(scenario);
+  } catch (err) {
+    this.log?.("❌ Error during cleanup: " + (err as Error).message);
+  }
+});

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/index.ts

@@ -0,0 +1,4 @@
+export * from "./fakerUtils";
+export * from "./optionsUtils";
+export * from "./resolveUtils";
+export * from "./sessionUtils";

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,93 @@
+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;
+
+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;
+
+  data: Record<string, any> = {};
+  logs: string[] = [];
+  testName?: string;
+
+  config: TestConfig = {
+    enableScreenshots: true,
+    enableVisualTest: false,
+    artifactDir: "test-artifacts",
+  };
+
+  async init(testInfo?: ITestCaseHookParameter) {
+    const isMobile = testInfo?.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` },
+    });
+
+    this.page = await this.context.newPage();
+    this.testName = testInfo?.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) {
+    testInfo?.result?.status === "FAILED";
+
+    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,39 @@
+// Actions
+export * from "./actions/clickSteps";
+export * from "./actions/cookieSteps";
+export * from "./actions/debugSteps";
+export * from "./actions/elementFindSteps";
+export * from "./actions/fillFormSteps";
+export * from "./actions/inputSteps";
+export * from "./actions/interceptionSteps";
+export * from "./actions/miscSteps";
+export * from "./actions/mouseSteps";
+export * from "./actions/scrollSteps";
+export * from "./actions/storageSteps";
+
+// Assertions
+export * from "./assertions/buttonAndTextVisibilitySteps";
+export * from "./assertions/cookieSteps";
+export * from "./assertions/elementSteps";
+export * from "./assertions/formInputSteps";
+export * from "./assertions/interceptionRequestsSteps";
+export * from "./assertions/locationSteps";
+export * from "./assertions/roleTestIdSteps";
+export * from "./assertions/semanticSteps";
+export * from "./assertions/storageSteps";
+export * from "./assertions/visualSteps";
+
+// 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";

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";