playwright-cucumber-ts-steps 0.0.4 → 0.0.6

package/dist/assertions/visualSteps.js

@@ -0,0 +1,70 @@
+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");
+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`),
+    };
+}
+Then("I should see the page matches the snapshot {string}", async function (name) {
+    var _a, _b;
+    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 });
+    await page.screenshot({ path: paths.current, fullPage: true });
+    if (!fs.existsSync(paths.baseline)) {
+        fs.copyFileSync(paths.current, paths.baseline);
+        (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `📸 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 { width, height } = baseline;
+    const diff = new PNG({ width, height });
+    const pixelDiff = pixelmatch(baseline.data, current.data, diff.data, width, height, { threshold: 0.1 });
+    if (pixelDiff > 0) {
+        fs.writeFileSync(paths.diff, PNG.sync.write(diff));
+        (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `❌ Visual mismatch detected, diff: ${paths.diff}`);
+    }
+    expect(pixelDiff, "Pixels that differ").toBe(0);
+});
+Then("I capture a snapshot of the element {string} as {string}", async function (selector, alias) {
+    var _a;
+    const element = this.getScope().locator(selector);
+    const pathCurrent = path.join(CURRENT_DIR, `${alias}.png`);
+    fs.mkdirSync(CURRENT_DIR, { recursive: true });
+    await element.screenshot({ path: pathCurrent });
+    (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `📸 Snapshot for ${selector} saved as ${alias}`);
+});
+Then("The snapshot {string} should match baseline", async function (alias) {
+    var _a, _b;
+    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))
+        : null;
+    if (!baseline) {
+        fs.copyFileSync(paths.current, paths.baseline);
+        (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, `📸 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 });
+    if (pixelDiff > 0) {
+        fs.writeFileSync(paths.diff, PNG.sync.write(diff));
+        (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `⚠️ Snapshot mismatch: ${alias}`);
+    }
+    expect(pixelDiff).toBe(0);
+});

package/dist/custom_setups/global-login.d.ts

@@ -0,0 +1,2 @@
+declare function globalSetup(): Promise<void>;
+export default globalSetup;

package/dist/custom_setups/global-login.js

@@ -0,0 +1,20 @@
+// global-setup.ts
+import { chromium } from "@playwright/test";
+import path from "path";
+async function globalSetup() {
+    const browser = await chromium.launch();
+    const page = await browser.newPage();
+    // Navigate to login and log in
+    await page.goto(process.env.PLAYWRIGHT_BASE_URL || "http://demoqa.com");
+    await page.getByPlaceholder("Email").fill("user@example.com");
+    await page.getByPlaceholder("Password").fill("SuperSecret123");
+    await page.getByRole("button", { name: "Login" }).click();
+    // Wait for navigation or some indicator that login is complete
+    await page.waitForURL("**/dashboard");
+    // Save session to file
+    await page
+        .context()
+        .storageState({ path: path.resolve(__dirname, "storageState.json") });
+    await browser.close();
+}
+export default globalSetup;

package/dist/custom_setups/loginHooks.d.ts

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

package/dist/custom_setups/loginHooks.js

@@ -0,0 +1,139 @@
+// 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";
+async function tryRestoreSession(world, sessionName) {
+    var _a;
+    const storagePath = path.resolve("e2e/support/helper/auth", `${sessionName}.json`);
+    if (fs.existsSync(storagePath)) {
+        await ((_a = world.context) === null || _a === void 0 ? void 0 : _a.addCookies([]));
+        await world.page.context().addInitScript(() => {
+            // preload logic if needed
+        });
+        await world.page.context().storageState({ path: storagePath });
+        world.log(`Session for ${sessionName} restored from file.`);
+        return true;
+    }
+    return false;
+}
+async function loginAndSaveSession(world, email, password, sessionName) {
+    const baseUrl = process.env.BASE_URL;
+    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`);
+    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 restored = await tryRestoreSession(this, sessionName);
+    if (!restored) {
+        await loginAndSaveSession(this, email, password, sessionName);
+    }
+};
+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();
+    }
+});
+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;
+    if (!baseUrl || !email || !password) {
+        console.warn("Missing base URL or credentials");
+        return;
+    }
+    await pageLogin(this, baseUrl, email, password);
+});
+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`);
+    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)) {
+        await this.context.addCookies([]); // optional reset
+        await this.context.addInitScript(() => { });
+        await this.context.storageState({ path: sessionFile });
+        this.log(`🗂️ Restored session from ${alias}User.json`);
+        // Wait for page to stabilize
+        await this.page.goto(baseUrl);
+        await this.page.waitForTimeout(1000);
+        const bodyText = await this.page.locator("body").innerText();
+        const url = this.page.url();
+        const looksLoggedOut = bodyText.match(/sign\s?in|login/i) || /login|signin/.test(url);
+        if (!looksLoggedOut) {
+            this.log("✅ Session is valid, no login required.");
+            return;
+        }
+        this.log("⚠️ Session appears invalid, re-logging in.");
+    }
+    // Perform login
+    await pageLogin(this, baseUrl, email, password);
+    await this.context.storageState({ path: sessionFile });
+    this.log(`💾 Saved session to ${alias}User.json`);
+});
+When("I perform login with:", async function (dataTable) {
+    var _a, _b, _c;
+    const loginData = Object.fromEntries(dataTable.raw());
+    const email = resolveLoginValue(loginData.email, this);
+    const password = (_a = resolveLoginValue(loginData.password, this)) !== null && _a !== void 0 ? _a : process.env.USER_PASSWORD;
+    if (!email)
+        throw new Error("Missing or invalid email for login");
+    if (!password)
+        throw new Error("Missing or invalid password for login");
+    (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, `🔐 Logging in with: ${email}`);
+    await this.page.goto(`${process.env.BASE_URL}/login`);
+    await this.page.waitForLoadState("networkidle");
+    await this.page.fill('input[type="email"]', email);
+    await this.page.fill('input[type="password"]', password);
+    const loginButton = this.page.getByRole("button", { name: /login/i });
+    await loginButton.click();
+    await this.page.waitForLoadState("networkidle");
+    (_c = this.log) === null || _c === void 0 ? void 0 : _c.call(this, "✅ Login successful");
+});
+async function pageLogin(world, baseUrl, email, password) {
+    var _a;
+    const { page } = world;
+    await page.goto(baseUrl);
+    await page.waitForLoadState("networkidle");
+    if (page.url().includes("/login")) {
+        await page.getByPlaceholder("email").fill(email);
+        await page.getByPlaceholder("password").fill(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");
+            await page.goto(`${baseUrl}/indicina`);
+        }
+        await 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"),
+        });
+        world.data["loggedIn"] = true;
+        (_a = world.log) === null || _a === void 0 ? void 0 : _a.call(world, "✅ Logged in and session saved.");
+    }
+    else {
+        console.log("Already logged in");
+    }
+}

package/dist/helpers/compareSnapshots.d.ts

@@ -0,0 +1,6 @@
+export declare function compareSnapshots({ actualPath, baselinePath, diffPath, threshold, }: {
+    actualPath: string;
+    baselinePath: string;
+    diffPath: string;
+    threshold?: number;
+}): number;

package/dist/helpers/compareSnapshots.js

@@ -0,0 +1,14 @@
+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));
+    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));
+    return numDiffPixels;
+}

package/dist/helpers/hooks.d.ts

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

package/dist/helpers/hooks.js

@@ -0,0 +1,148 @@
+// 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";
+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");
+let sharedBrowser;
+BeforeAll(async () => {
+    const dirsToClean = [
+        VIDEO_DIR,
+        SCREENSHOT_DIR,
+        SNAPSHOT_DIFF_DIR, // leave baseline snapshots intact
+    ];
+    for (const dir of dirsToClean) {
+        try {
+            if (fs.existsSync(dir)) {
+                fs.rmSync(dir, { recursive: true, force: true });
+                console.log(`🧹 Cleaned directory: ${dir}`);
+            }
+        }
+        catch (err) {
+            console.warn(`⚠️ Failed to clean directory ${dir}:`, err);
+        }
+    }
+    sharedBrowser = await chromium.launch({
+        headless: process.env.HEADLESS !== "false",
+    });
+    console.log("🚀 Launched shared browser for all scenarios");
+});
+AfterAll(async () => {
+    await (sharedBrowser === null || sharedBrowser === void 0 ? void 0 : sharedBrowser.close());
+    console.log("🧹 Closed shared browser after all scenarios");
+});
+Before(async function (scenario) {
+    var _a, _b;
+    // 🛡️ Ensure browser is still usable
+    if (!sharedBrowser || !sharedBrowser.isConnected()) {
+        console.warn("⚠️ Shared browser was disconnected. Restarting...");
+        sharedBrowser = await chromium.launch({
+            headless: process.env.HEADLESS !== "false",
+        });
+    }
+    const isMobile = scenario.pickle.tags.some((t) => t.name === "@mobile");
+    const isVisualTest = scenario.pickle.tags.some((t) => t.name === "@visual");
+    if (isVisualTest)
+        process.env.VISUAL_TEST = "true";
+    const contextOptions = {
+        recordVideo: { dir: VIDEO_DIR },
+        ...(isMobile ? devices["iPhone 13 Pro"] : {}),
+    };
+    if (fs.existsSync(SESSION_FILE)) {
+        contextOptions.storageState = SESSION_FILE;
+        (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, "✅ 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 (isMobile)
+        (_b = this.log) === null || _b === void 0 ? void 0 : _b.call(this, "📱 Mobile emulation enabled (iPhone 13 Pro)");
+});
+After(async function (scenario) {
+    var _a, _b, _c;
+    const failed = ((_a = scenario.result) === null || _a === void 0 ? void 0 : _a.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`);
+        try {
+            fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+            await this.page.screenshot({ path: screenshotPath, fullPage: true });
+            console.log(`🖼️ Screenshot saved: ${screenshotPath}`);
+        }
+        catch (err) {
+            console.warn("❌ Failed to save screenshot:", err);
+        }
+    }
+    // 🎥 Handle video recording
+    let rawPath;
+    try {
+        rawPath = await ((_c = (_b = this.page) === null || _b === void 0 ? void 0 : _b.video()) === null || _c === void 0 ? void 0 : _c.path());
+    }
+    catch (err) {
+        console.warn(`⚠️ Unable to access video path: ${err.message}`);
+    }
+    if (rawPath) {
+        try {
+            const finalPath = path.join(VIDEO_DIR, `failed-${name}.webm`);
+            fs.mkdirSync(VIDEO_DIR, { recursive: true });
+            if (failed) {
+                fs.renameSync(rawPath, finalPath);
+                console.log(`🎥 Video saved: ${finalPath}`);
+            }
+            else {
+                fs.unlinkSync(rawPath);
+                console.log(`🧹 Deleted video for passed test: ${rawPath}`);
+            }
+        }
+        catch (err) {
+            console.warn(`❌ Error handling video file: ${err.message}`);
+        }
+    }
+    // 🧪 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`);
+        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("❌ Error comparing snapshots:", err);
+            }
+        }
+    }
+    try {
+        if (this.context && this.page) {
+            await this.cleanup(scenario);
+        }
+    }
+    catch (err) {
+        console.warn("❌ Error during cleanup:", err);
+    }
+});

package/dist/helpers/world.js

@@ -17,7 +17,7 @@ export class CustomWorld extends World {
         };
     }
     async init(testInfo) {
-        const isMobile = testInfo?.pickle.tags.some((tag) => tag.name === "@mobile");
+        const isMobile = testInfo === null || testInfo === void 0 ? void 0 : 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({
@@ -25,32 +25,34 @@ export class CustomWorld extends World {
             recordVideo: { dir: "e2e/test-artifacts/videos" },
         });
         this.page = await this.context.newPage();
-        this.testName = testInfo?.pickle.name;
+        this.testName = testInfo === null || testInfo === void 0 ? void 0 : testInfo.pickle.name;
         this.log(`🧪 Initialized context${isMobile ? " (mobile)" : ""}`);
     }
     getScope() {
-        return this.frame ?? this.page;
+        var _a;
+        return (_a = this.frame) !== null && _a !== void 0 ? _a : this.page;
     }
     exitIframe() {
         this.frame = undefined;
         this.log("⬅️ Exited iframe, scope is now main page");
     }
     async cleanup(testInfo) {
-        const failed = testInfo?.result?.status === "FAILED";
+        var _a, _b, _c, _d;
+        const failed = ((_a = testInfo === null || testInfo === void 0 ? void 0 : testInfo.result) === null || _a === void 0 ? void 0 : _a.status) === "FAILED";
         try {
-            await this.page?.close();
+            await ((_b = this.page) === null || _b === void 0 ? void 0 : _b.close());
         }
         catch (err) {
             this.log(`⚠️ Error closing page: ${err.message}`);
         }
         try {
-            await this.context?.close();
+            await ((_c = this.context) === null || _c === void 0 ? void 0 : _c.close());
         }
         catch (err) {
             this.log(`⚠️ Error closing context: ${err.message}`);
         }
         try {
-            await this.browser?.close();
+            await ((_d = this.browser) === null || _d === void 0 ? void 0 : _d.close());
         }
         catch (err) {
             this.log(`⚠️ Error closing browser: ${err.message}`);

package/dist/iframes/frames.d.ts

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

package/dist/iframes/frames.js

@@ -0,0 +1,9 @@
+import { When } from "@cucumber/cucumber";
+When("I find href in iframe {string} and store as {string}", async function (iframeSelector, key) {
+    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/dist/index.d.ts

@@ -1,5 +1,28 @@
-export * from "./src/helpers/world";
-export * from "./src/helpers/utils";
-export * from "./src/helpers/hooks";
-export * from "./src/helpers/compareSnapshots";
-export type { CustomWorld } from "./src/helpers/world";
+export * from "./actions/cookieSteps";
+export * from "./actions/miscSteps";
+export * from "./actions/cookieSteps";
+export * from "./actions/clickSteps";
+export * from "./actions/debugSteps";
+export * from "./actions/elementFindSteps";
+export * from "./actions/inputSteps";
+export * from "./actions/mouseSteps";
+export * from "./actions/scrollSteps";
+export * from "./actions/storageSteps";
+export * from "./assertions/InterceptionRequests";
+export * from "./assertions/button_and_text_visibility";
+export * from "./assertions/cookieSteps";
+export * from "./assertions/elementSteps";
+export * from "./assertions/formInputSteps";
+export * from "./assertions/locationSteps";
+export * from "./assertions/roleTestIdSteps";
+export * from "./assertions/semanticSteps";
+export * from "./assertions/storageSteps";
+export * from "./assertions/InterceptionRequests";
+export * from "./custom_setups/loginHooks";
+export * from "./custom_setups/global-login";
+export * from "./iframes/frames";
+export * from "./helpers/utils";
+export * from "./helpers/world";
+export * from "./helpers/hooks";
+export * from "./helpers/compareSnapshots";
+export type { CustomWorld } from "./helpers/world";

package/dist/index.js

@@ -1,6 +1,29 @@
-// index.ts
+//src/index.ts
+export * from "./actions/cookieSteps";
+export * from "./actions/miscSteps";
+export * from "./actions/cookieSteps";
+export * from "./actions/clickSteps";
+export * from "./actions/debugSteps";
+export * from "./actions/elementFindSteps";
+export * from "./actions/inputSteps";
+export * from "./actions/mouseSteps";
+export * from "./actions/scrollSteps";
+export * from "./actions/storageSteps";
+export * from "./assertions/InterceptionRequests";
+export * from "./assertions/button_and_text_visibility";
+export * from "./assertions/cookieSteps";
+export * from "./assertions/elementSteps";
+export * from "./assertions/formInputSteps";
+export * from "./assertions/locationSteps";
+export * from "./assertions/roleTestIdSteps";
+export * from "./assertions/semanticSteps";
+export * from "./assertions/storageSteps";
+export * from "./assertions/InterceptionRequests";
+export * from "./custom_setups/loginHooks";
+export * from "./custom_setups/global-login";
+export * from "./iframes/frames";
 // Export core utilities and helpers
-export * from "./src/helpers/world";
-export * from "./src/helpers/utils";
-export * from "./src/helpers/hooks";
-export * from "./src/helpers/compareSnapshots";
+export * from "./helpers/utils";
+export * from "./helpers/world";
+export * from "./helpers/hooks";
+export * from "./helpers/compareSnapshots";

package/dist/register.d.ts

@@ -0,0 +1 @@
+import "./index";

package/dist/register.js

@@ -0,0 +1,2 @@
+// src/register.ts
+import "./index";

package/package.json

@@ -1,19 +1,13 @@
 {
   "name": "playwright-cucumber-ts-steps",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A collection of reusable Playwright step definitions for Cucumber in TypeScript, designed to streamline end-to-end testing across web, API, and mobile applications.",
   "type": "module",
-  "types": "dist/index.d.ts",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc"
   },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/qaPaschalE/playwright-cucumber-ts-steps.git"

package/index.ts

@@ -1,10 +0,0 @@
-// index.ts
-
-// Export core utilities and helpers
-export * from "./src/helpers/world";
-export * from "./src/helpers/utils";
-export * from "./src/helpers/hooks";
-export * from "./src/helpers/compareSnapshots";
-
-// Optionally expose types
-export type { CustomWorld } from "./src/helpers/world";

package/register.ts

@@ -1,31 +0,0 @@
-// src/register.ts
-import "./src/helpers/world.js";
-
-// Custom setups
-import "./custom_setups/global-login.js";
-import "./custom_setups/loginHooks.js";
-
-// Actions
-import "./actions/Interception & Requests.js";
-import "./actions/clickSteps.js";
-import "./actions/cookieSteps.js";
-import "./actions/debugSteps.js";
-import "./actions/elementFindSteps.js";
-import "./actions/inputSteps.js";
-import "./actions/mouseSteps.js";
-import "./actions/miscSteps.js";
-import "./actions/scrollSteps.js";
-import "./actions/storageSteps.js";
-
-// Assertions
-import "./assertions/button_and_text_visibility.js";
-import "./assertions/cookieSteps.js";
-import "./assertions/elementSteps.js";
-import "./assertions/formInputSteps.js";
-import "./assertions/locationSteps.js";
-import "./assertions/roleTestIdSteps.js";
-import "./assertions/semanticSteps.js";
-import "./assertions/storageSteps.js";
-
-// Iframes
-import "./iframes/frames.js";