@auto-wiz/playwright 1.1.3 → 1.3.0

package/dist/runner.js

@@ -108,16 +108,111 @@ class PlaywrightFlowRunner {
                             return clone.outerHTML;
                         });
                     }
+                    else if (step.prop === "simplified") {
+                        // Simplified: Canonical transformation, lighter but preserves hierarchy
+                        text = await locator.evaluate((el) => {
+                            const clone = el.cloneNode(true);
+                            const blockListTags = [
+                                "SCRIPT",
+                                "STYLE",
+                                "SVG",
+                                "NOSCRIPT",
+                                "IFRAME",
+                                "OBJECT",
+                                "EMBED",
+                                "PARAM",
+                                "SOURCE",
+                                "TRACK",
+                                "AREA",
+                                "MAP",
+                                "META",
+                                "LINK",
+                                "HEAD",
+                            ];
+                            const allowedAttributes = [
+                                "id",
+                                "name",
+                                "href",
+                                "src",
+                                "alt",
+                                "value",
+                                "type",
+                                "placeholder",
+                                "title",
+                                "colspan",
+                                "rowspan",
+                                "target",
+                            ];
+                            const isGenericContainer = (tagName) => ["DIV", "SPAN"].includes(tagName);
+                            function clean(node) {
+                                if (blockListTags.includes(node.tagName)) {
+                                    node.remove();
+                                    return;
+                                }
+                                const children = Array.from(node.children);
+                                for (const child of children) {
+                                    clean(child);
+                                }
+                                const attrs = Array.from(node.attributes || []);
+                                for (const attr of attrs) {
+                                    if (!allowedAttributes.includes(attr.name)) {
+                                        node.removeAttribute(attr.name);
+                                    }
+                                }
+                                if (isGenericContainer(node.tagName)) {
+                                    const hasIdOrName = node.hasAttribute("id") || node.hasAttribute("name");
+                                    if (hasIdOrName) {
+                                        const hasChildNodes = node.childNodes.length > 0;
+                                        if (!hasChildNodes) {
+                                            node.remove();
+                                        }
+                                        return;
+                                    }
+                                    const childElements = node.children;
+                                    let hasText = false;
+                                    for (const childNode of Array.from(node.childNodes)) {
+                                        if (childNode.nodeType === 3 &&
+                                            (childNode.textContent || "").trim() !== "") {
+                                            hasText = true;
+                                            break;
+                                        }
+                                    }
+                                    if (node.tagName === "SPAN") {
+                                        const parent = node.parentNode;
+                                        if (parent) {
+                                            while (node.firstChild) {
+                                                parent.insertBefore(node.firstChild, node);
+                                            }
+                                            parent.removeChild(node);
+                                        }
+                                        return;
+                                    }
+                                    if (childElements.length === 1 && !hasText) {
+                                        const singleChild = childElements[0];
+                                        const parent = node.parentNode;
+                                        if (parent) {
+                                            node.replaceWith(singleChild);
+                                        }
+                                        return;
+                                    }
+                                    if (childElements.length === 0 && !hasText) {
+                                        node.remove();
+                                        return;
+                                    }
+                                }
+                            }
+                            clean(clone);
+                            return clone.outerHTML;
+                        });
+                    }
                     else {
                         // Default "structure": clean HTML, keep only id, name, text
                         text = await locator.evaluate(function (el) {
                             const clone = el.cloneNode(true);
-                            // 1. Remove SVGs first
                             const svgs = clone.querySelectorAll("svg");
                             for (const svg of Array.from(svgs)) {
                                 svg.remove();
                             }
-                            // 2. Clean attributes of all descendants
                             const descendants = clone.querySelectorAll("*");
                             for (const child of Array.from(descendants)) {
                                 const attrs = Array.from(child.attributes);
@@ -127,7 +222,6 @@ class PlaywrightFlowRunner {
                                     }
                                 }
                             }
-                            // 3. Clean attributes of the root element itself
                             const rootAttrs = Array.from(clone.attributes);
                             for (const attr of rootAttrs) {
                                 if (attr.name !== "id" && attr.name !== "name") {
@@ -140,7 +234,7 @@ class PlaywrightFlowRunner {
                     return { success: true, extractedData: text?.trim() };
                 }
                 case "waitFor": {
-                    if (step.selector || step.locator) {
+                    if (step.locator) {
                         // 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);
@@ -158,26 +252,19 @@ class PlaywrightFlowRunner {
         }
     }
     async resolveLocator(page, step, timeout) {
-        const candidates = [];
-        // 1. Gather all candidate selectors
-        if ("locator" in step && step.locator) {
-            const { primary, fallbacks = [] } = step.locator;
-            candidates.push(primary, ...fallbacks);
-        }
-        else if ("selector" in step && step.selector) {
-            candidates.push(step.selector);
-        }
-        else {
-            throw new Error(`Step ${step.type} requires a selector or locator`);
+        if (!("locator" in step) || !step.locator) {
+            throw new Error(`Step ${step.type} requires a locator`);
         }
+        const { primary, fallbacks = [] } = step.locator;
+        const candidates = [primary, ...fallbacks];
         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 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
+        // 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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto-wiz/playwright",
-  "version": "1.1.3",
+  "version": "1.3.0",
   "license": "MIT",
   "author": "JaeSang",
   "repository": {
@@ -22,13 +22,16 @@
       "require": "./dist/index.js"
     }
   },
+  "peerDependencies": {
+    "@auto-wiz/core": "^1.2.0"
+  },
   "dependencies": {
-    "playwright": "^1.40.0",
-    "@auto-wiz/core": "1.1.3"
+    "playwright": "^1.40.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "@auto-wiz/core": "1.2.0"
   },
   "scripts": {
     "build": "tsc"