playwright-cucumber-ts-steps 1.1.6 → 1.1.8

package/dist/backend/actions/misc.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+// ==================================================
+// 1. TIMING & WAITS
+// ==================================================
+/**
+ * Pauses execution for a set amount of time.
+ * Pattern: When I wait for 1000 milliseconds
+ */
+(0, registry_1.Step)("I wait for {int} milliseconds", async (page, ms) => {
+    await page.waitForTimeout(ms);
+    console.log(`⏳ Waited for ${ms}ms`);
+});
+/**
+ * Pauses execution for a set amount of seconds.
+ * Pattern: When I wait for 5 seconds
+ */
+(0, registry_1.Step)("I wait for {int} seconds", async (page, seconds) => {
+    await page.waitForTimeout(seconds * 1000);
+    console.log(`⏳ Waited for ${seconds}s`);
+});
+// ==================================================
+// 2. DEBUGGING
+// ==================================================
+/**
+ * Pauses the test execution and opens the Playwright Inspector.
+ * Useful for manual debugging during a run.
+ * Pattern: When I pause
+ */
+(0, registry_1.Step)("I pause", async (page) => {
+    console.log("⏸️ Pausing test execution...");
+    await page.pause();
+});
+/**
+ * Alias for pause.
+ * Pattern: When I debug
+ */
+(0, registry_1.Step)("I debug", async (page) => {
+    console.log("🐞 Debugging...");
+    await page.pause();
+});
+/**
+ * Prints a message to the console logs.
+ * Pattern: When I log "Hello World"
+ */
+(0, registry_1.Step)("I log {string}", async (page, message) => {
+    console.log(`📝 LOG: ${message}`);
+});
+// ==================================================
+// 3. FOCUS & BLUR
+// ==================================================
+/**
+ * Focuses on the currently stored element.
+ * Pattern: When I focus
+ */
+(0, registry_1.Step)("I focus", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await element.focus();
+    console.log("👀 Focused on stored element");
+});
+/**
+ * Blurs (un-focuses) the currently stored element.
+ * Pattern: When I blur
+ */
+(0, registry_1.Step)("I blur", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    // Playwright doesn't have a direct .blur(), so we use JS evaluation
+    await element.evaluate((el) => {
+        if (el instanceof HTMLElement)
+            el.blur();
+    });
+    console.log("🌫️ Blurred stored element");
+});
+// ==================================================
+// 4. BROWSER STORAGE (Cookies / Local Storage)
+// ==================================================
+/**
+ * Sets a cookie for the current context.
+ * Pattern: When I set cookie "session_id" to "12345"
+ */
+(0, registry_1.Step)("I set cookie {string} to {string}", async (page, name, value) => {
+    const context = page.context();
+    const url = page.url();
+    // We need a domain or url to set cookies. We use the current page URL.
+    await context.addCookies([{ name, value, url }]);
+    console.log(`🍪 Set cookie "${name}"`);
+});
+/**
+ * Clears all cookies.
+ * Pattern: When I clear all cookies
+ */
+(0, registry_1.Step)("I clear all cookies", async (page) => {
+    const context = page.context();
+    await context.clearCookies();
+    console.log("🍪 Cleared all cookies");
+});
+/**
+ * Sets a Local Storage item.
+ * Pattern: When I set local storage item "theme" to "dark"
+ */
+(0, registry_1.Step)("I set local storage item {string} to {string}", async (page, key, value) => {
+    await page.evaluate(({ k, v }) => localStorage.setItem(k, v), {
+        k: key,
+        v: value,
+    });
+    console.log(`📦 Set local storage "${key}" = "${value}"`);
+});
+/**
+ * Gets a Local Storage item and prints it.
+ * Pattern: When I get local storage item "token"
+ */
+(0, registry_1.Step)("I get local storage item {string}", async (page, key) => {
+    const value = await page.evaluate((k) => localStorage.getItem(k), key);
+    console.log(`📦 Local Storage "${key}": ${value}`);
+});
+/**
+ * Clears all Local Storage.
+ * Pattern: When I clear local storage
+ */
+(0, registry_1.Step)("I clear local storage", async (page) => {
+    await page.evaluate(() => localStorage.clear());
+    console.log("📦 Cleared local storage");
+});
+/**
+ * Sets a Session Storage item.
+ * Pattern: When I set session storage item "user" to "admin"
+ */
+(0, registry_1.Step)("I set session storage item {string} to {string}", async (page, key, value) => {
+    await page.evaluate(({ k, v }) => sessionStorage.setItem(k, v), {
+        k: key,
+        v: value,
+    });
+    console.log(`📦 Set session storage "${key}" = "${value}"`);
+});
+/**
+ * Clears all Session Storage.
+ * Pattern: When I clear session storage
+ */
+(0, registry_1.Step)("I clear session storage", async (page) => {
+    await page.evaluate(() => sessionStorage.clear());
+    console.log("📦 Cleared session storage");
+});

package/dist/backend/actions/mobile.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mobile.d.ts.map

package/dist/backend/actions/mobile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/mobile.ts"],"names":[],"mappings":""}

package/dist/backend/actions/mobile.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+/**
+ * Helper: Tries to tap. If the context doesn't support touch, falls back to click.
+ */
+async function safeTap(target) {
+    try {
+        // Try native touch tap
+        await target.tap();
+        return "tapped";
+    }
+    catch (error) {
+        if (error.message.includes("does not support tap")) {
+            // Fallback for Desktop Contexts
+            await target.click();
+            return "clicked (fallback)";
+        }
+        throw error;
+    }
+}
+// ==================================================
+// 1. TOUCH INTERACTIONS
+// ==================================================
+/**
+ * Taps on the currently stored element.
+ * Pattern: When I tap
+ */
+(0, registry_1.Step)("I tap", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    const action = await safeTap(element);
+    console.log(`👆 ${action === "tapped" ? "Tapped" : "Clicked"} stored element`);
+});
+/**
+ * Finds an element by selector and taps it.
+ * Pattern: When I tap element "#submit-btn"
+ */
+(0, registry_1.Step)("I tap element {string}", async (page, selector) => {
+    const element = page.locator(selector);
+    const action = await safeTap(element);
+    console.log(`👆 ${action === "tapped" ? "Tapped" : "Clicked"} element "${selector}"`);
+});
+/**
+ * Taps at specific coordinates.
+ * Pattern: When I tap coordinates x:100 y:200
+ */
+(0, registry_1.Step)("I tap coordinates x:{int} y:{int}", async (page, x, y) => {
+    // page.mouse.click works for both desktop and mobile viewports
+    await page.mouse.click(x, y);
+    console.log(`👆 Tapped at (${x}, ${y})`);
+});
+// ==================================================
+// 2. VIEWPORT & EMULATION
+// ==================================================
+(0, registry_1.Step)("I resize window to width {int} and height {int}", async (page, width, height) => {
+    await page.setViewportSize({ width, height });
+    console.log(`📱 Resized viewport to ${width}x${height}`);
+});
+(0, registry_1.Step)("I simulate device {string}", async (page, deviceName) => {
+    const devices = {
+        "iPhone 12": { width: 390, height: 844 },
+        "iPhone SE": { width: 375, height: 667 },
+        iPad: { width: 768, height: 1024 },
+        "Pixel 5": { width: 393, height: 851 },
+        "Samsung Galaxy S8": { width: 360, height: 740 },
+        Desktop: { width: 1920, height: 1080 },
+    };
+    const size = devices[deviceName];
+    if (!size) {
+        throw new Error(`❌ Unknown device preset: "${deviceName}".`);
+    }
+    await page.setViewportSize(size);
+    console.log(`📱 Simulated device "${deviceName}" (${size.width}x${size.height})`);
+});
+// ==================================================
+// 3. GEOLOCATION & PERMISSIONS
+// ==================================================
+(0, registry_1.Step)("I set geolocation to lat: {float} long: {float}", async (page, lat, long) => {
+    await page.context().setGeolocation({ latitude: lat, longitude: long });
+    await page.context().grantPermissions(["geolocation"]);
+    console.log(`🌍 Geolocation set to ${lat}, ${long}`);
+});
+(0, registry_1.Step)("I grant permission {string}", async (page, permission) => {
+    await page.context().grantPermissions([permission]);
+    console.log(`🛡️ Granted permission: "${permission}"`);
+});

package/dist/backend/actions/mouse.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mouse.d.ts.map

package/dist/backend/actions/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/mouse.ts"],"names":[],"mappings":""}

package/dist/backend/actions/mouse.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+// ===================================================================================
+// MOUSE ACTIONS: SCROLLING
+// ===================================================================================
+/**
+ * Scrolls the element matching the selector into view.
+ * Pattern: When I scroll ".footer" into view
+ */
+(0, registry_1.Step)("I scroll {string} into view", async (page, selector) => {
+    const locator = page.locator(selector);
+    await locator.scrollIntoViewIfNeeded();
+    console.log(`🖱️ Scrolled element "${selector}" into view.`);
+});
+/**
+ * Scrolls a specific element to internal X, Y coordinates.
+ * Pattern: When I scroll "#box" to position x:100 y:200
+ */
+(0, registry_1.Step)("I scroll {string} to position x:{int} y:{int}", async (page, selector, x, y) => {
+    const locator = page.locator(selector);
+    await locator.evaluate((el, coords) => {
+        el.scrollTo(coords.x, coords.y);
+    }, { x, y });
+    console.log(`🖱️ Scrolled element "${selector}" to position x:${x} y:${y}.`);
+});
+/**
+ * Scrolls the entire window to specific coordinates.
+ * Pattern: When I scroll to coordinates x:0 y:500
+ */
+(0, registry_1.Step)("I scroll to coordinates x:{int} y:{int}", async (page, x, y) => {
+    await page.evaluate((coords) => {
+        window.scrollTo(coords.x, coords.y);
+    }, { x, y });
+    console.log(`🖱️ Scrolled window to coordinates x:${x} y:${y}.`);
+});
+/**
+ * Scrolls the window smoothly to specific coordinates.
+ * Pattern: When I scroll mouse window to position top:0 left:100
+ */
+(0, registry_1.Step)("I scroll mouse window to position top:{int} left:{int}", async (page, top, left) => {
+    await page.evaluate((coords) => {
+        window.scrollTo({
+            top: coords.top,
+            left: coords.left,
+            behavior: "smooth",
+        });
+    }, { top, left });
+    console.log(`🖱️ Scrolled window to position top:${top} left:${left} (smooth).`);
+});
+/**
+ * Scrolls to a general direction (top, bottom, left, right).
+ * Pattern: When I scroll to "bottom"
+ */
+(0, registry_1.Step)("I scroll to {string}", async (page, direction) => {
+    const validDirections = ["top", "bottom", "left", "right"];
+    const dir = direction.toLowerCase();
+    if (!validDirections.includes(dir)) {
+        throw new Error(`Invalid scroll direction "${direction}". Must be one of: ${validDirections.join(", ")}.`);
+    }
+    await page.evaluate((d) => {
+        const scrollOptions = { behavior: "smooth" };
+        switch (d) {
+            case "top":
+                scrollOptions.top = 0;
+                break;
+            case "bottom":
+                scrollOptions.top = document.body.scrollHeight;
+                break;
+            case "left":
+                scrollOptions.left = 0;
+                break;
+            case "right":
+                scrollOptions.left = document.body.scrollWidth;
+                break;
+        }
+        window.scrollTo(scrollOptions);
+    }, dir);
+    console.log(`🖱️ Scrolled to "${dir}".`);
+    // Wait a moment for smooth scroll to finish
+    await page.waitForTimeout(500);
+});
+// ===================================================================================
+// MOUSE ACTIONS: HOVERING / MOVEMENT
+// ===================================================================================
+/**
+ * Hovers over an element and sets it as the active element.
+ * Pattern: When I hover over the element ".menu-item"
+ */
+(0, registry_1.Step)("I hover over the element {string}", async (page, selector) => {
+    const element = page.locator(selector);
+    await element.hover();
+    // 🔥 Store the hovered element so we can click/assert on it immediately after
+    (0, state_1.setActiveElement)(page, element);
+    console.log(`🖱️ Hovered over: "${selector}".`);
+});
+/**
+ * Moves mouse to absolute coordinates.
+ * Pattern: When I move mouse to coordinates 100, 200
+ */
+(0, registry_1.Step)("I move mouse to coordinates {int}, {int}", async (page, x, y) => {
+    await page.mouse.move(x, y);
+    console.log(`🧭 Mouse moved to (${x}, ${y}).`);
+});

package/dist/backend/actions/navigation.js

@@ -1,19 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const registry_1 = require("../../core/registry");
-// Basic visit
+/**
+ * Visits a specific URL.
+ * Pattern: Given I visit "https://google.com"
+ */
 (0, registry_1.Step)("I visit {string}", async (page, url) => {
     await page.goto(url);
+    console.log(`🌍 Visiting: ${url}`);
 });
-// Visit and wait for network (useful for slow apps)
-(0, registry_1.Step)("I visit {string} and wait for network idle", async (page, url) => {
-    await page.goto(url, { waitUntil: "networkidle" });
-});
-// Reload page
+/**
+ * Reloads the current page.
+ * Pattern: When I reload the page
+ */
 (0, registry_1.Step)("I reload the page", async (page) => {
     await page.reload();
+    console.log("🔄 Page reloaded");
 });
-// Go back
+/**
+ * Navigates back in browser history.
+ * Pattern: When I go back
+ */
 (0, registry_1.Step)("I go back", async (page) => {
     await page.goBack();
+    console.log("⬅️ Went back");
+});
+/**
+ * Navigates forward in browser history.
+ * Pattern: When I go forward
+ */
+(0, registry_1.Step)("I go forward", async (page) => {
+    await page.goForward();
+    console.log("➡️ Went forward");
+});
+/**
+ * Navigates to a specific path (relative to base URL if set).
+ * Pattern: When I navigate to "/login"
+ */
+(0, registry_1.Step)("I navigate to {string}", async (page, path) => {
+    await page.goto(path);
+    console.log(`🌍 Navigated to path: ${path}`);
 });

package/dist/backend/actions/waits.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=waits.d.ts.map

package/dist/backend/actions/waits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waits.d.ts","sourceRoot":"","sources":["../../../src/backend/actions/waits.ts"],"names":[],"mappings":""}

package/dist/backend/actions/waits.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+/**
+ * Waits for the network to be idle (no active connections for 500ms).
+ * Useful after clicking a button that triggers complex API calls.
+ * Pattern: When I wait for network idle
+ */
+(0, registry_1.Step)("I wait for network idle", async (page) => {
+    await page.waitForLoadState("networkidle");
+    console.log("⏳ Network is idle");
+});
+/**
+ * Waits for the page to reach a specific load state.
+ * Options: "load", "domcontentloaded", "networkidle".
+ * Pattern: When I wait for load state "domcontentloaded"
+ */
+(0, registry_1.Step)("I wait for load state {string}", async (page, state) => {
+    if (!["load", "domcontentloaded", "networkidle"].includes(state)) {
+        throw new Error(`❌ Invalid load state: "${state}". Use load, domcontentloaded, or networkidle.`);
+    }
+    await page.waitForLoadState(state);
+    console.log(`⏳ Reached load state: "${state}"`);
+});
+/**
+ * Explicitly waits for the stored element to be visible.
+ * Pattern: When I wait for element to be visible
+ */
+(0, registry_1.Step)("I wait for element to be visible", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await element.waitFor({ state: "visible" });
+    console.log("⏳ Element is now visible");
+});
+/**
+ * Explicitly waits for the stored element to be hidden/detached.
+ * Pattern: When I wait for element to be hidden
+ */
+(0, registry_1.Step)("I wait for element to be hidden", async (page) => {
+    const element = (0, state_1.getActiveElement)(page);
+    await element.waitFor({ state: "hidden" });
+    console.log("⏳ Element is now hidden");
+});
+/**
+ * Waits for a specific URL pattern.
+ * Pattern: When I wait for URL to contain "dashboard"
+ */
+(0, registry_1.Step)("I wait for URL to contain {string}", async (page, urlPart) => {
+    await page.waitForURL(new RegExp(urlPart));
+    console.log(`⏳ URL now contains: "${urlPart}"`);
+});

package/dist/backend/api/index.d.ts

@@ -1,4 +1,5 @@
 import "./requests";
 import "./assertions";
 import "./mock";
+import "./network";
 //# sourceMappingURL=index.d.ts.map

package/dist/backend/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAC;AACpB,OAAO,cAAc,CAAC;AACtB,OAAO,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAC;AACpB,OAAO,cAAc,CAAC;AACtB,OAAO,QAAQ,CAAC;AAChB,OAAO,WAAW,CAAC"}

package/dist/backend/api/index.js

@@ -3,3 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("./requests");
 require("./assertions");
 require("./mock");
+require("./network");

package/dist/backend/api/network.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=network.d.ts.map

package/dist/backend/api/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../src/backend/api/network.ts"],"names":[],"mappings":""}

package/dist/backend/api/network.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../../core/registry");
+const state_1 = require("../utils/state");
+// Helper: Safely parse JSON even if it comes with DocString quotes or is undefined
+function safeJsonParse(input, context) {
+    if (!input) {
+        throw new Error(`❌ Missing JSON input for ${context}. Did you forget the DocString?`);
+    }
+    let text = typeof input === "string" ? input : JSON.stringify(input);
+    // Clean up DocString artifacts if the runner passes them
+    // 1. Remove surrounding triple quotes """ if present
+    text = text.replace(/^"""/g, "").replace(/"""$/g, "");
+    // 2. Trim whitespace/newlines
+    text = text.trim();
+    // Debug Log: Show exactly what we are trying to parse
+    // console.log(`🔍 [Debug] Parsing JSON for ${context}:`, text);
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        // If simple parse fails, it might be due to unquoted keys or single quotes
+        // You could add a 'loose JSON' parser here if needed, but for now, strict JSON is best.
+        throw new Error(`❌ Invalid JSON for ${context}.\nReceived: ${text.slice(0, 50)}...\nError: ${e.message}`);
+    }
+}
+// =============================
+// 1. INTERCEPTION / MOCKING
+// =============================
+/**
+ * Intercepts a URL and returns a JSON response (Mocking).
+ * Uses Regex to support optional trailing colon.
+ */
+(0, registry_1.Step)(/^I intercept URL "([^"]+)" and stub body:?$/, async (page, url, body) => {
+    const parsedBody = safeJsonParse(body, `stubbing "${url}"`);
+    await page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "application/json",
+            body: JSON.stringify(parsedBody),
+        });
+    });
+    console.log(`📡 Stubbed "${url}" with JSON response.`);
+});
+/**
+ * Intercepts a URL and stubs it with a raw string (non-JSON).
+ */
+(0, registry_1.Step)("I intercept URL {string} and stub body {string}", async (page, url, body) => {
+    await page.route(url, (route) => {
+        route.fulfill({
+            status: 200,
+            contentType: "text/plain",
+            body: body,
+        });
+    });
+    console.log(`📡 Stubbed "${url}" with raw text: "${body}"`);
+});
+/**
+ * Intercepts a URL but allows it to continue (Spying).
+ */
+(0, registry_1.Step)("I intercept URL {string}", async (page, url) => {
+    await page.route(url, async (route) => {
+        await route.continue();
+    });
+    console.log(`📡 Spying on URL "${url}" (allowed to continue).`);
+});
+// =============================
+// 2. MAKING API REQUESTS
+// =============================
+/**
+ * Makes a GET request and stores the response.
+ */
+(0, registry_1.Step)("I make request to {string}", async (page, url) => {
+    console.log(`⚡ GET request to: ${url}`);
+    const response = await page.request.get(url);
+    const status = response.status();
+    const body = await response.text();
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { status, body, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", status);
+    console.log(`✅ Status: ${status}`);
+});
+/**
+ * Makes a POST request with a JSON body.
+ * Uses Regex to support optional trailing colon.
+ */
+(0, registry_1.Step)(/^I make a POST request to "([^"]+)" with JSON body:?$/, async (page, url, docString) => {
+    const payload = safeJsonParse(docString, `POST to "${url}"`);
+    console.log(`⚡ POST request to: ${url}`);
+    const response = await page.request.post(url, { data: payload });
+    const status = response.status();
+    const body = await response.text();
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { status, body, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", status);
+    console.log(`✅ Status: ${status}`);
+});
+/**
+ * Makes a generic browser-context HTTP request (fetch).
+ */
+(0, registry_1.Step)('I make a "{word}" request to {string}', async (page, method, url, table) => {
+    const options = { method: method.toUpperCase() };
+    const rows = table && typeof table.rows === "function" ? table.rows() : table || [];
+    if (Array.isArray(rows)) {
+        rows.forEach((row) => {
+            const key = Array.isArray(row) ? row[0] : row.header || row.key;
+            const val = Array.isArray(row) ? row[1] : row.value;
+            if (!key)
+                return;
+            if (key.toLowerCase() === "body") {
+                options.body = val;
+            }
+            else {
+                if (!options.headers)
+                    options.headers = {};
+                options.headers[key] = val;
+            }
+        });
+    }
+    console.log(`⚡ Browser Fetch: ${method} ${url}`);
+    const res = await page.evaluate(async ({ url, options }) => {
+        const response = await fetch(url, options);
+        return {
+            status: response.status,
+            body: await response.text(),
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    }, { url, options });
+    let jsonBody;
+    try {
+        jsonBody = JSON.parse(res.body);
+    }
+    catch { }
+    (0, state_1.setVariable)(page, "lastResponse", { ...res, json: jsonBody });
+    (0, state_1.setVariable)(page, "lastStatusCode", res.status);
+    console.log(`✅ Status: ${res.status}`);
+});