playwright-cucumber-ts-steps 0.1.0 → 0.1.1

package/dist/assertions/storageSteps.js

@@ -1,26 +1,31 @@
-import { When, Then } from "@cucumber/cucumber";
-import fs from "fs";
-import path from "path";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 //
 // 🗃 LOCAL STORAGE
 //
-Then("I see local storage item {string}", async function (key) {
+(0, cucumber_1.Then)("I see local storage item {string}", async function (key) {
     const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
     if (value === null)
         throw new Error(`Local storage item "${key}" not found`);
 });
-Then("I do not see local storage item {string}", async function (key) {
+(0, cucumber_1.Then)("I do not see local storage item {string}", async function (key) {
     const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
     if (value !== null)
         throw new Error(`Expected localStorage["${key}"] to be null, but got "${value}"`);
 });
-Then("I see local storage item {string} equals {string}", async function (key, expected) {
+(0, cucumber_1.Then)("I see local storage item {string} equals {string}", async function (key, expected) {
     const actual = await this.page.evaluate((k) => localStorage.getItem(k), key);
     if (actual !== expected) {
         throw new Error(`Expected localStorage["${key}"] to be "${expected}", but got "${actual}"`);
     }
 });
-Then("I see local storage item {string} contains {string}", async function (key, part) {
+(0, cucumber_1.Then)("I see local storage item {string} contains {string}", async function (key, part) {
     const value = await this.page.evaluate((k) => localStorage.getItem(k), key);
     if (!value || !value.includes(part)) {
         throw new Error(`localStorage["${key}"] does not contain "${part}". Got: "${value}"`);
@@ -29,24 +34,24 @@ Then("I see local storage item {string} contains {string}", async function (key,
 //
 // 🗂 SESSION STORAGE
 //
-Then("I see session storage item {string}", async function (key) {
+(0, cucumber_1.Then)("I see session storage item {string}", async function (key) {
     const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
     if (value === null)
         throw new Error(`Session storage item "${key}" not found`);
 });
-Then("I do not see session storage item {string}", async function (key) {
+(0, cucumber_1.Then)("I do not see session storage item {string}", async function (key) {
     const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
     if (value !== null)
         throw new Error(`Expected sessionStorage["${key}"] to be null, but got "${value}"`);
 });
-When("I clear all saved session files", async function () {
-    const authDir = path.resolve("e2e/support/helper/auth");
-    if (fs.existsSync(authDir)) {
-        const files = fs.readdirSync(authDir);
+(0, cucumber_1.When)("I clear all saved session files", async function () {
+    const authDir = path_1.default.resolve("e2e/support/helper/auth");
+    if (fs_1.default.existsSync(authDir)) {
+        const files = fs_1.default.readdirSync(authDir);
         for (const file of files) {
-            const filePath = path.join(authDir, file);
-            if (fs.lstatSync(filePath).isFile()) {
-                fs.unlinkSync(filePath);
+            const filePath = path_1.default.join(authDir, file);
+            if (fs_1.default.lstatSync(filePath).isFile()) {
+                fs_1.default.unlinkSync(filePath);
                 this.log?.(`🧹 Deleted session file: ${file}`);
             }
         }
@@ -55,13 +60,13 @@ When("I clear all saved session files", async function () {
         this.log?.(`⚠️ Auth directory not found at ${authDir}`);
     }
 });
-Then("I see session storage item {string} equals {string}", async function (key, expected) {
+(0, cucumber_1.Then)("I see session storage item {string} equals {string}", async function (key, expected) {
     const actual = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
     if (actual !== expected) {
         throw new Error(`Expected sessionStorage["${key}"] to be "${expected}", but got "${actual}"`);
     }
 });
-Then("I see session storage item {string} contains {string}", async function (key, part) {
+(0, cucumber_1.Then)("I see session storage item {string} contains {string}", async function (key, part) {
     const value = await this.page.evaluate((k) => sessionStorage.getItem(k), key);
     if (!value || !value.includes(part)) {
         throw new Error(`sessionStorage["${key}"] does not contain "${part}". Got: "${value}"`);

package/dist/assertions/visualSteps.js

@@ -1,67 +1,72 @@
-import { Then } from "@cucumber/cucumber";
-import pixelmatch from "pixelmatch";
-import { PNG } from "pngjs";
-import fs from "fs";
-import path from "path";
-import { expect } from "@playwright/test";
-const BASELINE_DIR = path.resolve("e2e/snapshots/baseline");
-const CURRENT_DIR = path.resolve("e2e/snapshots/current");
-const DIFF_DIR = path.resolve("e2e/snapshots/diff");
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const pngjs_1 = require("pngjs");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const test_1 = require("@playwright/test");
+const BASELINE_DIR = path_1.default.resolve("e2e/snapshots/baseline");
+const CURRENT_DIR = path_1.default.resolve("e2e/snapshots/current");
+const DIFF_DIR = path_1.default.resolve("e2e/snapshots/diff");
 function getSnapshotPaths(name) {
     const safeName = name.replace(/[^a-z0-9]/gi, "_").toLowerCase();
     return {
-        baseline: path.join(BASELINE_DIR, `${safeName}.png`),
-        current: path.join(CURRENT_DIR, `${safeName}.png`),
-        diff: path.join(DIFF_DIR, `${safeName}.diff.png`),
+        baseline: path_1.default.join(BASELINE_DIR, `${safeName}.png`),
+        current: path_1.default.join(CURRENT_DIR, `${safeName}.png`),
+        diff: path_1.default.join(DIFF_DIR, `${safeName}.diff.png`),
     };
 }
-Then("I should see the page matches the snapshot {string}", async function (name) {
+(0, cucumber_1.Then)("I should see the page matches the snapshot {string}", async function (name) {
     const { page } = this;
     const paths = getSnapshotPaths(name);
-    fs.mkdirSync(BASELINE_DIR, { recursive: true });
-    fs.mkdirSync(CURRENT_DIR, { recursive: true });
-    fs.mkdirSync(DIFF_DIR, { recursive: true });
+    fs_1.default.mkdirSync(BASELINE_DIR, { recursive: true });
+    fs_1.default.mkdirSync(CURRENT_DIR, { recursive: true });
+    fs_1.default.mkdirSync(DIFF_DIR, { recursive: true });
     await page.screenshot({ path: paths.current, fullPage: true });
-    if (!fs.existsSync(paths.baseline)) {
-        fs.copyFileSync(paths.current, paths.baseline);
+    if (!fs_1.default.existsSync(paths.baseline)) {
+        fs_1.default.copyFileSync(paths.current, paths.baseline);
         this.log?.(`📸 Created baseline snapshot: ${paths.baseline}`);
         return;
     }
-    const baseline = PNG.sync.read(fs.readFileSync(paths.baseline));
-    const current = PNG.sync.read(fs.readFileSync(paths.current));
+    const baseline = pngjs_1.PNG.sync.read(fs_1.default.readFileSync(paths.baseline));
+    const current = pngjs_1.PNG.sync.read(fs_1.default.readFileSync(paths.current));
     const { width, height } = baseline;
-    const diff = new PNG({ width, height });
-    const pixelDiff = pixelmatch(baseline.data, current.data, diff.data, width, height, { threshold: 0.1 });
+    const diff = new pngjs_1.PNG({ width, height });
+    const pixelDiff = (0, pixelmatch_1.default)(baseline.data, current.data, diff.data, width, height, { threshold: 0.1 });
     if (pixelDiff > 0) {
-        fs.writeFileSync(paths.diff, PNG.sync.write(diff));
+        fs_1.default.writeFileSync(paths.diff, pngjs_1.PNG.sync.write(diff));
         this.log?.(`❌ Visual mismatch detected, diff: ${paths.diff}`);
     }
-    expect(pixelDiff, "Pixels that differ").toBe(0);
+    (0, test_1.expect)(pixelDiff, "Pixels that differ").toBe(0);
 });
-Then("I capture a snapshot of the element {string} as {string}", async function (selector, alias) {
+(0, cucumber_1.Then)("I capture a snapshot of the element {string} as {string}", async function (selector, alias) {
     const element = this.getScope().locator(selector);
-    const pathCurrent = path.join(CURRENT_DIR, `${alias}.png`);
-    fs.mkdirSync(CURRENT_DIR, { recursive: true });
+    const pathCurrent = path_1.default.join(CURRENT_DIR, `${alias}.png`);
+    fs_1.default.mkdirSync(CURRENT_DIR, { recursive: true });
     await element.screenshot({ path: pathCurrent });
     this.log?.(`📸 Snapshot for ${selector} saved as ${alias}`);
 });
-Then("The snapshot {string} should match baseline", async function (alias) {
+(0, cucumber_1.Then)("The snapshot {string} should match baseline", async function (alias) {
     const paths = getSnapshotPaths(alias);
-    const current = PNG.sync.read(fs.readFileSync(paths.current));
-    const baseline = fs.existsSync(paths.baseline)
-        ? PNG.sync.read(fs.readFileSync(paths.baseline))
+    const current = pngjs_1.PNG.sync.read(fs_1.default.readFileSync(paths.current));
+    const baseline = fs_1.default.existsSync(paths.baseline)
+        ? pngjs_1.PNG.sync.read(fs_1.default.readFileSync(paths.baseline))
         : null;
     if (!baseline) {
-        fs.copyFileSync(paths.current, paths.baseline);
+        fs_1.default.copyFileSync(paths.current, paths.baseline);
         this.log?.(`📸 Created new baseline for ${alias}`);
         return;
     }
     const { width, height } = baseline;
-    const diff = new PNG({ width, height });
-    const pixelDiff = pixelmatch(baseline.data, current.data, diff.data, width, height, { threshold: 0.1 });
+    const diff = new pngjs_1.PNG({ width, height });
+    const pixelDiff = (0, pixelmatch_1.default)(baseline.data, current.data, diff.data, width, height, { threshold: 0.1 });
     if (pixelDiff > 0) {
-        fs.writeFileSync(paths.diff, PNG.sync.write(diff));
+        fs_1.default.writeFileSync(paths.diff, pngjs_1.PNG.sync.write(diff));
         this.log?.(`⚠️ Snapshot mismatch: ${alias}`);
     }
-    expect(pixelDiff).toBe(0);
+    (0, test_1.expect)(pixelDiff).toBe(0);
 });

package/dist/custom_setups/globalLogin.js

@@ -1,8 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // global-setup.ts
-import { chromium } from "@playwright/test";
-import path from "path";
+const test_1 = require("@playwright/test");
+const path_1 = __importDefault(require("path"));
 async function globalSetup() {
-    const browser = await chromium.launch();
+    const browser = await test_1.chromium.launch();
     const page = await browser.newPage();
     // Navigate to login and log in
     await page.goto(process.env.PLAYWRIGHT_BASE_URL || "http://demoqa.com");
@@ -14,7 +19,7 @@ async function globalSetup() {
     // Save session to file
     await page
         .context()
-        .storageState({ path: path.resolve(__dirname, "storageState.json") });
+        .storageState({ path: path_1.default.resolve(__dirname, "storageState.json") });
     await browser.close();
 }
-export default globalSetup;
+exports.default = globalSetup;

package/dist/custom_setups/loginHooks.js

@@ -1,13 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // e2e/step_definitions/auth/loginHooks.ts
-import { When } from "@cucumber/cucumber";
-import { expect } from "@playwright/test";
-import path from "path";
-import { resolveValue, deriveSessionName, resolveLoginValue, } from "../helpers/utils/resolveUtils";
-import fs from "fs";
-import { log } from "console";
+const cucumber_1 = require("@cucumber/cucumber");
+const test_1 = require("@playwright/test");
+const path_1 = __importDefault(require("path"));
+const resolveUtils_1 = require("../helpers/utils/resolveUtils");
+const fs_1 = __importDefault(require("fs"));
+const console_1 = require("console");
 async function tryRestoreSession(world, sessionName) {
-    const storagePath = path.resolve("e2e/support/helper/auth", `${sessionName}.json`);
-    if (fs.existsSync(storagePath)) {
+    const storagePath = path_1.default.resolve("e2e/support/helper/auth", `${sessionName}.json`);
+    if (fs_1.default.existsSync(storagePath)) {
         await world.context?.addCookies([]);
         await world.page.context().addInitScript(() => {
             // preload logic if needed
@@ -23,30 +28,30 @@ async function loginAndSaveSession(world, email, password, sessionName) {
     if (!baseUrl)
         throw new Error("Missing BASE_URL in environment");
     await pageLogin(world, baseUrl, email, password);
-    const sessionFile = path.resolve("e2e/support/helper/auth", `${sessionName}.json`);
+    const sessionFile = path_1.default.resolve("e2e/support/helper/auth", `${sessionName}.json`);
     await world.page.context().storageState({ path: sessionFile });
     world.log(`Session saved to ${sessionFile}`);
 }
 const loginStep = async function (user, pass) {
-    const email = resolveValue(user);
-    const password = resolveValue(pass);
-    const sessionName = deriveSessionName(email);
+    const email = (0, resolveUtils_1.resolveValue)(user);
+    const password = (0, resolveUtils_1.resolveValue)(pass);
+    const sessionName = (0, resolveUtils_1.deriveSessionName)(email);
     const restored = await tryRestoreSession(this, sessionName);
     if (!restored) {
         await loginAndSaveSession(this, email, password, sessionName);
     }
 };
-When("I am logged out", async function () {
+(0, cucumber_1.When)("I am logged out", async function () {
     const { page } = this;
     await page.goto("/");
     const url = page.url();
     if (!url.includes("/login")) {
         await page.locator("//div[@id=':rti:']//*[name()='svg']").last().click();
         await page.getByText("Logout").click();
-        await expect(page.getByText("Log in")).toBeVisible();
+        await (0, test_1.expect)(page.getByText("Log in")).toBeVisible();
     }
 });
-When("I login as a default user", async function () {
+(0, cucumber_1.When)("I login as a default user", async function () {
     const baseUrl = process.env.BASE_URL;
     const email = process.env.USER_EMAIL;
     const password = process.env.USER_PASSWORD;
@@ -56,18 +61,18 @@ When("I login as a default user", async function () {
     }
     await pageLogin(this, baseUrl, email, password);
 });
-When("I login with user {string} and password {string}", loginStep);
+(0, cucumber_1.When)("I login with user {string} and password {string}", loginStep);
 // Given("I login with user {string} and password {string}", loginStep);
 // Special alias step
-When("I login as {string} user", async function (alias) {
-    const sessionFile = path.resolve("storage", `${alias}User.json`);
+(0, cucumber_1.When)("I login as {string} user", async function (alias) {
+    const sessionFile = path_1.default.resolve("storage", `${alias}User.json`);
     const email = process.env.USER_EMAIL;
     const password = process.env.USER_PASSWORD;
     const baseUrl = process.env.BASE_URL;
     if (!email || !password) {
         throw new Error("USER_EMAIL or USER_PASSWORD not set in .env");
     }
-    if (fs.existsSync(sessionFile)) {
+    if (fs_1.default.existsSync(sessionFile)) {
         await this.context.addCookies([]); // optional reset
         await this.context.addInitScript(() => { });
         await this.context.storageState({ path: sessionFile });
@@ -89,10 +94,10 @@ When("I login as {string} user", async function (alias) {
     await this.context.storageState({ path: sessionFile });
     this.log(`💾 Saved session to ${alias}User.json`);
 });
-When("I perform login with:", async function (dataTable) {
+(0, cucumber_1.When)("I perform login with:", async function (dataTable) {
     const loginData = Object.fromEntries(dataTable.raw());
-    const email = resolveLoginValue(loginData.email, this);
-    const password = resolveLoginValue(loginData.password, this) ?? process.env.USER_PASSWORD;
+    const email = (0, resolveUtils_1.resolveLoginValue)(loginData.email, this);
+    const password = (0, resolveUtils_1.resolveLoginValue)(loginData.password, this) ?? process.env.USER_PASSWORD;
     if (!email)
         throw new Error("Missing or invalid email for login");
     if (!password)
@@ -117,15 +122,15 @@ async function pageLogin(world, baseUrl, email, password) {
         await page.getByRole("button", { name: "Login" }).click();
         await page.waitForLoadState("networkidle");
         if (await page.getByText("Select an account").isVisible()) {
-            log("Login successful, navigating to accounts page");
+            (0, console_1.log)("Login successful, navigating to accounts page");
             await page.goto(`${baseUrl}/indicina`);
         }
-        await expect(page.getByText("Total unique customers")).toBeVisible({
+        await (0, test_1.expect)(page.getByText("Total unique customers")).toBeVisible({
             timeout: 10000,
         });
         // ✅ Save session after successful login
         await page.context().storageState({
-            path: path.resolve("e2e/support/helper/auth", "session.json"),
+            path: path_1.default.resolve("e2e/support/helper/auth", "session.json"),
         });
         world.data["loggedIn"] = true;
         world.log?.("✅ Logged in and session saved.");

package/dist/helpers/compareSnapshots.js

@@ -1,14 +1,20 @@
-import fs from "fs";
-import pixelmatch from "pixelmatch";
-import { PNG } from "pngjs";
-export function compareSnapshots({ actualPath, baselinePath, diffPath, threshold = 0.1, }) {
-    const actual = PNG.sync.read(fs.readFileSync(actualPath));
-    const baseline = PNG.sync.read(fs.readFileSync(baselinePath));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSnapshots = compareSnapshots;
+const fs_1 = __importDefault(require("fs"));
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const pngjs_1 = require("pngjs");
+function compareSnapshots({ actualPath, baselinePath, diffPath, threshold = 0.1, }) {
+    const actual = pngjs_1.PNG.sync.read(fs_1.default.readFileSync(actualPath));
+    const baseline = pngjs_1.PNG.sync.read(fs_1.default.readFileSync(baselinePath));
     if (actual.width !== baseline.width || actual.height !== baseline.height) {
         throw new Error("Snapshot size mismatch");
     }
-    const diff = new PNG({ width: actual.width, height: actual.height });
-    const numDiffPixels = pixelmatch(actual.data, baseline.data, diff.data, actual.width, actual.height, { threshold });
-    fs.writeFileSync(diffPath, PNG.sync.write(diff));
+    const diff = new pngjs_1.PNG({ width: actual.width, height: actual.height });
+    const numDiffPixels = (0, pixelmatch_1.default)(actual.data, baseline.data, diff.data, actual.width, actual.height, { threshold });
+    fs_1.default.writeFileSync(diffPath, pngjs_1.PNG.sync.write(diff));
     return numDiffPixels;
 }

package/dist/helpers/hooks.js

@@ -1,18 +1,56 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // support/hooks.ts
-import { Before, After, BeforeAll, AfterAll, } from "@cucumber/cucumber";
-import { chromium, devices } from "playwright";
-import * as dotenv from "dotenv";
-import fs from "fs";
-import path from "path";
-import { compareSnapshots } from "./compareSnapshots";
+const cucumber_1 = require("@cucumber/cucumber");
+const playwright_1 = require("playwright");
+const dotenv = __importStar(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compareSnapshots_1 = require("./compareSnapshots");
 dotenv.config();
-const SESSION_FILE = path.resolve("e2e/support/helper/auth", "session.json");
-const SCREENSHOT_DIR = path.resolve("e2e/screenshots");
-const VIDEO_DIR = path.resolve("e2e/videos");
-const SNAPSHOT_BASELINE_DIR = path.resolve("e2e/snapshots/baseline");
-const SNAPSHOT_DIFF_DIR = path.resolve("e2e/snapshots/diff");
+const SESSION_FILE = path_1.default.resolve("e2e/support/helper/auth", "session.json");
+const SCREENSHOT_DIR = path_1.default.resolve("e2e/screenshots");
+const VIDEO_DIR = path_1.default.resolve("e2e/videos");
+const SNAPSHOT_BASELINE_DIR = path_1.default.resolve("e2e/snapshots/baseline");
+const SNAPSHOT_DIFF_DIR = path_1.default.resolve("e2e/snapshots/diff");
 let sharedBrowser;
-BeforeAll(async () => {
+(0, cucumber_1.BeforeAll)(async () => {
     const dirsToClean = [
         VIDEO_DIR,
         SCREENSHOT_DIR,
@@ -20,8 +58,8 @@ BeforeAll(async () => {
     ];
     for (const dir of dirsToClean) {
         try {
-            if (fs.existsSync(dir)) {
-                fs.rmSync(dir, { recursive: true, force: true });
+            if (fs_1.default.existsSync(dir)) {
+                fs_1.default.rmSync(dir, { recursive: true, force: true });
                 console.log(`🧹 Cleaned directory: ${dir}`);
             }
         }
@@ -29,20 +67,20 @@ BeforeAll(async () => {
             console.warn(`⚠️ Failed to clean directory ${dir}:`, err);
         }
     }
-    sharedBrowser = await chromium.launch({
+    sharedBrowser = await playwright_1.chromium.launch({
         headless: process.env.HEADLESS !== "false",
     });
     console.log("🚀 Launched shared browser for all scenarios");
 });
-AfterAll(async () => {
+(0, cucumber_1.AfterAll)(async () => {
     await sharedBrowser?.close();
     console.log("🧹 Closed shared browser after all scenarios");
 });
-Before(async function (scenario) {
+(0, cucumber_1.Before)(async function (scenario) {
     // 🛡️ Ensure browser is still usable
     if (!sharedBrowser || !sharedBrowser.isConnected()) {
         console.warn("⚠️ Shared browser was disconnected. Restarting...");
-        sharedBrowser = await chromium.launch({
+        sharedBrowser = await playwright_1.chromium.launch({
             headless: process.env.HEADLESS !== "false",
         });
     }
@@ -52,9 +90,9 @@ Before(async function (scenario) {
         process.env.VISUAL_TEST = "true";
     const contextOptions = {
         recordVideo: { dir: VIDEO_DIR },
-        ...(isMobile ? devices["iPhone 13 Pro"] : {}),
+        ...(isMobile ? playwright_1.devices["iPhone 13 Pro"] : {}),
     };
-    if (fs.existsSync(SESSION_FILE)) {
+    if (fs_1.default.existsSync(SESSION_FILE)) {
         contextOptions.storageState = SESSION_FILE;
         this.log?.("✅ Reusing session from saved file.");
     }
@@ -66,14 +104,14 @@ Before(async function (scenario) {
     if (isMobile)
         this.log?.("📱 Mobile emulation enabled (iPhone 13 Pro)");
 });
-After(async function (scenario) {
+(0, cucumber_1.After)(async function (scenario) {
     const failed = scenario.result?.status === "FAILED";
     const name = scenario.pickle.name.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
     // 📸 Screenshot on failure
     if (failed && this.page) {
-        const screenshotPath = path.join(SCREENSHOT_DIR, `failed-${name}.png`);
+        const screenshotPath = path_1.default.join(SCREENSHOT_DIR, `failed-${name}.png`);
         try {
-            fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+            fs_1.default.mkdirSync(SCREENSHOT_DIR, { recursive: true });
             await this.page.screenshot({ path: screenshotPath, fullPage: true });
             console.log(`🖼️ Screenshot saved: ${screenshotPath}`);
         }
@@ -91,14 +129,14 @@ After(async function (scenario) {
     }
     if (rawPath) {
         try {
-            const finalPath = path.join(VIDEO_DIR, `failed-${name}.webm`);
-            fs.mkdirSync(VIDEO_DIR, { recursive: true });
+            const finalPath = path_1.default.join(VIDEO_DIR, `failed-${name}.webm`);
+            fs_1.default.mkdirSync(VIDEO_DIR, { recursive: true });
             if (failed) {
-                fs.renameSync(rawPath, finalPath);
+                fs_1.default.renameSync(rawPath, finalPath);
                 console.log(`🎥 Video saved: ${finalPath}`);
             }
             else {
-                fs.unlinkSync(rawPath);
+                fs_1.default.unlinkSync(rawPath);
                 console.log(`🧹 Deleted video for passed test: ${rawPath}`);
             }
         }
@@ -108,19 +146,19 @@ After(async function (scenario) {
     }
     // 🧪 Visual regression testing
     if (this.page && process.env.VISUAL_TEST === "true") {
-        fs.mkdirSync(SNAPSHOT_BASELINE_DIR, { recursive: true });
-        fs.mkdirSync(SNAPSHOT_DIFF_DIR, { recursive: true });
-        const baselinePath = path.join(SNAPSHOT_BASELINE_DIR, `${name}.png`);
-        const actualPath = path.join(SNAPSHOT_DIFF_DIR, `${name}.actual.png`);
-        const diffPath = path.join(SNAPSHOT_DIFF_DIR, `${name}.diff.png`);
+        fs_1.default.mkdirSync(SNAPSHOT_BASELINE_DIR, { recursive: true });
+        fs_1.default.mkdirSync(SNAPSHOT_DIFF_DIR, { recursive: true });
+        const baselinePath = path_1.default.join(SNAPSHOT_BASELINE_DIR, `${name}.png`);
+        const actualPath = path_1.default.join(SNAPSHOT_DIFF_DIR, `${name}.actual.png`);
+        const diffPath = path_1.default.join(SNAPSHOT_DIFF_DIR, `${name}.diff.png`);
         await this.page.screenshot({ path: actualPath, fullPage: true });
-        if (!fs.existsSync(baselinePath)) {
-            fs.copyFileSync(actualPath, baselinePath);
+        if (!fs_1.default.existsSync(baselinePath)) {
+            fs_1.default.copyFileSync(actualPath, baselinePath);
             console.log(`📸 Created baseline image: ${baselinePath}`);
         }
         else {
             try {
-                const diffPixels = compareSnapshots({
+                const diffPixels = (0, compareSnapshots_1.compareSnapshots)({
                     actualPath,
                     baselinePath,
                     diffPath,