@reshotdev/screenshot 0.0.1-beta.12 → 0.0.1-beta.13

package/src/lib/playwright-runner.js

@@ -1,252 +0,0 @@
-// playwright-runner.js - Generic Playwright runner for executing steps
-const { chromium } = require("playwright");
-const path = require("path");
-const fs = require("fs-extra");
-const { buildLaunchOptions } = require("./ci-detect");
-const { resolveSecretsInObject } = require("./secrets");
-
-/**
- * Wait for element with retries and fallbacks
- * @param {Page} page - Playwright page
- * @param {string} selector - CSS selector
- * @param {Object} options - Options
- * @returns {Promise<Locator>}
- */
-async function waitForElement(page, selector, options = {}) {
-  const { timeout = 10000, action = "interact" } = options;
-
-  // First, wait for the page to be stable (no network activity)
-  try {
-    await page.waitForLoadState("networkidle", { timeout: 5000 });
-  } catch (e) {
-    // Continue even if networkidle times out
-  }
-
-  // Try the selector directly
-  const locator = page.locator(selector);
-
-  try {
-    await locator.first().waitFor({ state: "visible", timeout });
-    return locator.first();
-  } catch (e) {
-    // If selector fails, try some fallback strategies
-    console.log(
-      `    ⚠ Selector "${selector}" not immediately found, trying fallbacks...`
-    );
-
-    // Strategy 1: Wait a bit longer for dynamic content
-    await page.waitForTimeout(1000);
-
-    try {
-      await locator.first().waitFor({ state: "visible", timeout: 3000 });
-      return locator.first();
-    } catch (e2) {
-      // Strategy 2: Try scrolling to make element visible
-      try {
-        await page.evaluate(() =>
-          window.scrollTo(0, document.body.scrollHeight / 2)
-        );
-        await page.waitForTimeout(500);
-        await locator.first().waitFor({ state: "visible", timeout: 2000 });
-        return locator.first();
-      } catch (e3) {
-        // Give up with helpful error
-        const count = await locator.count();
-        if (count === 0) {
-          throw new Error(
-            `Element not found: "${selector}" - no matching elements on page`
-          );
-        } else {
-          throw new Error(
-            `Element "${selector}" exists (${count} matches) but not visible/clickable`
-          );
-        }
-      }
-    }
-  }
-}
-
-/**
- * Run a sequence of steps with Playwright
- * Based on test/persona-injection/generic_runner.js and test/capturing-target/element_runner.js
- *
- * @param {Object} options - Run options
- * @param {string} options.url - URL to navigate to
- * @param {Array} options.steps - Array of step objects
- * @param {string} options.outputDir - Directory to save output files
- * @param {Object} options.context - Context object for variable resolution
- */
-async function runSteps({ url, steps, outputDir, context }) {
-  const browser = await chromium.launch(buildLaunchOptions({ headless: true }));
-  const page = await browser.newPage();
-
-  // Set viewport for consistent rendering
-  await page.setViewportSize({ width: 1280, height: 720 });
-
-  // Set a reasonable default timeout
-  page.setDefaultTimeout(20000); // 20 seconds
-
-  try {
-    console.log(`  Navigating to ${url}`);
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
-
-    // Wait for initial page load
-    await page
-      .waitForLoadState("networkidle", { timeout: 10000 })
-      .catch(() => {});
-
-    for (let index = 0; index < steps.length; index++) {
-      const step = steps[index];
-      console.log(
-        `  Executing step ${index + 1}/${steps.length}: ${step.action} ${
-          step.selector || ""
-        }`
-      );
-
-      // Resolve secrets in all step fields
-      const resolvedStep = resolveSecretsInObject(step);
-
-      try {
-        switch (resolvedStep.action) {
-          case "goto":
-            await page.goto(resolvedStep.url || url, {
-              waitUntil: "domcontentloaded",
-            });
-            await page
-              .waitForLoadState("networkidle", { timeout: 10000 })
-              .catch(() => {});
-            break;
-
-          case "type":
-          case "input": {
-            const inputElement = await waitForElement(
-              page,
-              resolvedStep.selector,
-              { action: "fill" }
-            );
-            await inputElement.fill(resolvedStep.text || "");
-            break;
-          }
-
-          case "click": {
-            const clickElement = await waitForElement(
-              page,
-              resolvedStep.selector,
-              { action: "click" }
-            );
-            await clickElement.click();
-            // Small delay after click to let page react
-            await page.waitForTimeout(300);
-            break;
-          }
-
-          case "hover": {
-            const hoverElement = await waitForElement(
-              page,
-              resolvedStep.selector,
-              { action: "hover" }
-            );
-            await hoverElement.hover();
-            break;
-          }
-
-          case "waitForSelector":
-            await waitForElement(page, resolvedStep.selector);
-            break;
-
-          case "wait":
-            await page.waitForTimeout(
-              resolvedStep.ms || resolvedStep.duration || 1000
-            );
-            break;
-
-          case "screenshot":
-            await handleScreenshot(page, resolvedStep, outputDir, index);
-            break;
-
-          default:
-            console.warn(`  ⚠ Unknown action: ${resolvedStep.action}`);
-        }
-
-        console.log(`    ✓ Step ${index + 1} completed`);
-      } catch (stepError) {
-        // Enhanced error message for selector failures
-        const selectorInfo = resolvedStep.selector
-          ? ` (selector: "${resolvedStep.selector}")`
-          : "";
-        console.error(
-          `  ❌ Step ${index + 1} failed: ${step.action}${selectorInfo}`
-        );
-        console.error(`     Error: ${stepError.message}`);
-
-        // Take a screenshot for debugging
-        try {
-          const debugPath = path.join(
-            outputDir || ".",
-            `debug-step-${index + 1}-failure.png`
-          );
-          await page.screenshot({ path: debugPath, fullPage: true });
-          console.error(`     Debug screenshot saved: ${debugPath}`);
-        } catch (ssError) {
-          // Ignore screenshot errors
-        }
-
-        // Re-throw to stop execution
-        throw new Error(
-          `Step ${index + 1} (${step.action}) failed: ${stepError.message}`
-        );
-      }
-    }
-
-    console.log(`  ✔ All ${steps.length} steps completed successfully`);
-  } finally {
-    await browser.close();
-  }
-}
-
-/**
- * Handle screenshot step
- * Based on test/capturing-target/element_runner.js
- */
-function resolveScreenshotPath(step, index) {
-  if (step.path) {
-    return step.path;
-  }
-
-  const baseName = step.captureKey || step.key;
-  if (baseName) {
-    return path.extname(baseName) ? baseName : `${baseName}.png`;
-  }
-
-  return `step-${(index ?? 0) + 1}.png`;
-}
-
-async function handleScreenshot(page, step, outputDir, index) {
-  const relativePath = resolveScreenshotPath(step, index);
-  const finalPath = path.join(outputDir, relativePath);
-  fs.ensureDirSync(path.dirname(finalPath));
-
-  if (step.selector) {
-    // Capture specific element
-    const element = await page.locator(step.selector).first();
-    await element.screenshot({ path: finalPath });
-    console.log(`  ✔ Captured element and saved to ${finalPath}`);
-  } else {
-    // Capture full page
-    const screenshotOptions = {
-      path: finalPath,
-      fullPage: !step.clip,
-    };
-
-    if (step.clip) {
-      screenshotOptions.clip = step.clip;
-    }
-
-    await page.screenshot(screenshotOptions);
-    console.log(`  ✔ Captured full page and saved to ${finalPath}`);
-  }
-}
-
-module.exports = {
-  runSteps,
-};