@intuned/browser-dev 0.1.9-dev.0 → 0.1.10-dev.0

package/dist/ai/extractStructuredData.js

@@ -15,7 +15,8 @@ var _getSimplifiedHtml = require("../common/getSimplifiedHtml");
 var _hashObject = require("../common/hashObject");
 var _Logger = require("../common/Logger");
 var _helpers = require("../helpers");
-var _xpathMapping = require("../common/xpathMapping");
+var _frame_utils = require("../common/frame_utils");
+var _matching = require("../common/matching/matching");
 const extractStructuredData = async options => {
   if ("content" in options && !("source" in options)) {
     return await extractStructuredDataFromContent(options);
@@ -57,11 +58,7 @@ const extractStructuredData = async options => {
   }
   let cacheKey = "";
   if (validatedData.strategy === "HTML") {
-    const containerHandle = isPageInput ? await pageOrLocator.locator("html").elementHandle() : await pageOrLocator.elementHandle();
-    if (!containerHandle) {
-      throw new Error("No HTML content found in the specified region.");
-    }
-    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(containerHandle);
+    const simplifiedHtml = await (0, _frame_utils.getContentWithNestedIframes)(pageOrLocator, 10000, _getSimplifiedHtml.getSimplifiedHtml);
     if (validatedData.enableCache) {
       cacheKey = (0, _hashObject.hashObject)({
         pageUrl: pageObject.url(),
@@ -76,7 +73,7 @@ const extractStructuredData = async options => {
       }, true);
       const cachedResult = await _cache.cache.get(cacheKey);
       if (validatedData.enableDomMatching && cachedResult && cachedResult.matchesMapping) {
-        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedResult.matchesMapping);
+        const isValid = await (0, _matching.validateMatchesMapping)(pageObject, cachedResult.matchesMapping);
         if (isValid) {
           _Logger.logger.info("Returning cached result with valid DOM matching");
           return cachedResult.result;
@@ -106,9 +103,10 @@ const extractStructuredData = async options => {
       if (!validatedData.enableDomMatching) {
         await _cache.cache.set(cacheKey, result.value.result);
       } else {
+        const domValidationHash = await (0, _matching.createMatchesMapping)(pageObject, result.value.result);
         const resultsToCache = {
           result: result.value.result,
-          matchesMapping: result.value.xpathMapping || {}
+          matchesMapping: domValidationHash
         };
         await _cache.cache.set(cacheKey, resultsToCache);
       }
@@ -132,7 +130,7 @@ const extractStructuredData = async options => {
       }, true);
       const cachedResult = await _cache.cache.get(cacheKey);
       if (validatedData.enableDomMatching && cachedResult && cachedResult.matchesMapping) {
-        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedResult.matchesMapping);
+        const isValid = await (0, _matching.validateMatchesMapping)(pageObject, cachedResult.matchesMapping);
         if (isValid) {
           _Logger.logger.info("Returning cached result with valid DOM matching");
           return cachedResult.result;
@@ -168,9 +166,10 @@ const extractStructuredData = async options => {
       if (!validatedData.enableDomMatching) {
         await _cache.cache.set(cacheKey, result.value.result);
       } else {
+        const domValidationHash = await (0, _matching.createMatchesMapping)(pageObject, result.value.result);
         const resultsToCache = {
           result: result.value.result,
-          matchesMapping: result.value.xpathMapping || {}
+          matchesMapping: domValidationHash
         };
         await _cache.cache.set(cacheKey, resultsToCache);
       }
@@ -178,13 +177,8 @@ const extractStructuredData = async options => {
     return result.value.result;
   }
   if (validatedData.strategy === "MARKDOWN") {
-    const containerHandle = isPageInput ? await pageOrLocator.locator("html").elementHandle() : await pageOrLocator.elementHandle();
-    const html = await (containerHandle === null || containerHandle === void 0 ? void 0 : containerHandle.innerHTML());
-    if (!html) {
-      throw new Error("No HTML content found in the specified region.");
-    }
     const markdown = await (0, _helpers.extractMarkdown)({
-      source: pageObject
+      source: pageOrLocator
     });
     if (validatedData.enableCache) {
       cacheKey = (0, _hashObject.hashObject)({
@@ -200,14 +194,13 @@ const extractStructuredData = async options => {
         })
       }, true);
       const cachedResult = await _cache.cache.get(cacheKey);
-      if (enableDomMatching && cachedResult && cachedResult.matchesMapping) {
-        const cachedXpathMapping = cachedResult.matchesMapping;
-        const isValid = await (0, _xpathMapping.validateXPathMapping)(pageObject, cachedXpathMapping);
+      if (validatedData.enableDomMatching && cachedResult && cachedResult.matchesMapping) {
+        const isValid = await (0, _matching.validateMatchesMapping)(pageObject, cachedResult.matchesMapping);
         if (isValid) {
           _Logger.logger.info("Returning cached result with valid DOM matching");
           return cachedResult.result;
         }
-      } else if (cachedResult && !enableDomMatching) {
+      } else if (cachedResult && !validatedData.enableDomMatching) {
         _Logger.logger.info("Returning cached result");
         return cachedResult;
       }
@@ -229,15 +222,16 @@ const extractStructuredData = async options => {
       throw new Error(result.error.context);
     }
     if (validatedData.enableCache) {
-      if (!enableDomMatching) {
+      if (!validatedData.enableDomMatching) {
         await _cache.cache.set(cacheKey, result.value.result);
-        return result.value.result;
+      } else {
+        const domValidationHash = await (0, _matching.createMatchesMapping)(pageObject, result.value.result);
+        const resultsToCache = {
+          result: result.value.result,
+          matchesMapping: domValidationHash
+        };
+        await _cache.cache.set(cacheKey, resultsToCache);
       }
-      const resultsToCache = {
-        result: result.value.result,
-        matchesMapping: result.value.xpathMapping || {}
-      };
-      await _cache.cache.set(cacheKey, resultsToCache);
     }
     return result.value.result;
   }

package/dist/ai/tests/testCreateMatchesMapping.spec.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _playwright = require("playwright");
+var _matching = require("../../common/matching/matching");
+const SIMPLE_PRODUCT_HTML = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+    <div class="stock">In Stock</div>
+  </div>
+</body>
+</html>
+`;
+const MULTIPLE_PRODUCTS_HTML = `
+<html>
+<body>
+  <div class="product" id="p1">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <div class="product" id="p2">
+    <h2 class="title">MacBook Air M2</h2>
+    <div class="price">$1199</div>
+  </div>
+</body>
+</html>
+`;
+const PRODUCT_WITH_IFRAME_HTML = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <iframe id="details-frame" srcdoc='
+    <html>
+      <body>
+        <div class="stock">In Stock</div>
+        <div class="rating">4.5 stars</div>
+      </body>
+    </html>
+  '></iframe>
+</body>
+</html>
+`;
+const DUPLICATE_TEXT_HTML = `
+<html>
+<body>
+  <div class="header">
+    <span class="price">$999</span>
+  </div>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <div class="footer">
+    <span class="disclaimer">Starting at $999</span>
+  </div>
+</body>
+</html>
+`;
+(0, _extendedTest.describe)("createMatchesMapping", () => {
+  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.test)("should create mapping for dict data", async () => {
+    await page.setContent(SIMPLE_PRODUCT_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999",
+      stock: "In Stock"
+    };
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$999");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("In Stock");
+    for (const [_value, matches] of Object.entries(mapping)) {
+      (0, _extendedTest.expect)(Array.isArray(matches)).toBe(true);
+      (0, _extendedTest.expect)(matches.length).toBeGreaterThan(0);
+      for (const match of matches) {
+        (0, _extendedTest.expect)(match).toHaveProperty("xpath");
+        (0, _extendedTest.expect)(match).toHaveProperty("matched_value");
+        (0, _extendedTest.expect)(typeof match.xpath).toBe("string");
+        (0, _extendedTest.expect)(typeof match.matched_value).toBe("string");
+      }
+    }
+    (0, _extendedTest.expect)(mapping["iPhone 14 Pro"][0].matched_value).toBe("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping["$999"][0].matched_value).toBe("$999");
+    (0, _extendedTest.expect)(mapping["In Stock"][0].matched_value).toBe("In Stock");
+  });
+  (0, _extendedTest.test)("should create mapping for list of strings", async () => {
+    await page.setContent(SIMPLE_PRODUCT_HTML);
+    const extractedData = ["iPhone 14 Pro", "$999", "In Stock"];
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(Object.keys(mapping).length).toBe(3);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$999");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("In Stock");
+    (0, _extendedTest.expect)(mapping["iPhone 14 Pro"][0].matched_value).toBe("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping["$999"][0].matched_value).toBe("$999");
+  });
+  (0, _extendedTest.test)("should create mapping for list of dicts", async () => {
+    await page.setContent(MULTIPLE_PRODUCTS_HTML);
+    const extractedData = [{
+      title: "iPhone 14 Pro",
+      price: "$999"
+    }, {
+      title: "MacBook Air M2",
+      price: "$1199"
+    }];
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$999");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("MacBook Air M2");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$1199");
+    (0, _extendedTest.expect)(mapping["iPhone 14 Pro"].length).toBeGreaterThanOrEqual(1);
+    (0, _extendedTest.expect)(mapping["MacBook Air M2"].length).toBeGreaterThanOrEqual(1);
+    (0, _extendedTest.expect)(mapping["iPhone 14 Pro"][0].matched_value).toBe("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping["MacBook Air M2"][0].matched_value).toBe("MacBook Air M2");
+  });
+  (0, _extendedTest.test)("should include matches from iframe content", async () => {
+    await page.setContent(PRODUCT_WITH_IFRAME_HTML);
+    await page.waitForSelector("#details-frame");
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999",
+      stock: "In Stock",
+      rating: "4.5 stars"
+    };
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("iPhone 14 Pro");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$999");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("In Stock");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("4.5 stars");
+    (0, _extendedTest.expect)(mapping["In Stock"].length).toBeGreaterThan(0);
+    (0, _extendedTest.expect)(mapping["4.5 stars"].length).toBeGreaterThan(0);
+    (0, _extendedTest.expect)(mapping["In Stock"][0].matched_value).toBe("In Stock");
+    (0, _extendedTest.expect)(mapping["4.5 stars"][0].matched_value).toBe("4.5 stars");
+  });
+  (0, _extendedTest.test)("should handle duplicate text in multiple locations", async () => {
+    await page.setContent(DUPLICATE_TEXT_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$999");
+    const priceMatches = mapping["$999"];
+    (0, _extendedTest.expect)(priceMatches.length).toBeGreaterThanOrEqual(2);
+    const xpaths = priceMatches.map(match => match.xpath);
+    const uniqueXpaths = new Set(xpaths);
+    (0, _extendedTest.expect)(uniqueXpaths.size).toBeGreaterThanOrEqual(2);
+    (0, _extendedTest.expect)(priceMatches.every(match => match.matched_value === "$999")).toBe(true);
+    (0, _extendedTest.expect)(priceMatches.every(match => match.xpath.length > 0)).toBe(true);
+  });
+  (0, _extendedTest.test)("should handle empty extraction data", async () => {
+    await page.setContent(SIMPLE_PRODUCT_HTML);
+    let mapping = await (0, _matching.createMatchesMapping)(page, {});
+    (0, _extendedTest.expect)(mapping).toEqual({});
+    (0, _extendedTest.expect)(Object.keys(mapping).length).toBe(0);
+    mapping = await (0, _matching.createMatchesMapping)(page, []);
+    (0, _extendedTest.expect)(mapping).toEqual({});
+    (0, _extendedTest.expect)(Object.keys(mapping).length).toBe(0);
+  });
+  (0, _extendedTest.test)("should handle nonexistent text in DOM", async () => {
+    await page.setContent(SIMPLE_PRODUCT_HTML);
+    const extractedData = {
+      title: "Samsung Galaxy S24",
+      price: "$899"
+    };
+    const mapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    (0, _extendedTest.expect)(mapping).toHaveProperty("Samsung Galaxy S24");
+    (0, _extendedTest.expect)(mapping).toHaveProperty("$899");
+    (0, _extendedTest.expect)(mapping["Samsung Galaxy S24"].length).toBe(0);
+    (0, _extendedTest.expect)(mapping["$899"].length).toBe(0);
+    (0, _extendedTest.expect)(Object.keys(mapping).length).toBe(2);
+    (0, _extendedTest.expect)(Array.isArray(mapping["Samsung Galaxy S24"])).toBe(true);
+    (0, _extendedTest.expect)(Array.isArray(mapping["$899"])).toBe(true);
+  });
+  (0, _extendedTest.test)("should have consistent structure across different data types", async () => {
+    await page.setContent(SIMPLE_PRODUCT_HTML);
+    const dictData = {
+      title: "iPhone 14 Pro"
+    };
+    const dictMapping = await (0, _matching.createMatchesMapping)(page, dictData);
+    const listData = ["iPhone 14 Pro"];
+    const listMapping = await (0, _matching.createMatchesMapping)(page, listData);
+    (0, _extendedTest.expect)(dictMapping).toHaveProperty("iPhone 14 Pro");
+    (0, _extendedTest.expect)(listMapping).toHaveProperty("iPhone 14 Pro");
+    const dictMatches = dictMapping["iPhone 14 Pro"];
+    const listMatches = listMapping["iPhone 14 Pro"];
+    (0, _extendedTest.expect)(dictMatches.length).toBe(listMatches.length);
+    for (let i = 0; i < dictMatches.length; i++) {
+      (0, _extendedTest.expect)(dictMatches[i].xpath).toBe(listMatches[i].xpath);
+      (0, _extendedTest.expect)(dictMatches[i].matched_value).toBe(listMatches[i].matched_value);
+    }
+    (0, _extendedTest.expect)(dictMatches[0].matched_value).toBe("iPhone 14 Pro");
+    (0, _extendedTest.expect)(listMatches[0].matched_value).toBe("iPhone 14 Pro");
+  });
+});