playwright-cucumber-ts-steps 1.0.1 → 1.0.2

package/dist/backend/api/state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiState = void 0;
+// A simple storage to hold the response between the "When" and "Then" steps
+let lastResponse = null;
+exports.apiState = {
+    setResponse: (response) => {
+        lastResponse = response;
+    },
+    getResponse: () => {
+        if (!lastResponse)
+            throw new Error("No API response found. Did you run a 'When I make a request' step first?");
+        return lastResponse;
+    },
+};

package/dist/backend/assertions/expectVisible.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectVisible = expectVisible;
+async function expectVisible(page, selector, timeout = 2000) {
+    const el = await page.waitForSelector(selector, { state: 'visible', timeout });
+    if (!el)
+        throw new Error(`Element ${selector} not visible`);
+}

package/dist/backend/assertions/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./visibility");
+require("./text");
+require("./pageState");

package/dist/backend/assertions/pageState.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const registry_1 = require("../../core/registry");
+// URL Check
+(0, registry_1.Step)("I expect the url to be {string}", async (page, url) => {
+    await (0, test_1.expect)(page).toHaveURL(url);
+});
+// Partial URL Check
+(0, registry_1.Step)("I expect the url to contain {string}", async (page, part) => {
+    // We use a RegExp to allow partial matching safely
+    await (0, test_1.expect)(page).toHaveURL(new RegExp(part));
+});
+// Title Check
+(0, registry_1.Step)("I expect the title to be {string}", async (page, title) => {
+    await (0, test_1.expect)(page).toHaveTitle(title);
+});
+// Partial Title Check
+(0, registry_1.Step)("I expect the title to contain {string}", async (page, titlePart) => {
+    await (0, test_1.expect)(page).toHaveTitle(new RegExp(titlePart));
+});
+// Screenshot Match (Visual Regression)
+(0, registry_1.Step)("I expect the page screenshot to match {string}", async (page, filename) => {
+    await (0, test_1.expect)(page).toHaveScreenshot(filename);
+});

package/dist/backend/assertions/text.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const registry_1 = require("../../core/registry");
+// Exact text match
+(0, registry_1.Step)("I expect {string} to have text {string}", async (page, selector, text) => {
+    await (0, test_1.expect)(page.locator(selector)).toHaveText(text);
+});
+// Partial text match (contains)
+(0, registry_1.Step)("I expect {string} to contain text {string}", async (page, selector, text) => {
+    await (0, test_1.expect)(page.locator(selector)).toContainText(text);
+});
+// Check input value (for form fields)
+(0, registry_1.Step)("I expect {string} to have value {string}", async (page, selector, value) => {
+    await (0, test_1.expect)(page.locator(selector)).toHaveValue(value);
+});
+// Check an attribute (e.g., class, href, src)
+(0, registry_1.Step)("I expect {string} to have attribute {string} with value {string}", async (page, selector, attr, value) => {
+    await (0, test_1.expect)(page.locator(selector)).toHaveAttribute(attr, value);
+});

package/dist/backend/assertions/visibility.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const registry_1 = require("../../core/registry");
+// Check if element exists and is visible
+(0, registry_1.Step)("I expect {string} to be visible", async (page, selector) => {
+    await (0, test_1.expect)(page.locator(selector)).toBeVisible();
+});
+// Check if element is hidden (or doesn't exist)
+(0, registry_1.Step)("I expect {string} to be hidden", async (page, selector) => {
+    await (0, test_1.expect)(page.locator(selector)).toBeHidden();
+});
+// Check if element is enabled (clickable)
+(0, registry_1.Step)("I expect {string} to be enabled", async (page, selector) => {
+    await (0, test_1.expect)(page.locator(selector)).toBeEnabled();
+});
+// Check if element is disabled
+(0, registry_1.Step)("I expect {string} to be disabled", async (page, selector) => {
+    await (0, test_1.expect)(page.locator(selector)).toBeDisabled();
+});

package/dist/backend/auth/index.js

@@ -0,0 +1,71 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// 1. SAVE STATE (Use this after a successful login)
+// Example: And I save the browser state to "admin.json"
+(0, registry_1.Step)("I save the browser state to {string}", async (page, filename) => {
+    // Ensure the directory exists
+    const authDir = path.resolve(process.cwd(), "auth");
+    if (!fs.existsSync(authDir)) {
+        fs.mkdirSync(authDir);
+    }
+    const filePath = path.resolve(authDir, filename);
+    await page.context().storageState({ path: filePath });
+    console.log(`✅ State saved to: ${filePath}`);
+});
+// 2. LOAD STATE (Use this at the start of other scenarios)
+// Example: Given I load the browser state from "admin.json"
+(0, registry_1.Step)("I load the browser state from {string}", async (page, filename) => {
+    const filePath = path.resolve(process.cwd(), "auth", filename);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`❌ Auth file not found at: ${filePath}. Did you run the login scenario first?`);
+    }
+    // Playwright normally loads state at context creation.
+    // To load it dynamically mid-test, we need to add cookies/origins to the current context.
+    const state = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (state.cookies) {
+        await page.context().addCookies(state.cookies);
+    }
+    if (state.origins) {
+        // LocalStorage requires a bit more work, usually handled by context creation,
+        // but adding cookies is often enough for 90% of apps.
+        // For full local storage support, users should configure this in playwright.config.ts
+        // but this step is a great dynamic helper.
+    }
+    console.log(`✅ Loaded session for: ${filename}`);
+});

package/dist/backend/elements/alerts.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+// Accept the next popup (Alert/Confirm/Prompt)
+(0, registry_1.Step)("I accept the next dialog", async (page) => {
+    page.once("dialog", async (dialog) => {
+        await dialog.accept();
+    });
+});
+// Dismiss (Cancel) the next popup
+(0, registry_1.Step)("I dismiss the next dialog", async (page) => {
+    page.once("dialog", async (dialog) => {
+        await dialog.dismiss();
+    });
+});
+// Type text into a prompt and accept
+(0, registry_1.Step)("I type {string} into the next prompt and accept", async (page, text) => {
+    page.once("dialog", async (dialog) => {
+        await dialog.accept(text);
+    });
+});

package/dist/backend/elements/forms.js

@@ -0,0 +1,59 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const path = __importStar(require("path"));
+// Dropdown: Select by value or label
+(0, registry_1.Step)("I select option {string} from {string}", async (page, option, selector) => {
+    await page.selectOption(selector, { label: option }).catch(() => {
+        // Fallback: try selecting by value if label fails
+        return page.selectOption(selector, { value: option });
+    });
+});
+// Checkboxes & Radio Buttons
+(0, registry_1.Step)("I check {string}", async (page, selector) => {
+    await page.check(selector);
+});
+(0, registry_1.Step)("I uncheck {string}", async (page, selector) => {
+    await page.uncheck(selector);
+});
+// File Upload
+// Usage: When I upload file "data.csv" to "#upload-input"
+(0, registry_1.Step)("I upload file {string} to {string}", async (page, fileName, selector) => {
+    // We assume the user puts files in a 'fixtures' or root folder.
+    // You might want to customize this path resolution.
+    const filePath = path.resolve(process.cwd(), fileName);
+    await page.setInputFiles(selector, filePath);
+});

package/dist/backend/elements/frames.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+// Click inside a specific frame
+(0, registry_1.Step)("I click {string} inside frame {string}", async (page, elementSelector, frameSelector) => {
+    const frame = page.frameLocator(frameSelector);
+    await frame.locator(elementSelector).click();
+});
+// Fill input inside a specific frame
+(0, registry_1.Step)("I fill {string} inside frame {string} with {string}", async (page, elementSelector, frameSelector, value) => {
+    const frame = page.frameLocator(frameSelector);
+    await frame.locator(elementSelector).fill(value);
+});
+// Assert text inside a specific frame
+(0, registry_1.Step)("I expect {string} inside frame {string} to have text {string}", async (page, elementSelector, frameSelector, text) => {
+    const frame = page.frameLocator(frameSelector);
+    const locator = frame.locator(elementSelector);
+    // We need to import expect for this assertion, or use a custom check
+    // Since we are inside 'elements', let's just do a basic wait/check or re-export expect
+    await locator.waitFor();
+    const actualText = await locator.textContent();
+    if (!actualText?.includes(text)) {
+        throw new Error(`Expected text "${text}" but found "${actualText}" in frame`);
+    }
+});

package/dist/backend/elements/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./forms");
+require("./alerts");
+require("./frames");

package/dist/core/registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepRegistry = void 0;
+exports.Step = Step;
+// src/core/registry.ts
+const cucumber_expressions_1 = require("@cucumber/cucumber-expressions");
+// 2. The Global Registry
+// This array stores every step you create in the backend folder
+exports.stepRegistry = [];
+const parameterTypeRegistry = new cucumber_expressions_1.ParameterTypeRegistry();
+// 3. The Function to Register Steps
+// You will use this inside src/backend/actions/...
+function Step(pattern, fn) {
+    const expression = new cucumber_expressions_1.CucumberExpression(pattern, parameterTypeRegistry);
+    exports.stepRegistry.push({
+        expression,
+        fn,
+        pattern,
+    });
+}

package/dist/core/runner.js

@@ -0,0 +1,136 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTests = runTests;
+// src/core/runner.ts
+const test_1 = require("@playwright/test");
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+const registry_1 = require("./registry");
+// LOAD BACKEND LIBRARIES
+require("../backend/actions/index");
+require("../backend/assertions/index");
+require("../backend/elements/index");
+require("../backend/api/index");
+require("../backend/auth/index");
+/**
+ * The main test runner. Parses feature files and executes them as Playwright tests.
+ * * @param featureGlob - Glob pattern to find feature files (e.g., 'features/*.feature')
+ * @param options - Configuration options for filtering tags
+ * * @example
+ * ```ts
+ * // Run all features
+ * runTests('features/*.feature');
+ * * // Run only @smoke tests
+ * runTests('features/*.feature', { tags: '@smoke' });
+ * ```
+ */
+function runTests(featureGlob, options) {
+    const files = (0, glob_1.globSync)(featureGlob);
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf8");
+        const featureMatch = content.match(/Feature:\s*(.+)/);
+        const featureName = featureMatch
+            ? featureMatch[1].trim()
+            : "Unnamed Feature";
+        test_1.test.describe(featureName, () => {
+            const scenarioRegex = /(?:(@[\w\s@]+)\s+)?Scenario:\s*(.+)/g;
+            let match;
+            while ((match = scenarioRegex.exec(content)) !== null) {
+                // 1. CAPTURE DATA IMMEDIATELY
+                // We calculate everything here so we don't rely on 'match' later
+                const foundTags = match[1] || "";
+                const scenarioName = match[2].trim();
+                const startIndex = match.index + match[0].length;
+                const nextMatchIndex = content.slice(startIndex).search(/Scenario:/);
+                const blockEnd = nextMatchIndex === -1 ? content.length : startIndex + nextMatchIndex;
+                // This variable 'scenarioBlock' is now safe to use inside the test
+                const scenarioBlock = content.slice(startIndex, blockEnd);
+                if (options?.tags && !foundTags.includes(options.tags)) {
+                    continue;
+                }
+                (0, test_1.test)(scenarioName, async ({ page }, testInfo) => {
+                    // 1. Calculate the scenario block (Same as before)
+                    const lines = scenarioBlock
+                        .trim()
+                        .split("\n")
+                        .map((l) => l.trim())
+                        .filter((l) => l);
+                    for (const stepText of lines) {
+                        if (stepText.startsWith("#") ||
+                            stepText.startsWith("@") ||
+                            stepText === "")
+                            continue;
+                        const cleanStep = stepText.replace(/^(Given|When|Then|And|But)\s+/i, "");
+                        const stepDef = findMatchingStep(cleanStep);
+                        if (!stepDef) {
+                            throw new Error(`❌ Undefined Step: "${cleanStep}"`);
+                        }
+                        // 2. ERROR HANDLING WRAPPER
+                        try {
+                            // Execute the step
+                            await stepDef.fn(page, ...stepDef.args);
+                        }
+                        catch (error) {
+                            // 3. CAPTURE EVIDENCE ON FAILURE
+                            console.error(`❌ Failed at step: "${stepText}"`);
+                            // Take a screenshot immediately
+                            const screenshot = await page.screenshot({
+                                fullPage: true,
+                                type: "png",
+                            });
+                            // Attach it to the report (HTML/JSON/Slack will pick this up)
+                            await testInfo.attach("failure-screenshot", {
+                                body: screenshot,
+                                contentType: "image/png",
+                            });
+                            // Re-throw the error so the test is marked as Failed
+                            throw error;
+                        }
+                    }
+                });
+            }
+        });
+    }
+}
+function findMatchingStep(text) {
+    for (const step of registry_1.stepRegistry) {
+        const match = step.expression.match(text);
+        if (match) {
+            return { fn: step.fn, args: match.map((arg) => arg.getValue(null)) };
+        }
+    }
+    return null;
+}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReporters = exports.Step = exports.runTests = void 0;
+// src/index.ts
+var runner_1 = require("./core/runner");
+Object.defineProperty(exports, "runTests", { enumerable: true, get: function () { return runner_1.runTests; } });
+var registry_1 = require("./core/registry"); // Export this in case users want to add custom steps
+Object.defineProperty(exports, "Step", { enumerable: true, get: function () { return registry_1.Step; } });
+var index_1 = require("./reporting/index");
+Object.defineProperty(exports, "getReporters", { enumerable: true, get: function () { return index_1.getReporters; } });

package/dist/reporting/index.js

@@ -0,0 +1,43 @@
+"use strict";
+// src/reporting/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReporters = getReporters;
+/**
+ * Helper to generate Playwright Reporter configuration.
+ * * @param options - Select which reporters to enable ('html', 'slack', etc.)
+ * @returns An array suitable for the 'reporter' field in playwright.config.ts
+ */
+function getReporters(options) {
+    const reporters = [];
+    // 1. ALWAYS ADD LIST (So they see progress in terminal)
+    reporters.push(["list"]);
+    // 2. HTML REPORTER (Priority 1)
+    if (options.on.includes("html")) {
+        reporters.push([
+            "html",
+            { open: "on-failure", outputFolder: "playwright-report" },
+        ]);
+    }
+    // 3. JSON REPORTER (Useful for CI)
+    if (options.on.includes("json")) {
+        reporters.push(["json", { outputFile: "results.json" }]);
+    }
+    // 4. SLACK REPORTER (Requires external package)
+    if (options.on.includes("slack")) {
+        if (!options.slackWebhookUrl) {
+            console.warn("⚠️ Slack reporter requested but no Webhook URL provided.");
+        }
+        else {
+            // We assume the user has installed 'playwright-slack-report'
+            // We return the config string that Playwright expects
+            reporters.push([
+                "playwright-slack-report",
+                {
+                    sendResults: "always", // 'always' | 'on-failure' | 'off'
+                    slackWebHookUrl: options.slackWebhookUrl,
+                },
+            ]);
+        }
+    }
+    return reporters;
+}

package/package.json

@@ -1,113 +1,31 @@
 {
   "name": "playwright-cucumber-ts-steps",
-  "version": "1.0.1",
-  "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": "commonjs",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "exports": {
-    ".": {
-      "import": "./lib/index.js"
-    },
-    "./register": {
-      "import": "./lib/register.js"
-    }
-  },
-  "sideEffects": false,
-  "typesVersions": {
-    "*": {
-      "*": [
-        "lib/*"
-      ]
-    }
-  },
+  "version": "1.0.2",
+  "private": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "docs": "typedoc",
-    "docs:deploy": "gh-pages -d temp-docs",
-    "prepare": "husky",
-    "lint": "eslint . --ext .ts",
-    "lint:fix": "eslint . --ext .ts --fix",
-    "lint:tsc": "tsc --noEmit",
-    "format": "prettier --write .",
-    "clean": "rm -rf playwright/report",
-    "test": "npm run clean && cucumber-js --config playwright/config/cucumber.js",
-    "commitlint": "commitlint --edit"
-  },
-  "lint-staged": {
-    "*.{js,ts,tsx,json,md}": [
-      "eslint --fix",
-      "prettier --write"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
+    "prepublishOnly": "npm run build"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/qaPaschalE/playwright-cucumber-ts-steps.git"
-  },
-  "keywords": [
-    "playwright",
-    "cucumber",
-    "typescript",
-    "e2e",
-    "steps",
-    "step-definitions",
-    "testing",
-    "automation",
-    "bdd",
-    "api",
-    "ui",
-    "web",
-    "end-to-end",
-    "behavior-driven",
-    "mobile",
-    "visual-testing"
-  ],
-  "author": "qaPaschalE <paschal.enyimiri@gmail.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/qaPaschalE/playwright-cucumber-ts-steps/issues"
+  "dependencies": {
+    "@cucumber/cucumber-expressions": "^17.1.0",
+    "@cucumber/gherkin": "^27.0.0",
+    "@cucumber/messages": "^22.0.0",
+    "glob": "^10.3.10"
   },
-  "homepage": "https://github.com/qaPaschalE/playwright-cucumber-ts-steps#readme",
   "peerDependencies": {
-    "@cucumber/cucumber": "*",
-    "@playwright/test": "*"
-  },
-  "files": [
-    "lib/",
-    "src/"
-  ],
-  "dependencies": {
-    "@cucumber/tag-expressions": "^6.2.0",
-    "@faker-js/faker": "^9.8.0",
-    "dayjs": "^1.11.13",
-    "dotenv-cli": "^8.0.0",
-    "glob": "^11.0.3",
-    "parse": "^6.1.1",
-    "pixelmatch": "^7.1.0",
-    "pngjs": "^7.0.0"
+    "@playwright/test": "^1.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
-    "@types/pngjs": "^6.0.5",
-    "eslint": "^9.29.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-import": "^2.32.0",
-    "gh-pages": "^6.3.0",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.1.2",
-    "prettier": "^3.5.3",
-    "ts-node": "^10.9.2",
-    "typedoc": "^0.28.5",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.34.1"
+    "@playwright/test": "^1.41.0",
+    "@types/glob": "^8.1.0",
+    "@types/node": "^20.11.0",
+    "typedoc": "^0.28.15",
+    "typescript": "^5.3.3"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Chetachi (Paschal) Enyimiri 
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.