@intuned/browser-dev 2.2.3-test-build.0

package/dist/common/matching/matching.js

@@ -0,0 +1,317 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterAndRankMatches = filterAndRankMatches;
+exports.isMatchExact = isMatchExact;
+exports.matchStringsWithDomContent = matchStringsWithDomContent;
+exports.matchStringsWithDomContentInBrowser = matchStringsWithDomContentInBrowser;
+exports.normalizeSpacing = normalizeSpacing;
+exports.rankMatch = rankMatch;
+exports.removePunctuationAndSpaces = removePunctuationAndSpaces;
+exports.replaceWithBestMatches = replaceWithBestMatches;
+exports.selectBestMatch = selectBestMatch;
+var _utils = require("../../helpers/utils");
+const logger = {
+  info: message => console.info(message),
+  warning: message => console.warn(message),
+  error: message => console.error(message)
+};
+function normalizeSpacing({
+  text
+}) {
+  let normalized = text.replace(/\n/g, " ").replace(/\t/g, " ");
+  normalized = normalized.split(/\s+/).join(" ");
+  return normalized.trim();
+}
+function isMatchExact({
+  data,
+  value
+}) {
+  if (data === "" || value === "") {
+    return [false, ""];
+  }
+  const normalizedData = normalizeSpacing({
+    text: data
+  });
+  const normalizedValue = normalizeSpacing({
+    text: value
+  });
+  return [normalizedData.toLowerCase() === normalizedValue.toLowerCase(), normalizedValue];
+}
+function removePunctuationAndSpaces({
+  s
+}) {
+  const punctuation = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+  return s.split("").filter(c => !punctuation.includes(c) && c !== " ").join("");
+}
+function rankMatch({
+  original,
+  match
+}) {
+  try {
+    const normalizedOriginal = normalizeSpacing({
+      text: original
+    }).toLowerCase();
+    const normalizedMatch = normalizeSpacing({
+      text: match
+    }).toLowerCase();
+    const ratio = calculateSimilarityRatio(normalizedOriginal, normalizedMatch);
+    const lenOriginal = normalizedOriginal.length;
+    if (lenOriginal > 20 && ratio > 0.85) {
+      return "HIGH";
+    }
+    const normalizedOriginalNoPunct = removePunctuationAndSpaces({
+      s: normalizedOriginal
+    });
+    const normalizedMatchNoPunct = removePunctuationAndSpaces({
+      s: normalizedMatch
+    });
+    if (normalizedOriginalNoPunct === normalizedMatchNoPunct) {
+      return "HIGH";
+    }
+    return "LOW";
+  } catch (error) {
+    logger.warning("Error in rankMatch, falling back to simple comparison");
+    const normalizedOriginal = removePunctuationAndSpaces({
+      s: normalizeSpacing({
+        text: original
+      }).toLowerCase()
+    });
+    const normalizedMatch = removePunctuationAndSpaces({
+      s: normalizeSpacing({
+        text: match
+      }).toLowerCase()
+    });
+    if (normalizedOriginal === normalizedMatch) {
+      return "HIGH";
+    }
+    return "LOW";
+  }
+}
+function calculateSimilarityRatio(str1, str2) {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  if (longer.length === 0) {
+    return 1.0;
+  }
+  return (longer.length - editDistance(longer, shorter)) / longer.length;
+}
+function editDistance(str1, str2) {
+  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+  for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= str2.length; j++) {
+    for (let i = 1; i <= str1.length; i++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        matrix[j][i] = matrix[j - 1][i - 1];
+      } else {
+        matrix[j][i] = Math.min(matrix[j - 1][i - 1] + 1, matrix[j][i - 1] + 1, matrix[j - 1][i] + 1);
+      }
+    }
+  }
+  return matrix[str2.length][str1.length];
+}
+function selectBestMatch({
+  original,
+  matches
+}) {
+  const exactMatches = matches.filter(match => match.match_mode !== "fuzzy");
+  if (exactMatches.length > 0) {
+    const bestMatch = exactMatches[0];
+    return {
+      matchText: bestMatch.matched_value,
+      matchXpath: bestMatch.xpath,
+      matchType: bestMatch.match_source === "direct_text_node" ? "direct-text" : bestMatch.match_source === "attribute" ? {
+        attribute: "unknown"
+      } : "all-text"
+    };
+  }
+  const fuzzyMatches = matches.filter(match => match.match_mode === "fuzzy");
+  const rankedFuzzyMatches = fuzzyMatches.map(match => ({
+    match,
+    rank: rankMatch({
+      original,
+      match: match.matched_value
+    })
+  }));
+  const highRankedMatches = rankedFuzzyMatches.filter(item => item.rank === "HIGH");
+  const filteredFuzzyMatches = highRankedMatches.map(item => item.match);
+  if (filteredFuzzyMatches.length > 0) {
+    const sortedFuzzyMatches = filteredFuzzyMatches.sort((a, b) => (a.fuzzy_distance || Infinity) - (b.fuzzy_distance || Infinity));
+    const bestMatch = sortedFuzzyMatches[0];
+    return {
+      matchText: bestMatch.matched_value,
+      matchXpath: bestMatch.xpath,
+      matchType: bestMatch.match_source === "direct_text_node" ? "direct-text" : bestMatch.match_source === "attribute" ? {
+        attribute: "unknown"
+      } : "all-text"
+    };
+  }
+  return null;
+}
+async function matchStringsWithDomContent({
+  pageObject,
+  stringsList,
+  container = null
+}) {
+  try {
+    await (0, _utils.ensureBrowserScripts)(pageObject);
+    let handle;
+    if (container) {
+      handle = container;
+    } else {
+      handle = await pageObject.locator("html").elementHandle();
+    }
+    const matches = await pageObject.evaluate(async args => {
+      const [container, searchTexts] = args;
+      try {
+        if (typeof window.__INTUNED__ !== "undefined" && typeof window.__INTUNED__.matchStringsWithDomContent === "function") {
+          return await window.__INTUNED__.matchStringsWithDomContent(container, searchTexts);
+        } else {
+          return searchTexts.reduce((acc, text) => {
+            acc[text] = [];
+            return acc;
+          }, {});
+        }
+      } catch (error) {
+        console.error("Error matching strings with DOM content:", error);
+        return searchTexts.reduce((acc, text) => {
+          acc[text] = [];
+          return acc;
+        }, {});
+      }
+    }, [handle, stringsList]);
+    return matches;
+  } catch (error) {
+    logger.warning(`Error matching strings with DOM content: ${error}`);
+    return stringsList.reduce((acc, string) => {
+      acc[string] = [];
+      return acc;
+    }, {});
+  }
+}
+async function replaceWithBestMatches({
+  stringsToMatch,
+  pageObject,
+  container = null
+}) {
+  const matchesMap = await matchStringsWithDomContent({
+    pageObject,
+    stringsList: stringsToMatch,
+    container
+  });
+  const replacements = {};
+  const xpathMapping = {};
+  for (const [string, matches] of Object.entries(matchesMap)) {
+    const bestMatch = matches.length > 0 ? selectBestMatch({
+      original: string,
+      matches
+    }) : null;
+    replacements[string] = bestMatch;
+    if (bestMatch) {
+      xpathMapping[bestMatch.matchText] = [{
+        xpath: bestMatch.matchXpath,
+        matchType: bestMatch.matchType
+      }];
+    }
+  }
+  return {
+    replacements,
+    xpathMapping
+  };
+}
+async function filterAndRankMatches(frame, matches) {
+  const filteredMatches = matches.filter(match => {
+    const xpath = match.xpath;
+    return !(xpath.includes("[name()='svg']/") || xpath.includes("/path") || xpath.includes("/style"));
+  });
+  async function getVisibility(match) {
+    try {
+      const locator = frame.locator(`xpath=${match.xpath}`);
+      return await locator.isVisible({
+        timeout: 100
+      });
+    } catch {
+      return false;
+    }
+  }
+  const visibilityResults = await Promise.all(filteredMatches.map(match => getVisibility(match)));
+  const modeOrder = {
+    full: 3,
+    partial: 2,
+    fuzzy: 1
+  };
+  const sourceOrder = {
+    direct_text_node: 3,
+    text_content: 2,
+    attribute: 1
+  };
+  function sortKey(match, visible) {
+    const modeKey = modeOrder[match.match_mode.toLowerCase()] || 0;
+    const sourceKey = sourceOrder[match.match_source.toLowerCase()] || 0;
+    const visibleKey = visible ? 1 : 0;
+    let partialScore = 0;
+    if (match.match_mode.toLowerCase() === "partial" && match.matched_source_value && match.matched_value) {
+      const extraChars = match.matched_source_value.length - match.matched_value.length;
+      if (extraChars === 0) {
+        partialScore = 1;
+      } else {
+        partialScore = 1 / extraChars;
+      }
+    }
+    return modeKey + sourceKey + visibleKey + partialScore;
+  }
+  const matchesWithVisibility = filteredMatches.map((match, index) => ({
+    match,
+    visible: visibilityResults[index]
+  }));
+  const sortedMatchesWithVisibility = matchesWithVisibility.sort((a, b) => sortKey(b.match, b.visible) - sortKey(a.match, a.visible));
+  const sortedMatches = sortedMatchesWithVisibility.map(item => item.match);
+  const seenXpaths = new Set();
+  const uniqueMatches = [];
+  for (const match of sortedMatches) {
+    if (seenXpaths.has(match.xpath)) {
+      continue;
+    }
+    seenXpaths.add(match.xpath);
+    uniqueMatches.push(match);
+  }
+  return uniqueMatches;
+}
+async function matchStringsWithDomContentInBrowser(frame, stringsList, container = null) {
+  let handle;
+  if (container) {
+    handle = await container.elementHandle();
+  } else {
+    handle = await frame.locator("html").elementHandle();
+  }
+  logger.info(`Searching for ${stringsList.length} strings in the DOM, ${stringsList}`);
+  const matches = await frame.evaluate(async args => {
+    const [container, searchTexts] = args;
+    const result = await window.__INTUNED__.matchStringsWithDomContent(container, searchTexts);
+    return result;
+  }, [handle, stringsList]);
+  let frames = [];
+  if ("childFrames" in frame) {
+    frames = frame.childFrames();
+  } else if ("frames" in frame) {
+    frames = frame.frames();
+  }
+  for (const subframe of frames) {
+    try {
+      const frameMatches = await matchStringsWithDomContentInBrowser(subframe, stringsList, null);
+      for (const [string, stringMatches] of Object.entries(frameMatches)) {
+        if (string in matches) {
+          matches[string].extend(stringMatches);
+        } else {
+          matches[string] = stringMatches;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return matches;
+}

package/dist/common/matching/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/common/noEmpty.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = noEmpty;
+function noEmpty(value) {
+  return value !== null && value !== undefined;
+}

package/dist/common/saveSnapshotWithExamples.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__saveSnapshotWithExamples = __saveSnapshotWithExamples;
+exports.__saveSnapshotWithExamplesFromPage = __saveSnapshotWithExamplesFromPage;
+var _clientS = require("@aws-sdk/client-s3");
+var z = _interopRequireWildcard(require("zod"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function shouldSkipCaptureSnapshots() {
+  return process.env.DISABLE_CAPTURE_EXAMPLE === "true";
+}
+async function __saveSnapshotWithExamplesFromPage(page, snapshotName, examples, s3Configs) {
+  const html = await page.content();
+  const url = page.url();
+  return __saveSnapshotWithExamples(snapshotName, examples, html, url, s3Configs);
+}
+async function __saveSnapshotWithExamples(snapshotName, examples, html, url, s3Configs) {
+  if (shouldSkipCaptureSnapshots()) {
+    return;
+  }
+  const origin = new URL(url).origin;
+  const defaultConfigs = {
+    accessKeyId: process.env.SNAPSHOT_S3_ACCESS_KEY_ID,
+    bucket: process.env.SNAPSHOT_S3_BUCKET,
+    folderName: process.env.SNAPSHOT_S3_FOLDER,
+    region: process.env.SNAPSHOT_S3_REGION,
+    secretAccessKey: process.env.SNAPSHOT_S3_SECRET_ACCESS_KEY
+  };
+  const schema = z.record(z.string(), z.any());
+  const parsedConfigs = schema.safeParse({
+    ...defaultConfigs,
+    ...s3Configs
+  });
+  if (parsedConfigs.success === false) {
+    return;
+  }
+  const configs = parsedConfigs.data;
+  const folderPath = `${configs.folderName}`;
+  const client = new _clientS.S3Client({
+    region: configs.region,
+    credentials: {
+      accessKeyId: configs.accessKeyId,
+      secretAccessKey: configs.secretAccessKey
+    }
+  });
+  const snapshotJson = {
+    origin,
+    html,
+    examples
+  };
+  await client.send(new _clientS.PutObjectCommand({
+    Bucket: configs.bucket,
+    Key: `${folderPath}/${snapshotName}.json`,
+    Body: JSON.stringify(snapshotJson),
+    ContentType: "application/json"
+  }));
+  console.log("Snapshot saved successfully.", snapshotName);
+}

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: false
+    });
+  });
+  (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.clickButtonUntilNoChange = 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 clickButtonUntilNoChange = 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.clickButtonUntilNoChange = clickButtonUntilNoChange;