@dev-blinq/cucumber_client 1.0.1398-dev → 1.0.1398-stage

package/bin/assets/scripts/recorder.js

@@ -390,6 +390,7 @@ class BVTRecorder {
           }
           case "input": {
             const target = this.eventUtils.getNearestInteractiveElement(this.eventUtils.deepEventTarget(event));
+
             if (target.nodeName === "INPUT" && target.type.toLowerCase() === "file") {
               return {
                 details: {
@@ -434,6 +435,32 @@ class BVTRecorder {
             return;
           }
           case "keydown": {
+            // override event.preventDefault to capture the value
+
+            const oldPreventDefault = event.preventDefault.bind(event);
+            event.preventDefault = () => {
+              if (event.key.length >= 1 && !event.ctrlKey && !event.metaKey && !event.altKey) {
+                const target = this.eventUtils.getNearestInteractiveElement(this.eventUtils.deepEventTarget(event));
+                setTimeout((() => {
+                  if (event.__bvt_recorded !== undefined) return;
+                  const valueBefore = target.value;
+                  let newValue = valueBefore;
+
+                  this.recordEvent({
+                    details: {
+                      name: "fill",
+                      text: newValue,
+                    },
+                    element: target,
+                  }, target, "input", event);
+
+                  event.__bvt_recorded = true;
+                }), 20)
+              }
+              oldPreventDefault();
+            };
+
+
             if (!this.eventUtils.shouldGenerateKeyPressFor(event)) return;
             // if (this._actionInProgress(event)) {
             //   this._expectProgrammaticKeyUp = true;
@@ -676,7 +703,7 @@ class BVTRecorder {
 
       lastInputId = el.dataset.inputId;
 
-      el.__locators = this.getLocatorsObject(el);
+      // el.__locators = this.getLocatorsObject(el, { maxLocators: 1 });
     }
     const role = this.PW.roleUtils.getAriaRole(el);
     const label =
@@ -684,13 +711,15 @@ class BVTRecorder {
       this.PW.roleUtils.getElementAccessibleName(el, true) ||
       "";
     const result = this.getElementProperties(el);
+    const elText = this.PW.selectorUtils.elementText(new Map(), el);
     return {
       role,
       label,
       inputID: el.dataset.inputId,
       tagName: el.tagName,
       type: el.type,
-      text: this.PW.selectorUtils.elementText(new Map(), el).full.trim(),
+      text: elText.full.trim(),
+      textNormalized: elText.normalized.trim(),
       parent: `tagname: ${el.parentElement?.tagName}\ninnerText: ${el.parentElement?.innerText}`,
       attrs: {
         placeholder: el.getAttribute("placeholder"),
@@ -788,26 +817,15 @@ class BVTRecorder {
     });
   }
 
-  getLocatorsObject(el) {
+  getLocatorsObject(el, options = {}) {
     if (this.contextElement) {
-      const text = this.contextElement.innerText; // TODO: handle case where contextElement is not in dom/ children removed
-      const contextEl = this.contextElement;
-      // const { climb, commonParent } = window.getCommonParent(contextEl, el);
-      const commonParent = this.locatorGenerator.dom_Parent.findLowestCommonAncestor([contextEl, el]);
-      const climb = this.locatorGenerator.dom_Parent.getClimbCountToParent(contextEl, commonParent);
-      const result = this.locatorGenerator.getElementLocators(el, {
-        excludeText: true,
-        root: commonParent,
-      });
-      result.locators.forEach((locator) => {
-        locator.text = text;
-        locator.climb = climb;
-      });
+      const result = this.locatorGenerator.toContextLocators(el, this.contextElement, options);
       return result;
     }
     const isRecordingText = this.#mode === "recordingText";
     return this.locatorGenerator.getElementLocators(el, {
       excludeText: isRecordingText,
+      ...options,
     });
   }
   addListeners() {
@@ -844,31 +862,7 @@ class BVTRecorder {
           }
 
           performance.mark("command-send");
-          const cmd = {
-            mode: this.#mode,
-            action: action.details,
-            element: this.getElementDetails(actionElement, eventName),
-            isPopupCloseClick: this.isPopupCloseEvent(e),
-            // ...this.getLocatorsObject(actionElement),
-            ...(actionElement.__locators ?? this.getLocatorsObject(actionElement)),
-            frame: this.getFrameDetails(),
-            statistics: {
-              time: `${performance.measure("command-received", "command-send").duration.toFixed(2)} ms`,
-            },
-          };
-          const snapshotDetails = {
-            id: actionElement.getAttribute("data-blinq-id"),
-            contextId: this.contextElement?.getAttribute("data-blinq-context-id"),
-            doc: this.snapshotCapturer.createSnapshot({
-              excludeSelectors: ["x-bvt-toolbar", "script", "style", "link[rel=stylesheet]"],
-            }),
-          };
-          cmd.snapshotDetails = snapshotDetails;
-          // eventQueue.enqueue(async () => {
-          // await bvtRecorderBindings.validateLocators(snapshotDetails);
-          // });
-          // console.log(cmd);
-          await bvtRecorderBindings.recordCommand(cmd);
+          this.recordEvent(action, actionElement, eventName, e);
           this.handleStateTransition(action.element);
         },
         { capture: true }
@@ -876,6 +870,33 @@ class BVTRecorder {
     });
   }
 
+  recordEvent(action, actionElement, eventName, e) {
+    const cmd = {
+      mode: this.#mode,
+      action: action.details,
+      element: this.getElementDetails(actionElement, eventName),
+      isPopupCloseClick: this.isPopupCloseEvent(e),
+      // ...(actionElement.__locators ?? this.getLocatorsObject(actionElement, { maxLocators: 1 })),
+      frame: this.getFrameDetails(),
+      statistics: {
+        time: `${performance.measure("command-received", "command-send").duration.toFixed(2)} ms`,
+      },
+    };
+    const snapshotDetails = {
+      id: actionElement.getAttribute("data-blinq-id"),
+      contextId: this.contextElement?.getAttribute("data-blinq-context-id"),
+      doc: this.snapshotCapturer.createSnapshot({
+        excludeSelectors: ["x-bvt-toolbar", "script", "style", "link[rel=stylesheet]"],
+      }),
+    };
+    cmd.snapshotDetails = snapshotDetails;
+    // eventQueue.enqueue(async () => {
+    // await bvtRecorderBindings.validateLocators(snapshotDetails);
+    // });
+    // console.log(cmd);
+    bvtRecorderBindings.recordCommand(cmd);
+  }
+
   // TODO: implement the corresponding logic for the below methods
   setPopupHandlers(_popopHandlers) {
     this.popupHandlers = _popopHandlers;
@@ -894,7 +915,7 @@ class BVTRecorder {
     this.interestedElements.clear();
   }
   processAriaSnapshot(snapshot) {
-    const matchedElements = this.findMatchingElements(snapshot, this.snapshotElements);
+    const matchedElements = this.snapshotUtils.findMatchingElements(snapshot, this.snapshotElements);
     for (const el of matchedElements.values()) {
       const element = el;
       if (element) {

package/bin/assets/scripts/snapshot_capturer.js

@@ -1,155 +1,155 @@
 class SnapshotCapturer {
-    constructor(options = {}) {
-        const {
-            inlineImages = true,
-            inlineStyles = true,
-            excludeSelectors = []
-        } = options;
-        // this.options = {
-        //     inlineImages,
-        //     inlineStyles,
-        //     excludeSelectors
-        // };
-        this.inlineImages = inlineImages;
-        this.inlineStyles = inlineStyles;
-        this.excludeSelectors = excludeSelectors;
+  constructor(options = {}) {
+    const { inlineImages = true, inlineStyles = true, excludeSelectors = [] } = options;
+    // this.options = {
+    //     inlineImages,
+    //     inlineStyles,
+    //     excludeSelectors
+    // };
+    this.inlineImages = inlineImages;
+    this.inlineStyles = inlineStyles;
+    this.excludeSelectors = excludeSelectors;
+  }
+  imageToDataURL(img, document) {
+    try {
+      // Create canvas to draw the image
+      const canvas = document.createElement("canvas");
+      canvas.width = img.naturalWidth || img.width;
+      canvas.height = img.naturalHeight || img.height;
+      const ctx = canvas.getContext("2d");
+
+      // Draw image to canvas and convert to data URL
+      ctx.drawImage(img, 0, 0);
+      return canvas.toDataURL("image/png");
+    } catch (error) {
+      console.warn(`Failed to inline image: ${img.src}`, error);
+      return img.src; // Fall back to original source
     }
-    imageToDataURL(img, document) {
-        try {
-            // Create canvas to draw the image
-            const canvas = document.createElement('canvas');
-            canvas.width = img.naturalWidth || img.width;
-            canvas.height = img.naturalHeight || img.height;
-            const ctx = canvas.getContext('2d');
-
-            // Draw image to canvas and convert to data URL
-            ctx.drawImage(img, 0, 0);
-            return canvas.toDataURL('image/png');
-        } catch (error) {
-            console.warn(`Failed to inline image: ${img.src}`, error);
-            return img.src; // Fall back to original source
-        }
-    }
-    processStyles(document) {
-        if (!this.inlineStyles) return;
-
-        const stylesheets = Array.from(document.styleSheets);
-        for (const sheet of stylesheets) {
-            try {
-                if (!sheet.href) continue; // Skip inline styles
-                const styleEl = document.createElement('style');
-                let text = ""
-                const cssRules = Array.from(sheet.cssRules || []);
-                for (const rule of cssRules) {
-                    if (rule.cssText) {
-                        text += rule.cssText + '\n';
-                    }
-                }
-                styleEl.textContent = text;
-
-                // Replace the link with our new style element
-                if (sheet.ownerNode && sheet.ownerNode.parentNode) {
-                    sheet.ownerNode.parentNode.replaceChild(styleEl, sheet.ownerNode);
-                } else if (sheet.ownerNode) {
-                    // If the owner node is not in the document, just append it
-                    document.head.appendChild(styleEl);
-                }
-
-            } catch (error) {
-                console.warn(`Error processing stylesheet: ${sheet.href}`, error);
-            }
+  }
+  processStyles(document) {
+    if (!this.inlineStyles) return;
+
+    const stylesheets = Array.from(window.document.styleSheets);
+    for (const sheet of stylesheets) {
+      try {
+        const el = sheet.ownerNode.cloneNode(true);
+        if (!el.href) {
+          document.head.appendChild(el);
+        } else {
+          const rules = Array.from(sheet.cssRules)
+            .map((rule) => rule.cssText)
+            .join("\n");
+          const styleEl = document.createElement("style");
+          styleEl.textContent = rules;
+          document.head.appendChild(styleEl);
         }
+      } catch (error) {
+        console.warn(`Error processing stylesheet: ${sheet.href}`, error);
+      }
     }
-    processImages(document) {
-        if (!this.inlineImages) return;
-
-        const images = document.querySelectorAll('img');
-        images.forEach(img => {
-            // Skip SVGs and already data URLs
-            if (img.src.startsWith('data:') || img.src.endsWith('.svg')) return;
-
-            // Skip if the image is excluded
-            if (this.excludeSelectors.some(selector => img.matches(selector))) return;
-
-            // Only inline complete images
-            if (img.complete && img.naturalWidth !== 0) {
-                try {
-                    img.setAttribute('src', this.imageToDataURL(img, document));
-                } catch (e) {
-                    console.warn(`Failed to process image: ${img.src}`, e);
-                }
-            }
-        });
-    }
-    removeExcludedElements(document) {
-        this.excludeSelectors.forEach(selector => {
-            const elements = document.querySelectorAll(selector);
-            elements.forEach(el => {
-                el.parentNode?.removeChild(el);
-            });
-        });
-    }
-    processComputedStyles(document) {
-        const elements = document.querySelectorAll('*');
-
-        elements.forEach(el => {
-            // Skip excluded elements
-            if (this.excludeSelectors.some(selector => el.matches(selector))) return;
-
-            // Get computed style
-            const style = window.getComputedStyle(el);
-
-            // Copy important styles to inline style
-            const importantStyles = [
-                'display', 'position', 'width', 'height', 'margin', 'padding',
-                'color', 'background-color', 'font-family', 'font-size',
-                'text-align', 'line-height', 'border', 'box-shadow', 'opacity'
-                // Add more styles as needed
-            ];
-
-            const inlineStyles = [];
-
-            importantStyles.forEach(prop => {
-                const value = style.getPropertyValue(prop);
-                if (value) {
-                    inlineStyles.push(`${prop}: ${value}`);
-                }
-            });
-
-            // Set inline style
-            if (inlineStyles.length > 0) {
-                const currentStyle = el.getAttribute('style') || '';
-                el.setAttribute('style', currentStyle + inlineStyles.join('; ') + ';');
-            }
-        });
-
-    }
-    createSnapshot() {
-        // Clone the document to avoid modifying the original
-        const docClone = window.document.cloneNode(true);
+  }
+  processImages(document) {
+    if (!this.inlineImages) return;
 
-        // Store the original document
-        const originalDoc = window.document;
+    const images = document.querySelectorAll("img");
+    images.forEach((img) => {
+      // Skip SVGs and already data URLs
+      if (img.src.startsWith("data:") || img.src.endsWith(".svg")) return;
 
-        // Temporarily "swap" the document for processing
-        // (We're just using this as a convention - it doesn't actually replace the global document)
-        const doc = docClone;
+      // Skip if the image is excluded
+      if (this.excludeSelectors.some((selector) => img.matches(selector))) return;
 
-        // Process the clone
-        this.processStyles(doc);
-        this.processImages(doc);
-        this.removeExcludedElements(doc);
-        this.processComputedStyles(doc);
-
-        // Generate HTML with doctype
-        const doctype = originalDoc.doctype ?
-            new XMLSerializer().serializeToString(originalDoc.doctype) : '<!DOCTYPE html>';
-
-        // Get the HTML content
-        const htmlContent = doc.documentElement.outerHTML;
-
-        // Combine doctype and HTML content
-        return `${doctype}${htmlContent}`;
-    }
+      // Only inline complete images
+      if (img.complete && img.naturalWidth !== 0) {
+        try {
+          img.setAttribute("src", this.imageToDataURL(img, document));
+        } catch (e) {
+          console.warn(`Failed to process image: ${img.src}`, e);
+        }
+      }
+    });
+  }
+  removeExcludedElements(document) {
+    this.excludeSelectors.forEach((selector) => {
+      const elements = document.querySelectorAll(selector);
+      elements.forEach((el) => {
+        el.parentNode?.removeChild(el);
+      });
+    });
+  }
+  processComputedStyles(document) {
+    const elements = document.querySelectorAll("*");
+
+    elements.forEach((el) => {
+      // Skip excluded elements
+      if (this.excludeSelectors.some((selector) => el.matches(selector))) return;
+
+      // Get computed style
+      const style = window.getComputedStyle(el);
+
+      // Copy important styles to inline style
+      const importantStyles = [
+        "display",
+        "position",
+        "width",
+        "height",
+        "margin",
+        "padding",
+        "color",
+        "background-color",
+        "font-family",
+        "font-size",
+        "text-align",
+        "line-height",
+        "border",
+        "box-shadow",
+        "opacity",
+        // Add more styles as needed
+      ];
+
+      const inlineStyles = [];
+
+      importantStyles.forEach((prop) => {
+        const value = style.getPropertyValue(prop);
+        if (value) {
+          inlineStyles.push(`${prop}: ${value}`);
+        }
+      });
+
+      // Set inline style
+      if (inlineStyles.length > 0) {
+        const currentStyle = el.getAttribute("style") || "";
+        el.setAttribute("style", currentStyle + inlineStyles.join("; ") + ";");
+      }
+    });
+  }
+  createSnapshot() {
+    // Clone the document to avoid modifying the original
+    const docClone = window.document.cloneNode(true);
+
+    // Store the original document
+    const originalDoc = window.document;
+
+    // Temporarily "swap" the document for processing
+    // (We're just using this as a convention - it doesn't actually replace the global document)
+    const doc = docClone;
+
+    // Process the clone
+    this.processStyles(doc);
+    this.processImages(doc);
+    this.removeExcludedElements(doc);
+    this.processComputedStyles(doc);
+
+    // Generate HTML with doctype
+    const doctype = originalDoc.doctype
+      ? new XMLSerializer().serializeToString(originalDoc.doctype)
+      : "<!DOCTYPE html>";
+
+    // Get the HTML content
+    const htmlContent = doc.documentElement.outerHTML;
+
+    // Combine doctype and HTML content
+    return `${doctype}${htmlContent}`;
+  }
 }
-export default SnapshotCapturer;
+export default SnapshotCapturer;