@intuned/browser-dev 0.1.4-dev.0

package/dist/optimized-extractors/common/isTableHeaderOrFooter.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTableHeaderOrFooter = isTableHeaderOrFooter;
+var _anthropicModel = require("../models/anthropicModel");
+var _zod = require("zod");
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("../types/errors"));
+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); }
+async function isTableHeaderOrFooter(content) {
+  var _response$error;
+  if (!content) {
+    return (0, _neverthrow.ok)({
+      isHeader: false
+    });
+  }
+  const anthropic = (0, _anthropicModel.createAnthropicInstance)();
+  const itemContent = typeof content === "string" ? {
+    type: "text",
+    text: content
+  } : {
+    type: "image",
+    source: {
+      data: content.toString("base64"),
+      media_type: "image/png",
+      type: "base64"
+    }
+  };
+  const response = await (0, _neverthrow.fromPromise)(anthropic.messages.create({
+    max_tokens: 4096,
+    temperature: 0,
+    messages: [{
+      role: "user",
+      content: [{
+        type: "text",
+        text: `given the following content, you need to decide if the content is a html table header or a table footer, 
+            a table header is a row that contains labels for table columns, and footer usually has pagination information or summary of the table`
+      }, itemContent]
+    }],
+    model: "claude-3-haiku-20240307",
+    tools: [{
+      input_schema: {
+        type: "object",
+        properties: {
+          isTableHeaderOrFooter: {
+            type: "boolean"
+          }
+        },
+        required: ["isTableHeaderOrFooter"]
+      },
+      name: "is_table_header_or_footer",
+      description: `given a text or image content, decide if the content is a table header or footer or not.`
+    }]
+  }), error => {
+    const typedError = error;
+    if (typedError.status === 449) return Errors.insufficientAiCredits(`🔴 ${typedError.error.error}`);
+  });
+  if (response.isErr() && ((_response$error = response.error) === null || _response$error === void 0 ? void 0 : _response$error.type) === "InsufficientAiCredits") {
+    return (0, _neverthrow.err)(response.error);
+  }
+  if (response.isErr()) {
+    return (0, _neverthrow.ok)({
+      isHeader: false
+    });
+  }
+  const unwrappedResponse = response.value;
+  const tool = unwrappedResponse.content.find(t => t.type === "tool_use");
+  if (!tool) return (0, _neverthrow.ok)({
+    isHeader: false
+  });
+  const headersParsingResults = _zod.z.object({
+    isTableHeaderOrFooter: _zod.z.boolean()
+  }).safeParse(tool.input);
+  if (!headersParsingResults.success) {
+    return (0, _neverthrow.ok)({
+      isHeader: false
+    });
+  }
+  return (0, _neverthrow.ok)({
+    isHeader: headersParsingResults.data.isTableHeaderOrFooter
+  });
+}

package/dist/optimized-extractors/common/matching/matching.js

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MatchSource = exports.MatchMode = void 0;
+exports.filterAndRankMatches = filterAndRankMatches;
+exports.matchStringsWithDomContent = matchStringsWithDomContent;
+exports.matchStringsWithDomContentInBrowser = matchStringsWithDomContentInBrowser;
+exports.normalizeSpacing = normalizeSpacing;
+exports.rankMatch = rankMatch;
+exports.removePunctuationAndSpaces = removePunctuationAndSpaces;
+exports.replaceWithBestMatches = replaceWithBestMatches;
+exports.selectBestMatch = selectBestMatch;
+var _levenshtein = require("../../../common/matching/levenshtein");
+var _ensureBrowserScripts = require("../../../common/ensureBrowserScripts");
+let MatchMode = exports.MatchMode = function (MatchMode) {
+  MatchMode["FULL"] = "full";
+  MatchMode["PARTIAL"] = "partial";
+  MatchMode["FUZZY"] = "fuzzy";
+  return MatchMode;
+}({});
+let MatchSource = exports.MatchSource = function (MatchSource) {
+  MatchSource["ATTRIBUTE"] = "attribute";
+  MatchSource["TEXT_CONTENT"] = "text_content";
+  MatchSource["DIRECT_TEXT_NODE"] = "direct_text_node";
+  return MatchSource;
+}({});
+function normalizeSpacing(text) {
+  let normalized = text.replace(/\n/g, " ").replace(/\t/g, " ");
+  normalized = normalized.split(/\s+/).join(" ");
+  return normalized.trim();
+}
+function removePunctuationAndSpaces(s) {
+  return s.replace(/[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~\s]/g, "");
+}
+function rankMatch(original, match) {
+  try {
+    const normalizedOriginal = normalizeSpacing(original).toLowerCase();
+    const normalizedMatch = normalizeSpacing(match).toLowerCase();
+    const ratio = (0, _levenshtein.levenshteinRatio)(normalizedOriginal, normalizedMatch);
+    const lenOriginal = normalizedOriginal.length;
+    if (lenOriginal > 20 && ratio > 0.85) {
+      return "HIGH";
+    }
+    const normalizedOriginalNoPunct = removePunctuationAndSpaces(normalizedOriginal);
+    const normalizedMatchNoPunct = removePunctuationAndSpaces(normalizedMatch);
+    if (normalizedOriginalNoPunct === normalizedMatchNoPunct) {
+      return "HIGH";
+    }
+    return "LOW";
+  } catch (error) {
+    console.warn("Error in rankMatch, falling back to simple comparison", error);
+    const normalizedOriginal = removePunctuationAndSpaces(normalizeSpacing(original).toLowerCase());
+    const normalizedMatch = removePunctuationAndSpaces(normalizeSpacing(match).toLowerCase());
+    if (normalizedOriginal === normalizedMatch) {
+      return "HIGH";
+    }
+    return "LOW";
+  }
+}
+function selectBestMatch(original, matches) {
+  const exactMatches = matches.filter(match => match.match_mode !== MatchMode.FUZZY);
+  if (exactMatches.length > 0) {
+    return exactMatches[0].matched_value;
+  }
+  const fuzzyMatches = matches.filter(match => match.match_mode === MatchMode.FUZZY);
+  const rankedFuzzyMatches = fuzzyMatches.map(match => ({
+    match,
+    rank: rankMatch(original, match.matched_value)
+  })).filter(({
+    rank
+  }) => rank === "HIGH");
+  if (rankedFuzzyMatches.length > 0) {
+    const sortedFuzzyMatches = rankedFuzzyMatches.sort((a, b) => {
+      const distA = a.match.fuzzy_distance ?? Infinity;
+      const distB = b.match.fuzzy_distance ?? Infinity;
+      return distA - distB;
+    });
+    return sortedFuzzyMatches[0].match.matched_value;
+  }
+  return null;
+}
+async function matchStringsWithDomContent(pageObject, stringsList, container) {
+  try {
+    await (0, _ensureBrowserScripts.ensureBrowserScripts)(pageObject);
+    let handle;
+    if (container) {
+      handle = container;
+    } else {
+      handle = await pageObject.locator("html").elementHandle();
+    }
+    const matches = await pageObject.evaluate(async ([container, searchTexts]) => {
+      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 (e) {
+    console.warn("Error matching strings with DOM content:", e);
+    return stringsList.reduce((acc, string) => {
+      acc[string] = [];
+      return acc;
+    }, {});
+  }
+}
+async function replaceWithBestMatches(stringsToMatch, pageObject, container) {
+  const matchesMap = await matchStringsWithDomContent(pageObject, stringsToMatch, container);
+  return Object.fromEntries(Object.entries(matchesMap).map(([string, matches]) => [string, matches.length > 0 ? selectBestMatch(string, matches) : string]));
+}
+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 visibilityPromises = filteredMatches.map(match => getVisibility(match));
+  const visibilityResults = await Promise.all(visibilityPromises);
+  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;
+      partialScore = extraChars === 0 ? 1 : 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) {
+  let handle;
+  if (container) {
+    handle = await container.elementHandle();
+  } else {
+    handle = await frame.locator("html").elementHandle();
+  }
+  console.info(`Searching for ${stringsList.length} strings in the DOM:`, stringsList);
+  const matches = await frame.evaluate(async ([container, searchTexts]) => {
+    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].push(...stringMatches);
+        } else {
+          matches[string] = stringMatches;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return matches;
+}