playwright-cucumber-ts-steps 1.1.6 → 1.1.8

package/dist/backend/assertions/pageState.js

@@ -2,24 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const test_1 = require("@playwright/test");
 const registry_1 = require("../../core/registry");
-// URL Check
+/**
+ * Checks if the URL contains a specific string.
+ * Pattern: Then I expect the url to contain "dashboard"
+ */
+(0, registry_1.Step)("I expect the url to contain {string}", async (page, part) => {
+    await (0, test_1.expect)(page).toHaveURL(new RegExp(part));
+    console.log(`✅ URL contains "${part}"`);
+});
+/**
+ * Checks if the URL is an exact match.
+ * Pattern: Then I expect the url to be "https://google.com"
+ */
 (0, registry_1.Step)("I expect the url to be {string}", async (page, url) => {
     await (0, test_1.expect)(page).toHaveURL(url);
+    console.log(`✅ URL is "${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));
+/**
+ * Checks if the page title contains a string.
+ * Pattern: Then I expect the title to contain "Welcome"
+ */
+(0, registry_1.Step)("I expect the title to contain {string}", async (page, part) => {
+    await (0, test_1.expect)(page).toHaveTitle(new RegExp(part));
+    console.log(`✅ Title contains "${part}"`);
 });
-// Title Check
+/**
+ * Checks if the page title is an exact match.
+ * Pattern: Then I expect the title to be "Welcome Page"
+ */
 (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);
+    console.log(`✅ Title is "${title}"`);
 });

package/dist/backend/assertions/visibility.js

@@ -2,19 +2,123 @@
 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();
+const state_1 = require("../utils/state");
+// ===============================
+// 1. VISIBILITY & STATE CHECKS
+// ===============================
+/**
+ * Checks if the stored element is visible.
+ * Pattern: Then I expect element to be visible
+ */
+(0, registry_1.Step)("I expect element to be visible", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toBeVisible();
+    console.log("✅ Element is visible");
 });
-// 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();
+/**
+ * Checks if the stored element is hidden.
+ * Pattern: Then I expect element to be hidden
+ */
+(0, registry_1.Step)("I expect element to be hidden", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toBeHidden();
+    console.log("✅ Element is hidden");
 });
-// 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();
+/**
+ * Checks if the stored element is enabled.
+ * Pattern: Then I expect element to be enabled
+ */
+(0, registry_1.Step)("I expect element to be enabled", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toBeEnabled();
+    console.log("✅ Element is enabled");
 });
-// 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();
+/**
+ * Checks if the stored element is disabled.
+ * Pattern: Then I expect element to be disabled
+ */
+(0, registry_1.Step)("I expect element to be disabled", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toBeDisabled();
+    console.log("✅ Element is disabled");
+});
+// ===============================
+// 2. TEXT & VALUE CHECKS
+// ===============================
+/**
+ * Checks if the element contains exact text.
+ * Pattern: Then I expect element to have text "Submit"
+ */
+(0, registry_1.Step)("I expect element to have text {string}", async (page, text) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toHaveText(text);
+    console.log(`✅ Element has text "${text}"`);
+});
+/**
+ * Checks if the element contains partial text.
+ * Pattern: Then I expect element to contain text "Sub"
+ */
+(0, registry_1.Step)("I expect element to contain text {string}", async (page, text) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toContainText(text);
+    console.log(`✅ Element contains text "${text}"`);
+});
+/**
+ * Checks if the element has a specific input value.
+ * Pattern: Then I expect element to have value "123"
+ */
+(0, registry_1.Step)("I expect element to have value {string}", async (page, value) => {
+    // Support aliases (e.g. @myVar)
+    if (value.startsWith("@")) {
+        const alias = value.slice(1);
+        const stored = (0, state_1.getVariable)(page, alias);
+        if (!stored)
+            throw new Error(`Alias @${alias} not found`);
+        value = stored;
+    }
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toHaveValue(value);
+    console.log(`✅ Element has value "${value}"`);
+});
+// ===============================
+// 3. ATTRIBUTE CHECKS
+// ===============================
+/**
+ * Checks if the element has a specific attribute.
+ * Pattern: Then I expect element to have attribute "data-test"
+ */
+(0, registry_1.Step)("I expect element to have attribute {string}", async (page, attr) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toHaveAttribute(attr);
+    console.log(`✅ Element has attribute "${attr}"`);
+});
+/**
+ * Checks if the element has a specific attribute value.
+ * Pattern: Then I expect element to have attribute "type" with value "submit"
+ */
+(0, registry_1.Step)("I expect element to have attribute {string} with value {string}", async (page, attr, value) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toHaveAttribute(attr, value);
+    console.log(`✅ Element has attribute "${attr}" = "${value}"`);
+});
+// ===============================
+// 4. VISUAL REGRESSION (Screenshots)
+// ===============================
+/**
+ * Verifies the ENTIRE page matches a stored screenshot.
+ * Pattern: Then I expect the page screenshot to match "home-page.png"
+ * Note: Screenshots are stored in 'tests/{feature-name}/' folder by default.
+ */
+(0, registry_1.Step)("I expect the page screenshot to match {string}", async (page, filename) => {
+    await (0, test_1.expect)(page).toHaveScreenshot(filename);
+    console.log(`📸 Page matches screenshot: ${filename}`);
+});
+/**
+ * Verifies the CURRENT ELEMENT matches a stored screenshot.
+ * Pattern: Then I expect the element screenshot to match "submit-btn.png"
+ */
+(0, registry_1.Step)("I expect the element screenshot to match {string}", async (page, filename) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await (0, test_1.expect)(element).toHaveScreenshot(filename);
+    console.log(`📸 Element matches screenshot: ${filename}`);
 });

package/dist/backend/utils/state.d.ts

@@ -0,0 +1,18 @@
+import { Page, Locator } from "@playwright/test";
+export declare function setActiveElement(page: Page, element: Locator): void;
+export declare function getActiveElement(page: Page): Locator;
+export declare function setActiveElements(page: Page, elements: Locator): void;
+export declare function getActiveElements(page: Page): Locator;
+export declare function setVariable(page: Page, key: string, value: any): void;
+export declare function getVariable(page: Page, key: string): any;
+export declare function parseClickOptions(table: any): {
+    force?: boolean;
+    button?: "left" | "right" | "middle";
+    modifiers?: Array<"Alt" | "Control" | "Meta" | "Shift">;
+    position?: {
+        x: number;
+        y: number;
+    };
+    timeout?: number;
+};
+//# sourceMappingURL=state.d.ts.map

package/dist/backend/utils/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/backend/utils/state.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,QAE5D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAQpD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,QAE9D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAMrD;AAID,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,QAK9D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAGxD;AAKD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrC,SAAS,CAAC,EAAE,KAAK,CAAC,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACxD,QAAQ,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAwCA"}

package/dist/backend/utils/state.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setActiveElement = setActiveElement;
+exports.getActiveElement = getActiveElement;
+exports.setActiveElements = setActiveElements;
+exports.getActiveElements = getActiveElements;
+exports.setVariable = setVariable;
+exports.getVariable = getVariable;
+exports.parseClickOptions = parseClickOptions;
+// 1. STATE MANAGEMENT
+// We attach data to the Playwright Page object so it persists between steps.
+function setActiveElement(page, element) {
+    page.__bdd_element = element;
+}
+function getActiveElement(page) {
+    const el = page.__bdd_element;
+    if (!el) {
+        throw new Error("❌ No stored element found. Did you forget a 'When I find...' step?");
+    }
+    return el;
+}
+function setActiveElements(page, elements) {
+    page.__bdd_elements = elements;
+}
+function getActiveElements(page) {
+    const els = page.__bdd_elements;
+    if (!els) {
+        throw new Error("❌ No stored elements list found.");
+    }
+    return els;
+}
+// 2. DATA / ALIAS MANAGEMENT (for @variable support)
+function setVariable(page, key, value) {
+    if (!page.__bdd_data) {
+        page.__bdd_data = {};
+    }
+    page.__bdd_data[key] = value;
+}
+function getVariable(page, key) {
+    const data = page.__bdd_data;
+    return data ? data[key] : undefined;
+}
+// 3. OPTION PARSERS
+// Converts Gherkin DataTables into Playwright ClickOptions
+function parseClickOptions(table) {
+    if (!table)
+        return {};
+    let hash = {};
+    // Handle Cucumber DataTable object (legacy) or raw Array
+    if (typeof table.rowsHash === "function") {
+        hash = table.rowsHash();
+    }
+    else if (Array.isArray(table)) {
+        // Convert Array of Arrays [['force', 'true']] to Object { force: 'true' }
+        table.forEach((row) => {
+            if (Array.isArray(row) && row.length >= 2) {
+                hash[row[0].toString()] = row[1].toString();
+            }
+        });
+    }
+    else {
+        return {};
+    }
+    const options = {};
+    // Parse specific boolean/number values
+    if (hash["force"] === "true")
+        options.force = true;
+    if (hash["button"])
+        options.button = hash["button"];
+    if (hash["timeout"])
+        options.timeout = parseInt(hash["timeout"], 10);
+    // Handle modifiers (comma separated)
+    if (hash["modifiers"]) {
+        options.modifiers = hash["modifiers"].split(",").map((m) => m.trim());
+    }
+    // Handle position (x,y)
+    if (hash["x"] && hash["y"]) {
+        options.position = {
+            x: parseInt(hash["x"], 10),
+            y: parseInt(hash["y"], 10),
+        };
+    }
+    return options;
+}

package/dist/core/registry.d.ts

@@ -1,23 +1,23 @@
 import { CucumberExpression } from "@cucumber/cucumber-expressions";
 import { Page } from "@playwright/test";
 /**
- * Registers a new Step Definition.
- * * @param pattern - The Gherkin pattern (e.g., 'I click {string}')
- * @param fn - The async function to execute. It receives the Playwright Page object as the first argument.
- * * @example
- * ```ts
- * Step('I scroll to bottom', async (page) => {
- * await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
- * });
- * ```
+ * Define the type of function for our steps.
+ * Every step automatically gets 'page' as the first argument.
  */
 export type StepAction = (page: Page, ...args: any[]) => Promise<void>;
-interface StepDefinition {
-    expression: CucumberExpression;
+/**
+ * 1. StepDefinition Interface
+ * Updated to allow both CucumberExpression (legacy) AND RegExp (standard)
+ */
+export interface StepDefinition {
+    expression: CucumberExpression | RegExp;
     fn: StepAction;
-    pattern: string;
+    pattern: string | RegExp;
 }
 export declare const stepRegistry: StepDefinition[];
-export declare function Step(pattern: string, fn: StepAction): void;
-export {};
+/**
+ * 3. The Function to Register Steps
+ * Supports passing a string (converted to CucumberExpression) OR a direct RegExp.
+ */
+export declare function Step(pattern: string | RegExp, fn: StepAction): void;
 //# sourceMappingURL=registry.d.ts.map

package/dist/core/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/core/registry.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAEnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC;;;;;;;;;;GAUG;AAGH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE,UAAU,cAAc;IACtB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,EAAE,EAAE,UAAU,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,eAAO,MAAM,YAAY,EAAE,cAAc,EAAO,CAAC;AAMjD,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,QAQnD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/core/registry.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAEnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAAC;IACxC,EAAE,EAAE,UAAU,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B;AAGD,eAAO,MAAM,YAAY,EAAE,cAAc,EAAO,CAAC;AAIjD;;;GAGG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,EAAE,UAAU,QAgB5D"}

package/dist/core/registry.js

@@ -5,13 +5,22 @@ 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/...
+/**
+ * 3. The Function to Register Steps
+ * Supports passing a string (converted to CucumberExpression) OR a direct RegExp.
+ */
 function Step(pattern, fn) {
-    const expression = new cucumber_expressions_1.CucumberExpression(pattern, parameterTypeRegistry);
+    let expression;
+    if (pattern instanceof RegExp) {
+        // ✅ If it's a Regex, use it directly (Faster, Standard)
+        expression = pattern;
+    }
+    else {
+        // ⚠️ If it's a String, convert to Cucumber Expression (Legacy)
+        expression = new cucumber_expressions_1.CucumberExpression(pattern, parameterTypeRegistry);
+    }
     exports.stepRegistry.push({
         expression,
         fn,

package/dist/core/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAMA,OAAO,0BAA0B,CAAC;AAClC,OAAO,6BAA6B,CAAC;AACrC,OAAO,2BAA2B,CAAC;AACnC,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAE/B,OAAO,qBAAqB,CAAC;AAE7B,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC3C;AAED,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,QAyIpE"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAMA,OAAO,0BAA0B,CAAC;AAClC,OAAO,6BAA6B,CAAC;AACrC,OAAO,2BAA2B,CAAC;AACnC,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAE/B,OAAO,qBAAqB,CAAC;AAE7B,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC3C;AASD,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,QA6LpE"}

package/dist/core/runner.js

@@ -58,7 +58,6 @@ function runTests(featureGlob, options) {
     for (const file of files) {
         const content = fs.readFileSync(file, "utf8");
         // 1. CAPTURE FEATURE TAGS
-        // Loose Regex: Matches any lines starting with @ above "Feature:"
         const featureTagMatch = content.match(/((?:@\S+\s*)+)Feature:/);
         const rawFeatureTags = featureTagMatch ? featureTagMatch[1] : "";
         const featureTags = rawFeatureTags.replace(/[\r\n]+/g, " ").trim();
@@ -67,9 +66,8 @@ function runTests(featureGlob, options) {
             ? featureMatch[1].trim()
             : "Unnamed Feature";
         test_1.test.describe(featureName, () => {
-            // 2. LOOSE SCENARIO REGEX
+            // 2. SCENARIO REGEX
             // Matches: Optional Tags -> (Scenario OR Scenario Outline) -> Name
-            // Change: @\S+ allows dots/dashes. "Scenario|Scenario Outline" supports outlines.
             const scenarioRegex = /(?:((?:@\S+\s*)+))?(?:Scenario|Scenario Outline):\s*(.+)/g;
             let match;
             let foundCount = 0;
@@ -83,9 +81,7 @@ function runTests(featureGlob, options) {
                 const fullName = combinedTags
                     ? `${scenarioName} ${combinedTags}`
                     : scenarioName;
-                // DEBUG LOG: See what we found
-                // console.log(`   👉 Found: "${scenarioName}" [Tags: ${combinedTags}]`);
-                // 4. ENV FILTERING (Optional)
+                // 4. ENV FILTERING
                 const activeFilter = options?.tags || envTag;
                 if (activeFilter) {
                     const targetGroups = activeFilter.split(",").map((t) => t.trim());
@@ -96,6 +92,7 @@ function runTests(featureGlob, options) {
                     if (!isMatch)
                         continue;
                 }
+                // 5. EXTRACT SCENARIO BLOCK
                 const startIndex = match.index + match[0].length;
                 const nextMatchIndex = content
                     .slice(startIndex)
@@ -103,43 +100,91 @@ function runTests(featureGlob, options) {
                 const blockEnd = nextMatchIndex === -1 ? content.length : startIndex + nextMatchIndex;
                 const scenarioBlock = content.slice(startIndex, blockEnd);
                 (0, test_1.test)(fullName, async ({ page }, testInfo) => {
-                    const lines = scenarioBlock
-                        .trim()
-                        .split("\n")
-                        .map((l) => l.trim())
-                        .filter((l) => l);
-                    for (let i = 0; i < lines.length; i++) {
-                        const stepText = lines[i];
-                        if (stepText.startsWith("#") ||
-                            stepText.startsWith("@") ||
-                            stepText === "")
+                    // ==================================================
+                    // PHASE 1: PARSE GHERKIN (Preserve Formatting)
+                    // ==================================================
+                    const rawLines = scenarioBlock.split("\n");
+                    const steps = [];
+                    let currentStep = null;
+                    let docStringBuffer = [];
+                    let isDocStringOpen = false;
+                    for (let line of rawLines) {
+                        const trimmedLine = line.trim();
+                        // A. Handle DocStrings (""")
+                        if (trimmedLine.startsWith('"""')) {
+                            isDocStringOpen = !isDocStringOpen;
+                            if (!isDocStringOpen && currentStep) {
+                                // Closing DocString: Save buffer to step
+                                currentStep.docString = docStringBuffer.join("\n");
+                                docStringBuffer = [];
+                            }
                             continue;
-                        // Handle Data Tables
-                        const tableData = [];
-                        while (i + 1 < lines.length && lines[i + 1].startsWith("|")) {
-                            i++;
-                            const row = lines[i]
-                                .split("|")
-                                .map((cell) => cell.trim())
-                                .filter((cell) => cell !== "");
-                            tableData.push(row);
                         }
-                        const cleanStep = stepText
+                        // B. Inside DocString? Capture raw line (preserve indent)
+                        if (isDocStringOpen) {
+                            docStringBuffer.push(line); // Don't trim!
+                            continue;
+                        }
+                        // C. Skip Empty Lines & Comments
+                        if (!trimmedLine ||
+                            trimmedLine.startsWith("#") ||
+                            trimmedLine.startsWith("@")) {
+                            continue;
+                        }
+                        // D. Handle Data Tables (| col | col |)
+                        if (trimmedLine.startsWith("|")) {
+                            if (currentStep) {
+                                if (!currentStep.dataTable)
+                                    currentStep.dataTable = [];
+                                const row = trimmedLine
+                                    .split("|")
+                                    .map((cell) => cell.trim())
+                                    .filter((cell, index, arr) => index > 0 && index < arr.length - 1);
+                                // Simple split often leaves empty strings at start/end
+                                // Better split logic:
+                                const cleanRow = trimmedLine
+                                    .split("|")
+                                    .slice(1, -1) // Remove first and last empty splits from |...|
+                                    .map((c) => c.trim());
+                                currentStep.dataTable.push(cleanRow);
+                            }
+                            continue;
+                        }
+                        // E. It is a New Step
+                        const cleanText = trimmedLine
                             .replace(/^(Given|When|Then|And|But)\s+/i, "")
-                            .replace(/:$/, "")
+                            .replace(/:$/, "") // Remove trailing colon
                             .trim();
-                        const matchResult = findMatchingStep(cleanStep);
+                        currentStep = {
+                            text: trimmedLine,
+                            cleanText: cleanText,
+                        };
+                        steps.push(currentStep);
+                    }
+                    // ==================================================
+                    // PHASE 2: EXECUTE STEPS
+                    // ==================================================
+                    console.log(`\n🔹 Scenario: ${scenarioName}`);
+                    for (const step of steps) {
+                        const matchResult = findMatchingStep(step.cleanText);
                         if (!matchResult) {
-                            throw new Error(`❌ Undefined Step: "${cleanStep}"`);
+                            throw new Error(`❌ Undefined Step: "${step.cleanText}"`);
                         }
                         try {
+                            console.log(`   executing: ${step.text.trim()}`);
                             const args = [...matchResult.args];
-                            if (tableData.length > 0)
-                                args.push(tableData);
+                            // Append Data Table if present
+                            if (step.dataTable && step.dataTable.length > 0) {
+                                args.push(step.dataTable);
+                            }
+                            // Append DocString if present
+                            if (step.docString) {
+                                args.push(step.docString);
+                            }
                             await matchResult.fn(page, ...args);
                         }
                         catch (error) {
-                            console.error(`❌ Failed at step: "${stepText}"`);
+                            console.error(`❌ Failed at step: "${step.text.trim()}"`);
                             const screenshot = await page.screenshot({
                                 fullPage: true,
                                 type: "png",
@@ -153,32 +198,41 @@ function runTests(featureGlob, options) {
                     }
                 });
             }
-            // SAFETY CHECK
             if (foundCount === 0) {
                 console.warn(`⚠️  File matched but 0 Scenarios found in: ${file}`);
-                console.warn(`   Check if you are using 'Scenario Outline' or strange spacing.`);
             }
         });
     }
 }
+/**
+ * Finds the matching step definition from the registry.
+ * Supports: RegExp (with capture groups) and CucumberExpressions.
+ */
 function findMatchingStep(text) {
     for (const step of registry_1.stepRegistry) {
+        // 1. RegExp Match
         if (step.expression instanceof RegExp) {
             const match = step.expression.exec(text);
-            if (match)
+            if (match) {
+                // match[0] is full string, slice(1) are capture groups
                 return { fn: step.fn, args: match.slice(1) };
+            }
         }
+        // 2. Cucumber Expression Match (if strictly typed)
         else if (typeof step.expression.match === "function") {
             const match = step.expression.match(text);
-            if (match)
+            if (match) {
                 return {
                     fn: step.fn,
                     args: match.map((arg) => arg.getValue(null)),
                 };
+            }
         }
+        // 3. String Match (Legacy/Simple)
         else if (typeof step.expression === "string") {
-            if (step.expression === text)
+            if (step.expression === text) {
                 return { fn: step.fn, args: [] };
+            }
         }
     }
     return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "playwright-cucumber-ts-steps",
   "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.",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",