@intuned/browser-dev 0.1.4-dev.0

package/dist/common/tests/testEnsureBrowserScript.spec.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _extendedTest = require("../extendedTest");
+var _ensureBrowserScripts = require("../ensureBrowserScripts");
+var _playwright = require("playwright");
+var _dotenv = require("dotenv");
+(0, _dotenv.config)();
+(0, _extendedTest.describe)("goToUrl E2E Tests", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwright.chromium.launch({
+      headless: true
+    });
+  });
+  (0, _extendedTest.afterAll)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.beforeEach)(async () => {
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await page.close();
+  });
+  (0, _extendedTest.describe)("ensureBrowserScripts", () => {
+    (0, _extendedTest.test)("should ensure browser scripts are loaded", async () => {
+      await (0, _ensureBrowserScripts.ensureBrowserScripts)(page);
+      (0, _extendedTest.expect)(await page.evaluate("typeof window.__INTUNED__")).toBe("object");
+    });
+  });
+});

package/dist/common/xpathMapping.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createXPathMapping = createXPathMapping;
+exports.validateXPathMapping = validateXPathMapping;
+var _ensureBrowserScripts = require("./ensureBrowserScripts");
+async function validateXPathMapping(page, cachedMapping, prefix) {
+  try {
+    for (const [expectedText, entries] of Object.entries(cachedMapping)) {
+      for (const entry of entries) {
+        const {
+          xpath,
+          matchType
+        } = entry;
+        const elementExists = await page.evaluate(({
+          xpath,
+          prefix
+        }) => {
+          const element = document.evaluate(prefix ? `${prefix}/${xpath}` : xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          return element !== null;
+        }, {
+          xpath,
+          prefix
+        });
+        if (!elementExists) {
+          return false;
+        }
+        const actualText = await page.evaluate(({
+          xpath,
+          prefix,
+          matchType
+        }) => {
+          const element = document.evaluate(prefix ? `${prefix}/${xpath}` : xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          if (!element) return "";
+          if (matchType === "direct-text") {
+            let directText = "";
+            for (const child of element.childNodes) {
+              if (child.nodeType === Node.TEXT_NODE) {
+                directText += child.textContent || "";
+              }
+            }
+            return directText.trim();
+          } else if (matchType === "all-text") {
+            var _element$textContent;
+            return ((_element$textContent = element.textContent) === null || _element$textContent === void 0 ? void 0 : _element$textContent.trim()) || "";
+          } else if (typeof matchType === "object" && matchType.attribute) {
+            return element.getAttribute(matchType.attribute) || "";
+          }
+          return "";
+        }, {
+          xpath,
+          prefix,
+          matchType
+        });
+        if (actualText !== expectedText) {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function createXPathMapping(page, extractedData) {
+  const xpathMapping = {};
+  let uniqueValues = [];
+  await (0, _ensureBrowserScripts.ensureBrowserScripts)(page);
+  if (Array.isArray(extractedData)) {
+    if (extractedData.length > 0 && typeof extractedData[0] === "string") {
+      uniqueValues = [...new Set(extractedData)];
+    } else {
+      uniqueValues = [...new Set(extractedData.flatMap(obj => Object.values(obj)))];
+    }
+  } else if (extractedData && typeof extractedData === "object") {
+    uniqueValues = [...new Set(Object.values(extractedData).filter(value => value !== null))];
+  }
+  for (const value of uniqueValues) {
+    xpathMapping[value] = [];
+    const strategies = [{
+      locatorFn: () => page.getByText(value, {
+        exact: true
+      }),
+      matchType: "all-text"
+    }];
+    for (const strategy of strategies) {
+      const locators = strategy.locatorFn();
+      const count = await locators.count();
+      for (let i = 0; i < count; i++) {
+        const locator = locators.nth(i);
+        const xpath = await locator.evaluate(el => {
+          return window.__INTUNED__.getElementXPath(el);
+        });
+        const existingEntry = xpathMapping[value].find(entry => entry.xpath === xpath);
+        if (!existingEntry) {
+          xpathMapping[value].push({
+            xpath,
+            matchType: strategy.matchType
+          });
+        }
+      }
+    }
+  }
+  return xpathMapping;
+}

package/dist/helpers/clickUntilExhausted.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clickUntilExhausted = exports.clickButtonAndWait = void 0;
+var _withNetworkSettledWait = require("./withNetworkSettledWait");
+var _Logger = require("../common/Logger");
+const getContainerState = async container => {
+  const count = await container.count();
+  if (count > 0) {
+    return await container.locator("> *").count();
+  }
+  return await container.evaluate(element => element.scrollHeight);
+};
+const clickButtonAndWaitInternal = async (page, buttonLocator, clickDelay) => {
+  await buttonLocator.scrollIntoViewIfNeeded();
+  await buttonLocator.click({
+    force: true
+  });
+  await new Promise(resolve => setTimeout(resolve, clickDelay * 1000));
+};
+const clickButtonAndWait = async input => {
+  const {
+    page,
+    buttonLocator,
+    clickDelay = 0.5
+  } = input;
+  await (0, _withNetworkSettledWait.withNetworkSettledWait)(async () => {
+    await clickButtonAndWaitInternal(page, buttonLocator, clickDelay);
+  }, {
+    page,
+    maxInflightRequests: 0,
+    timeoutInMs: 10000
+  });
+};
+exports.clickButtonAndWait = clickButtonAndWait;
+const clickUntilExhausted = async input => {
+  const {
+    page,
+    buttonLocator,
+    heartbeat = undefined,
+    containerLocator = undefined,
+    maxClicks = 50,
+    clickDelay = 0.5,
+    noChangeThreshold = 0
+  } = input;
+  await (0, _withNetworkSettledWait.withNetworkSettledWait)(async () => {
+    let prevState = null;
+    if (containerLocator) {
+      prevState = await getContainerState(containerLocator);
+      _Logger.logger.info(`Initial container state: ${prevState}`);
+    }
+    const buttonCount = await buttonLocator.count();
+    _Logger.logger.info(`Button matches: ${buttonCount}`);
+    for (let i = 0; i < maxClicks; i++) {
+      heartbeat === null || heartbeat === void 0 || heartbeat();
+      const isVisible = await buttonLocator.isVisible();
+      if (!isVisible) {
+        _Logger.logger.info("Button not visible, stopping.");
+        break;
+      }
+      const isEnabled = await buttonLocator.isEnabled();
+      if (!isEnabled) {
+        _Logger.logger.info("Button not enabled, stopping.");
+        break;
+      }
+      await clickButtonAndWaitInternal(page, buttonLocator, clickDelay);
+      if (containerLocator) {
+        const currentState = await getContainerState(containerLocator);
+        _Logger.logger.info(`Current container state: ${currentState}`);
+        if (prevState !== null && currentState - prevState <= noChangeThreshold) {
+          _Logger.logger.info(`No significant change in container state: ${currentState} (previous: ${prevState})`);
+          break;
+        }
+        prevState = currentState;
+      }
+    }
+  }, {
+    page,
+    maxInflightRequests: 0,
+    timeoutInMs: 30000
+  });
+};
+exports.clickUntilExhausted = clickUntilExhausted;

package/dist/helpers/downloadFile.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.downloadFile = void 0;
+var _asyncMutex = require("async-mutex");
+var _utils = require("./utils/");
+var _resolveUrl = require("./resolveUrl");
+const downloadMutex = new _asyncMutex.Mutex();
+function isValidURL(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+async function getAbsoluteUrl(page, url) {
+  try {
+    const url_locator = page.locator(`a[href='${url}']`);
+    if ((await url_locator.count()) > 0) {
+      const href = await url_locator.evaluate(element => element.href);
+      return href;
+    }
+  } catch (error) {
+    console.error("Error getting absolute URL:", error);
+  }
+  const absUrl = await (0, _resolveUrl.resolveUrl)({
+    url,
+    page
+  });
+  return absUrl;
+}
+const downloadFile = async input => {
+  const {
+    page,
+    trigger,
+    timeoutInMs
+  } = input;
+  let pageToDownloadFrom = page;
+  let shouldClosePage = false;
+  let downloadPromise;
+  let isInvalidUrl = false;
+  const isUrlTrigger = trigger => {
+    return typeof trigger === "string";
+  };
+  const isCallableTrigger = trigger => {
+    return typeof trigger === "function";
+  };
+  const isLocatorTrigger = trigger => {
+    return typeof trigger === "object" && trigger !== null && "click" in trigger;
+  };
+  if (isUrlTrigger(trigger)) {
+    pageToDownloadFrom = await page.context().newPage();
+    shouldClosePage = true;
+  }
+  let action;
+  let absoluteUrl;
+  const release = await downloadMutex.acquire();
+  try {
+    downloadPromise = pageToDownloadFrom.waitForEvent("download", {
+      timeout: (timeoutInMs ?? 5000) + 1000
+    });
+    if (isUrlTrigger(trigger)) {
+      absoluteUrl = await getAbsoluteUrl(page, trigger);
+      if (!isValidURL(absoluteUrl)) {
+        isInvalidUrl = true;
+        console.warn(`Url is not valid, the download might not be triggered correctly. ${absoluteUrl}`);
+      }
+      try {
+        action = await pageToDownloadFrom.goto(absoluteUrl);
+        if (!action) {
+          throw new Error(`Failed to navigate to ${absoluteUrl}`);
+        }
+        const contentType = action.headers()["content-type"];
+        if (contentType && contentType.startsWith("image/")) {
+          await pageToDownloadFrom.evaluate(fullURL => {
+            const link = document.createElement("a");
+            link.href = fullURL;
+            link.download = "";
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+          }, absoluteUrl);
+          downloadPromise.catch(() => {
+            console.error(`Download was cancelled for URL: ${absoluteUrl}`);
+          });
+        }
+      } catch (error) {
+        console.error("Error during download:", error);
+      }
+    } else if (isCallableTrigger(trigger)) {
+      action = await trigger(page);
+    } else if (isLocatorTrigger(trigger)) {
+      action = await trigger.click();
+    }
+    const download = await downloadPromise;
+    if ((0, _utils.isGenerateCodeMode)()) {
+      download.cancel();
+    }
+    return download;
+  } catch (error) {
+    if (isUrlTrigger(trigger) && !isInvalidUrl) {
+      const notFoundPatterns = ["404", "not found", "page not found", "page doesn't exist", "page does not exist", "resource not found"];
+      for (const pattern of notFoundPatterns) {
+        if ((await pageToDownloadFrom.getByText(pattern).count()) > 0) {
+          throw new Error(`Download timeout for url:${trigger}. Page appears to be a 404 page.`);
+        }
+      }
+    } else if (error instanceof Error && isLocatorTrigger(trigger)) {
+      throw new Error(`Failed to download file: ${error.message} Download was never triggered`);
+    } else if (error instanceof Error && isCallableTrigger(trigger)) {
+      throw new Error(`Failed to download file: ${error.message} Download was never triggered`);
+    } else if (isInvalidUrl) {
+      throw new Error(`Failed to download file: ${error.message} Url is not valid, the download did not trigger correctly.`);
+    }
+  } finally {
+    if (shouldClosePage) {
+      await pageToDownloadFrom.close();
+    }
+    release();
+  }
+};
+exports.downloadFile = downloadFile;

package/dist/helpers/export.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});