automation_model 1.0.490-dev → 1.0.490-stage

package/lib/scripts/find_text.js

@@ -0,0 +1,126 @@
+/**
+ * Find elements by universal selector and check if they match the provided text pattern.
+ */
+function findMatchingElements(textToMatch, options = {}, root = document) {
+  function findLeafElements(elements) {
+    const nonLeaf = new Set();
+    elements.forEach((el) => {
+      elements.forEach((otherEl) => {
+        if (el !== otherEl && el.contains(otherEl)) {
+          nonLeaf.add(el);
+        }
+      });
+    });
+    return elements.filter((el) => !nonLeaf.has(el));
+  }
+
+  function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function collectAllShadowDomElements(element, result = []) {
+    // Check and add the element if it has a shadow root
+    if (element instanceof Element && element.shadowRoot) {
+      result.push(element);
+      // Also search within the shadow root
+      collectAllShadowDomElements(element.shadowRoot, result);
+    }
+
+    // Iterate over child nodes
+    element.childNodes.forEach((child) => {
+      // Recursively call the function for each child node
+      if (child instanceof Element) {
+        collectAllShadowDomElements(child, result);
+      }
+    });
+
+    return result;
+  }
+  /**
+   * Convert a single snippet into an OR group for:
+   *   1) literal text
+   *   2) interpreted as a raw regex
+   */
+  function snippetToAlternatives(snippet) {
+    if (snippet.startsWith("/") && snippet.endsWith("/")) {
+      return snippet.slice(1, -1);
+    }
+    const literalPattern = escapeRegex(snippet);
+    return literalPattern;
+  }
+
+  /**
+   * Build a single RegExp that:
+   *   - splits the user's text by whitespace
+   *   - for each token, matches either literal or regex
+   *   - allows arbitrary whitespace between tokens
+   */
+  function buildLooseRegexFromText(text, options) {
+    if (options.singleRegex === true) {
+      return new RegExp(text, options.ignoreCase === false ? "" : "i");
+    }
+    const tokens = text.split(/\s+/);
+    let pattern = tokens.map((token) => snippetToAlternatives(token)).join("\\s*");
+    if (options.exactMatch === true) {
+      pattern = `^${pattern}$`;
+    }
+    // check if one of the tokens end with /i
+    const endWithI = tokens.some((token) => token.endsWith("/i"));
+    return new RegExp(pattern, endWithI || options.ignoreCase === false ? "" : "i");
+  }
+  let climb = 0;
+  // check if the text to merge end with ^ follow by a number (climb), e.g. "some text^2" we should set the climb and remove the ^2 from the text
+  if (textToMatch.match(/\^(\d+)$/)) {
+    climb = parseInt(textToMatch.match(/\^(\d+)$/)[1]);
+    textToMatch = textToMatch.replace(/\^(\d+)$/, "");
+  }
+
+  let tag = options.tag || "*";
+  // Build the pattern
+  const regex = buildLooseRegexFromText(textToMatch, options);
+  // Query all elements
+  let elements = Array.from(root.querySelectorAll(tag));
+
+  let shadowHosts = [];
+  collectAllShadowDomElements(document, shadowHosts);
+  for (let i = 0; i < shadowHosts.length; i++) {
+    let shadowElement = shadowHosts[i].shadowRoot;
+    if (!shadowElement) {
+      continue;
+    }
+    let shadowElements = Array.from(shadowElement.querySelectorAll(tag));
+    elements = elements.concat(shadowElements);
+  }
+
+  // filter out elements that are style or script tags
+  elements = elements.filter((el) => !["STYLE", "SCRIPT", "HEAD"].includes(el.tagName));
+  elements = findLeafElements(
+    elements.filter((el) => {
+      // Normalize text content
+      let normalized = options.innerText === false || !el.innerText ? el.textContent : el.innerText;
+      if (!normalized) {
+        normalized = "";
+      }
+      let normalizedSpace = normalized.replace(/\s+/g, " ").trim();
+      let normalizedNoSpace = normalized.replace(/\s+/g, "").trim();
+      regex.lastIndex = 0; // reset if using 'g'
+      return regex.test(normalizedSpace) || regex.test(normalizedNoSpace);
+    })
+  );
+  // if climb is greater than 0, we should climb up the DOM tree for each element
+  if (climb > 0) {
+    let newElements = [];
+    for (let i = 0; i < elements.length; i++) {
+      let el = elements[i];
+      for (let j = 0; j < climb; j++) {
+        if (!el.parentElement) {
+          break;
+        }
+        el = el.parentElement;
+      }
+      newElements.push(el);
+    }
+    elements = newElements;
+  }
+  return elements;
+}
+window.findMatchingElements = findMatchingElements;

package/lib/stable_browser.d.ts

@@ -1,5 +1,37 @@
 import type { Browser, Page } from "playwright";
-type Params = Record<string, string>;
+import { Params } from "./utils.js";
+export declare const Types: {
+    CLICK: string;
+    NAVIGATE: string;
+    FILL: string;
+    EXECUTE: string;
+    OPEN: string;
+    COMPLETE: string;
+    ASK: string;
+    GET_PAGE_STATUS: string;
+    CLICK_ROW_ACTION: string;
+    VERIFY_ELEMENT_CONTAINS_TEXT: string;
+    VERIFY_PAGE_CONTAINS_TEXT: string;
+    VERIFY_PAGE_CONTAINS_NO_TEXT: string;
+    ANALYZE_TABLE: string;
+    SELECT: string;
+    VERIFY_PAGE_PATH: string;
+    TYPE_PRESS: string;
+    PRESS: string;
+    HOVER: string;
+    CHECK: string;
+    UNCHECK: string;
+    EXTRACT: string;
+    CLOSE_PAGE: string;
+    SET_DATE_TIME: string;
+    SET_VIEWPORT: string;
+    VERIFY_VISUAL: string;
+    LOAD_DATA: string;
+    SET_INPUT: string;
+    WAIT_FOR_TEXT_TO_DISAPPEAR: string;
+    VERIFY_ATTRIBUTE: string;
+    VERIFY_TEXT_WITH_RELATION: string;
+};
 export declare const apps: {};
 declare class StableBrowser {
     browser: Browser;
@@ -12,18 +44,13 @@ declare class StableBrowser {
     networkLogger: null;
     configuration: null;
     appName: string;
+    tags: null;
     constructor(browser: Browser, page: Page, logger?: any, context?: any, world?: any);
     registerEventListeners(context: any): void;
     switchApp(appName: any): Promise<void>;
-    _copyContext(from: any, to: any): void;
-    getWebLogFile(logFolder: string): string;
     registerConsoleLogListener(page: Page, context: any): void;
     registerRequestListener(page: Page, context: any, logFile: string): void;
-    goto(url: string): Promise<void>;
-    _fixUsingParams(text: any, _params: Params): any;
-    _fixLocatorUsingParams(locator: any, _params: Params): any;
-    _isObject(value: any): any;
-    scanAndManipulate(currentObj: any, _params: Params): void;
+    goto(url: string, world?: null): Promise<void>;
     _getLocator(locator: any, scope: any, _params: any): any;
     _locateElmentByTextClimbCss(scope: any, text: any, climb: any, css: any, _params: Params): Promise<string | undefined>;
     _locateElementByText(scope: any, text1: any, tag1: any, regex1: boolean | undefined, partial1: any, _params: Params): Promise<any>;
@@ -32,8 +59,8 @@ declare class StableBrowser {
         rerun: boolean;
     }>;
     _locate(selectors: any, info: any, _params?: Params, timeout: any): Promise<any>;
-    _findFrameScope(selectors: any, timeout?: number): Promise<any>;
-    _getDocumentBody(selectors: any, timeout?: number): Promise<any>;
+    _findFrameScope(selectors: any, timeout: number | undefined, info: any): Promise<any>;
+    _getDocumentBody(selectors: any, timeout: number | undefined, info: any): Promise<any>;
     _locate_internal(selectors: any, info: any, _params?: Params, timeout?: number): Promise<any>;
     _scanLocatorsGroup(locatorsGroup: any, scope: any, _params: any, info: any, visibleOnly: any): Promise<{
         foundElements: any[];
@@ -92,27 +119,32 @@ declare class StableBrowser {
     _screenShot(options?: {}, world?: null, info?: null): Promise<{}>;
     takeScreenshot(screenshotPath: any): Promise<any>;
     verifyElementExistInPage(selectors: any, _params?: null, options?: {}, world?: null): Promise<any>;
-    extractAttribute(selectors: any, attribute: any, variable: any, _params?: null, options?: {}, world?: null): Promise<{}>;
+    extractAttribute(selectors: any, attribute: any, variable: any, _params?: null, options?: {}, world?: null): Promise<any>;
+    verifyAttribute(selectors: any, attribute: any, value: any, _params?: null, options?: {}, world?: null): Promise<any>;
     extractEmailData(emailAddress: any, options: any, world: any): Promise<{
         emailUrl: any;
         emailCode: any;
     }>;
     _highlightElements(scope: any, css: any): Promise<void>;
     verifyPagePath(pathPart: any, options?: {}, world?: null): Promise<{} | undefined>;
-    verifyTextExistInPage(text: any, options?: {}, world?: null): Promise<{}>;
-    _getServerUrl(): string;
-    visualVerification(text: any, options?: {}, world?: null): Promise<{}>;
+    findTextInAllFrames(dateAlternatives: any, numberAlternatives: any, text: any, state: any): Promise<any[]>;
+    verifyTextExistInPage(text: any, options?: {}, world?: null): Promise<any>;
+    waitForTextToDisappear(text: any, options?: {}, world?: null): Promise<any>;
+    verifyTextRelatedToText(textAnchor: string, climb: number, textToVerify: string, options?: {}, world?: any): Promise<any>;
+    visualVerification(text: any, options?: {}, world?: null): Promise<{} | undefined>;
     verifyTableData(selectors: any, data: any, _params?: null, options?: {}, world?: null): Promise<void>;
     getTableData(selectors: any, _params?: null, options?: {}, world?: null): Promise<any>;
-    analyzeTable(selectors: any, query: any, operator: any, value: any, _params?: null, options?: {}, world?: null): Promise<{}>;
+    analyzeTable(selectors: any, query: any, operator: any, value: any, _params?: null, options?: {}, world?: null): Promise<{} | undefined>;
     _replaceWithLocalData(value: any, world: any, _decrypt?: boolean, totpWait?: boolean): Promise<string>;
     _getLoadTimeout(options: any): number;
     waitForPageLoad(options?: {}, world?: null): Promise<void>;
     closePage(options?: {}, world?: null): Promise<void>;
+    saveTestDataAsGlobal(options: any, world: any): void;
     setViewportSize(width: number, hight: number, options?: {}, world?: null): Promise<void>;
     reloadPage(options?: {}, world?: null): Promise<void>;
     scrollIfNeeded(element: any, info: any): Promise<void>;
-    _reportToWorld(world: any, properties: JsonCommandReport): void;
+    beforeStep(world: any, step: any): Promise<void>;
+    afterStep(world: any, step: any): Promise<void>;
 }
 type JsonTimestamp = number;
 type JsonResultPassed = {
@@ -127,7 +159,7 @@ type JsonResultFailed = {
     message?: string;
 };
 type JsonCommandResult = JsonResultPassed | JsonResultFailed;
-type JsonCommandReport = {
+export type JsonCommandReport = {
     type: string;
     value?: string;
     text: string;