@skrillex1224/playwright-toolkit 2.1.201 → 2.1.203

package/dist/index.js

@@ -3039,6 +3039,7 @@ var Captcha = {
 };
 
 // src/mutation.js
+import { createHash } from "node:crypto";
 import { v4 as uuidv42 } from "uuid";
 var logger10 = createInternalLogger("Mutation");
 var MUTATION_MONITOR_MODE = Object.freeze({
@@ -3245,82 +3246,138 @@ var Mutation = {
       if (text.length <= max) return text;
       return `${text.slice(0, max)}...`;
     };
+    const normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+    const normalizeHtml = (value) => String(value || "").trim();
+    const hashSnapshot = (value) => createHash("sha256").update(String(value || "")).digest("hex");
     const buildState = async () => {
-      return await page.evaluate(({ selectorList: selectorList2 }) => {
-        const normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
-        const tail = (value, max = 512) => {
-          const text = String(value || "");
-          if (text.length <= max) return text;
-          return text.slice(text.length - max);
-        };
-        const safeFrameId = (frameEl) => {
-          const id = String(frameEl?.id || "").trim();
-          if (id) return id;
-          const name = String(frameEl?.name || "").trim();
-          if (name) return name;
-          return "no-id";
-        };
-        const items = [];
-        selectorList2.forEach((selector) => {
-          let nodes = [];
+      const items = [];
+      const describeElement = async (elementHandle) => {
+        return await elementHandle.evaluate((node) => {
+          const tagName = String(node?.tagName || "").toUpperCase();
+          return {
+            tagName,
+            id: String(node?.id || "").trim(),
+            name: String(node?.getAttribute?.("name") || "").trim()
+          };
+        });
+      };
+      const readElementSnapshot = async (elementHandle) => {
+        return await elementHandle.evaluate((node) => {
+          const text = String(node?.innerText || node?.textContent || "");
+          const html = String(node?.innerHTML || node?.outerHTML || "");
+          return {
+            text,
+            html
+          };
+        });
+      };
+      const readFrameSnapshot = async (frame) => {
+        return await frame.evaluate(() => {
+          const root = document.documentElement || document.body;
+          const text = String(root?.innerText || root?.textContent || "");
+          const html = String(root?.innerHTML || "");
+          return {
+            text,
+            html,
+            url: window.location.href,
+            readyState: document.readyState
+          };
+        });
+      };
+      for (const selector of selectorList) {
+        let handles = [];
+        try {
+          handles = await page.locator(selector).elementHandles();
+        } catch {
+          continue;
+        }
+        for (let index = 0; index < handles.length; index += 1) {
+          const handle = handles[index];
           try {
-            nodes = Array.from(document.querySelectorAll(selector));
-          } catch {
-            return;
-          }
-          nodes.forEach((node, index) => {
-            const isIframe = node?.tagName === "IFRAME";
-            let text = "";
-            let html = "";
+            const descriptor = await describeElement(handle);
+            const tagName = descriptor?.tagName || "";
+            const isFrameElement = tagName === "IFRAME" || tagName === "FRAME";
+            const nodeName = descriptor?.id || descriptor?.name || "no-id";
             let source = "main";
             let path2 = `${selector}[${index}]`;
-            if (isIframe) {
+            let text = "";
+            let html = "";
+            let frameUrl = "";
+            let readyState = "";
+            if (isFrameElement) {
               source = "iframe";
-              path2 = `${selector}[${index}]::iframe(${safeFrameId(node)})`;
-              try {
-                const frameDoc = node.contentDocument;
-                const frameRoot = frameDoc?.body || frameDoc?.documentElement;
-                if (frameRoot) {
-                  text = normalizeText(frameRoot.innerText || frameRoot.textContent || "");
-                  html = normalizeText(frameRoot.innerHTML || "");
+              path2 = `${selector}[${index}]::iframe(${nodeName})`;
+              const frame = await handle.contentFrame();
+              if (frame) {
+                try {
+                  const frameSnapshot = await readFrameSnapshot(frame);
+                  text = normalizeText(frameSnapshot?.text || "");
+                  html = normalizeHtml(frameSnapshot?.html || "");
+                  frameUrl = String(frameSnapshot?.url || "").trim();
+                  readyState = String(frameSnapshot?.readyState || "").trim();
+                } catch (error) {
+                  source = "iframe-unreadable";
+                  readyState = error?.name || "unreadable";
                 }
-              } catch {
+              } else {
+                source = "iframe-detached";
               }
             } else {
-              text = normalizeText(node?.innerText || node?.textContent || "");
-              html = normalizeText(node?.innerHTML || node?.outerHTML || "");
+              try {
+                const elementSnapshot = await readElementSnapshot(handle);
+                text = normalizeText(elementSnapshot?.text || "");
+                html = normalizeHtml(elementSnapshot?.html || "");
+              } catch (error) {
+                source = "main-unreadable";
+                readyState = error?.name || "unreadable";
+              }
             }
-            const snapshot = text || html;
+            const snapshot = `${text}
+<!--HTML-->
+${html}`;
             items.push({
               selector,
               source,
               path: path2,
               text,
               html,
+              frameUrl,
+              readyState,
               snapshot
             });
-          });
-        });
-        const snapshotKey = items.map((item) => `${item.path}:${item.snapshot.length}:${tail(item.snapshot, 512)}`).join("||");
-        const summaryText = items.map((item) => item.snapshot || item.text).join("\n").trim();
-        const summaryHtml = items.map((item) => item.html).join("\n");
-        const hasMatched = items.length > 0;
-        const primary = items.length > 0 ? items[items.length - 1] : null;
-        return {
-          hasMatched,
-          snapshotKey,
-          text: summaryText,
-          html: summaryHtml,
-          snapshotLength: summaryText.length,
-          itemCount: items.length,
-          primaryPath: primary?.path || "",
-          mutationNodes: items.map((item) => ({
-            html: item.html,
-            text: item.snapshot || item.text,
-            mutationType: item.source
-          }))
-        };
-      }, { selectorList });
+          } finally {
+            await handle.dispose().catch(() => {
+            });
+          }
+        }
+      }
+      const serializedSnapshot = items.map((item) => JSON.stringify({
+        path: item.path,
+        source: item.source,
+        frameUrl: item.frameUrl,
+        readyState: item.readyState,
+        snapshot: item.snapshot
+      })).join("||");
+      const summaryText = items.map((item) => item.text).join("\n").trim();
+      const summaryHtml = items.map((item) => item.html).join("\n");
+      const hasMatched = items.length > 0;
+      const primary = items.length > 0 ? items[items.length - 1] : null;
+      return {
+        hasMatched,
+        snapshotKey: hashSnapshot(serializedSnapshot),
+        text: summaryText,
+        html: summaryHtml,
+        snapshotLength: serializedSnapshot.length,
+        itemCount: items.length,
+        primaryPath: primary?.path || "",
+        mutationNodes: items.map((item) => ({
+          html: item.html,
+          text: item.text,
+          mutationType: item.source,
+          frameUrl: item.frameUrl,
+          readyState: item.readyState
+        }))
+      };
     };
     const invokeMutationCallback = async (context) => {
       if (!onMutation) return "__CONTINUE__";