@auto-wiz/playwright 1.0.0 → 1.0.1

package/dist/runner.d.ts

@@ -3,5 +3,5 @@ import { Page } from "playwright";
 export declare class PlaywrightFlowRunner implements FlowRunner<Page> {
     run(flow: Flow, page: Page, options?: RunnerOptions): Promise<RunResult>;
     runStep(step: Step, page: Page, options?: RunnerOptions): Promise<ExecutionResult>;
-    private getLocator;
+    private resolveLocator;
 }

package/dist/runner.js

@@ -4,6 +4,33 @@ exports.PlaywrightFlowRunner = void 0;
 class PlaywrightFlowRunner {
     async run(flow, page, options = {}) {
         const extractedData = {};
+        // Implicit Navigation:
+        // If we are on a blank page and the first step has a URL but is NOT a 'navigate' step,
+        // we should navigate to that URL to start the flow.
+        if (page.url() === "about:blank" && flow.steps.length > 0) {
+            const firstStep = flow.steps[0];
+            // Check if the step has a url property (it might not be in the Step type definition for all types)
+            if (firstStep.type !== "navigate" &&
+                "url" in firstStep &&
+                firstStep.url) {
+                try {
+                    // Use the provided timeout or default 5s
+                    await page.goto(firstStep.url, {
+                        timeout: options.timeout || 5000,
+                        waitUntil: "domcontentloaded",
+                    });
+                }
+                catch (error) {
+                    // If navigation fails, we return early as the flow cannot proceed
+                    return {
+                        success: false,
+                        error: `Implicit navigation failed: ${error.message}`,
+                        failedStepIndex: 0,
+                        extractedData,
+                    };
+                }
+            }
+        }
         for (const [index, step] of flow.steps.entries()) {
             try {
                 const result = await this.runStep(step, page, options);
@@ -43,12 +70,12 @@ class PlaywrightFlowRunner {
                     }
                     break;
                 case "click": {
-                    const locator = this.getLocator(page, step);
+                    const locator = await this.resolveLocator(page, step, timeout);
                     await locator.click({ timeout });
                     break;
                 }
                 case "type": {
-                    const locator = this.getLocator(page, step);
+                    const locator = await this.resolveLocator(page, step, timeout);
                     const text = step.text || step.originalText || "";
                     await locator.fill(text, { timeout });
                     if (step.submit) {
@@ -57,24 +84,35 @@ class PlaywrightFlowRunner {
                     break;
                 }
                 case "select": {
-                    const locator = this.getLocator(page, step);
+                    const locator = await this.resolveLocator(page, step, timeout);
                     if (step.value) {
                         await locator.selectOption(step.value, { timeout });
                     }
                     break;
                 }
                 case "extract": {
-                    const locator = this.getLocator(page, step);
-                    const text = await locator.textContent({ timeout });
+                    const locator = await this.resolveLocator(page, step, timeout);
+                    let text = null;
+                    if (step.prop === "outerHTML") {
+                        text = await locator.evaluate((el) => el.outerHTML);
+                    }
+                    else if (step.prop === "value") {
+                        text = await locator.inputValue();
+                    }
+                    else if (step.prop === "innerText") {
+                        text = await locator.innerText({ timeout });
+                    }
+                    else {
+                        // Default match 'outerHTML' if prop is not specified
+                        text = await locator.evaluate((el) => el.outerHTML);
+                    }
                     return { success: true, extractedData: text?.trim() };
                 }
                 case "waitFor": {
                     if (step.selector || step.locator) {
-                        const locator = this.getLocator(page, step);
-                        await locator.waitFor({
-                            state: "visible",
-                            timeout: step.timeoutMs || timeout,
-                        });
+                        // resolveLocator internally waits for visibility, so this is implicitly handled,
+                        // but we call it to ensure we find the valid element.
+                        await this.resolveLocator(page, step, step.timeoutMs || timeout);
                     }
                     else if (step.timeoutMs) {
                         await page.waitForTimeout(step.timeoutMs);
@@ -88,15 +126,54 @@ class PlaywrightFlowRunner {
             return { success: false, error: error.message };
         }
     }
-    getLocator(page, step) {
+    async resolveLocator(page, step, timeout) {
+        const candidates = [];
+        // 1. Gather all candidate selectors
         if ("locator" in step && step.locator) {
-            const { primary } = step.locator;
-            return page.locator(primary).first();
+            const { primary, fallbacks = [] } = step.locator;
+            candidates.push(primary, ...fallbacks);
+        }
+        else if ("selector" in step && step.selector) {
+            candidates.push(step.selector);
         }
-        if ("selector" in step && step.selector) {
-            return page.locator(step.selector).first();
+        else {
+            throw new Error(`Step ${step.type} requires a selector or locator`);
+        }
+        if (candidates.length === 0) {
+            throw new Error(`Step ${step.type} has no valid selectors`);
+        }
+        // 2. If only one candidate, just return it (Playwright's default behavior)
+        if (candidates.length === 1) {
+            return page.locator(candidates[0]).first();
+        }
+        // 3. Parallel Race: Check all candidates for visibility
+        // We create a promise for each candidate that resolves if the element becomes visible
+        // and returns the corresponding Locator.
+        const promises = candidates.map(async (selector) => {
+            const loc = page.locator(selector).first();
+            try {
+                // Wait for it to be visible.
+                // We use the full timeout for each parallel check.
+                // The first one to succeed wins.
+                await loc.waitFor({ state: "visible", timeout });
+                return loc;
+            }
+            catch (err) {
+                // If this specific selector fails, we throw so Promise.any ignores it
+                // (unless all fail)
+                throw err;
+            }
+        });
+        try {
+            // Promise.any resolves with the first fulfilled promise.
+            // If all reject, it throws an AggregateError.
+            const winner = await Promise.any(promises);
+            return winner;
+        }
+        catch (error) {
+            // If all failed, throw a descriptive error
+            throw new Error(`Failed to resolve locator. Tried candidates: ${JSON.stringify(candidates)}. Error: ${error.message}`);
         }
-        throw new Error(`Step ${step.type} requires a selector or locator`);
     }
 }
 exports.PlaywrightFlowRunner = PlaywrightFlowRunner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto-wiz/playwright",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "MIT",
   "author": "JaeSang",
   "repository": {
@@ -24,7 +24,7 @@
   },
   "dependencies": {
     "playwright": "^1.40.0",
-    "@auto-wiz/core": "1.0.0"
+    "@auto-wiz/core": "1.0.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0",