@intuned/browser-dev 0.1.4-dev.1 → 0.1.5-dev.1

package/dist/helpers/waitForDomSettled.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.waitForDomSettled = void 0;
 var _locatorHelpers = require("../common/locatorHelpers");
 var _Logger = require("../common/Logger");
+var _findAllIframes = require("./frame_utils/findAllIframes");
+var _getContainerFrame = require("./frame_utils/getContainerFrame");
 const waitForDomSettled = async options => {
   const {
     source,
@@ -14,10 +16,10 @@ const waitForDomSettled = async options => {
   } = options;
   const settleDurationMsFloored = Math.floor(settleDurationMs);
   const timeoutMs = Math.floor(timeoutInMs);
-  let pageObj;
+  let frame;
   let elementHandle;
   if (!(0, _locatorHelpers.isPage)(source)) {
-    pageObj = source.page();
+    frame = await (0, _getContainerFrame.getContainerFrame)(source);
     const handle = await source.elementHandle();
     if (!handle) {
       _Logger.logger.warn("Could not get element handle from locator");
@@ -25,46 +27,26 @@ const waitForDomSettled = async options => {
     }
     elementHandle = handle;
   } else if ((0, _locatorHelpers.isPage)(source)) {
-    pageObj = source;
-    elementHandle = await pageObj.evaluateHandle("document.documentElement");
+    frame = source.mainFrame();
+    elementHandle = await frame.evaluateHandle("document.documentElement");
   } else {
     throw new Error("Invalid state");
   }
-  try {
-    const result = await pageObj.evaluate(({
-      target,
+  const jsCode = (target, args) => {
+    const {
       settleDurationMsFloored,
       timeoutMs
-    }) => {
-      return new Promise((resolve, reject) => {
-        if (!target) {
-          reject(new Error("Target element not found"));
-          return;
-        }
-        let mutationTimer;
-        let settled = false;
-        const observer = new MutationObserver(() => {
-          if (settled) return;
-          clearTimeout(mutationTimer);
-          mutationTimer = window.setTimeout(() => {
-            settled = true;
-            observer.disconnect();
-            clearTimeout(timeoutTimer);
-            resolve(true);
-          }, settleDurationMsFloored);
-        });
-        const timeoutTimer = window.setTimeout(() => {
-          settled = true;
-          observer.disconnect();
-          clearTimeout(mutationTimer);
-          reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
-        }, timeoutMs);
-        observer.observe(target, {
-          childList: true,
-          subtree: true,
-          attributes: true,
-          characterData: true
-        });
+    } = args;
+    return new Promise((resolve, reject) => {
+      if (!target) {
+        reject(new Error("Target element not found"));
+        return;
+      }
+      let mutationTimer;
+      let settled = false;
+      const observer = new MutationObserver(() => {
+        if (settled) return;
+        clearTimeout(mutationTimer);
         mutationTimer = window.setTimeout(() => {
           settled = true;
           observer.disconnect();
@@ -72,12 +54,47 @@ const waitForDomSettled = async options => {
           resolve(true);
         }, settleDurationMsFloored);
       });
-    }, {
-      target: elementHandle,
+      const timeoutTimer = window.setTimeout(() => {
+        settled = true;
+        observer.disconnect();
+        clearTimeout(mutationTimer);
+        reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
+      }, timeoutMs);
+      observer.observe(target, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        characterData: true
+      });
+      mutationTimer = window.setTimeout(() => {
+        settled = true;
+        observer.disconnect();
+        clearTimeout(timeoutTimer);
+        resolve(true);
+      }, settleDurationMsFloored);
+    });
+  };
+  try {
+    const result = await elementHandle.evaluate(jsCode, {
       settleDurationMsFloored,
       timeoutMs
     });
-    return result;
+    if (!result) {
+      return false;
+    }
+    const allIframes = await (0, _findAllIframes.findAllIframesList)(frame);
+    for (const iframeNode of allIframes) {
+      const iframeElementHandle = await iframeNode.frame.evaluateHandle("document.documentElement");
+      const iframeResult = await iframeElementHandle.evaluate(jsCode, {
+        settleDurationMsFloored,
+        timeoutMs
+      });
+      await iframeElementHandle.dispose();
+      if (!iframeResult) {
+        return false;
+      }
+    }
+    return true;
   } catch (error) {
     _Logger.logger.warn(`DOM settlement detection failed: ${error}`);
     return false;

package/dist/intunedServices/ApiGateway/tests/testApiGateway.spec.js

@@ -63,15 +63,15 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
     (0, _extendedTest.it)("should use default model when not provided", () => {
       const gateway = new _aiApiGateway.APIGateway({
         apiKey: "sk-test123",
-        model: "gpt-4o-2024-08-06"
+        model: "gpt-5-mini-2025-08-07"
       });
-      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-5-mini-2025-08-07");
     });
     (0, _extendedTest.it)("should allow no parameters", () => {
       const gateway = new _aiApiGateway.APIGateway({
-        model: "gpt-4o-2024-08-06"
+        model: "gpt-5-mini-2025-08-07"
       });
-      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-5-mini-2025-08-07");
       (0, _extendedTest.expect)(gateway["apiKey"]).toBeUndefined();
     });
   });

package/dist/optimized-extractors/listExtractionHelpers/__tests__/testArrayExtractorFromPage.spec.js

@@ -69,10 +69,10 @@ _extendedTest.describe.skip("Array Extractor from Page Caching Tests", () => {
         label: testLabel,
         itemEntitySchema,
         strategy: {
-          model: "claude-3-5-sonnet-20240620",
+          model: "claude-3-5-haiku-20241022",
           type: "HTML"
         },
-        variantKey: variantKey,
+        variantKey,
         apiKey: process.env.ANTHROPIC_API_KEY
       };
       await page.setContent(productListTemplate);
@@ -126,5 +126,274 @@ _extendedTest.describe.skip("Array Extractor from Page Caching Tests", () => {
       (0, _extendedTest.expect)(fourthResult[0]).toHaveProperty("price", "$1099");
       console.log("All cache behavior tests completed successfully!");
     });
+    (0, _extendedTest.test)("should demonstrate caching behavior with different types of DOM changes", async ({
+      page
+    }) => {
+      await page.goto("https://vendor.myfloridamarketplace.com/search/bids/detail/9507", {
+        timeout: 0
+      });
+      const result = await (0, _.extractArrayFromPage)(page, {
+        label: "external website links.",
+        itemEntityName: "downloadable_links",
+        itemEntitySchema: {
+          type: "object",
+          required: ["anchor_innerText"],
+          properties: {
+            anchor_href: {
+              type: "string",
+              description: "extract all downloadable files hrefs."
+            },
+            anchor_innerText: {
+              primary: true,
+              type: "string",
+              description: "extract title attribute of that anchor.k"
+            }
+          }
+        },
+        strategy: {
+          type: "HTML",
+          model: "claude-3-5-haiku-20241022"
+        }
+      });
+      console.log("Result:", result);
+    });
+  });
+  (0, _extendedTest.describe)("Edge Cases - Item Count Variations", () => {
+    (0, _extendedTest.test)("should handle extraction with 0 items", async ({
+      page
+    }) => {
+      const testLabel = `product-list-0-items-${(0, _uuid.v4)()}`;
+      const emptyListTemplate = `
+        <div class="products-container">
+          <div class="additional-info">
+            <div class="shipping-notice">No products available</div>
+            <div class="return-policy">Check back later</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          }
+        }
+      };
+      await page.setContent(emptyListTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("0 items result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(0);
+      (0, _extendedTest.expect)(Array.isArray(result)).toBe(true);
+    });
+    (0, _extendedTest.test)("should handle extraction with 1 item", async ({
+      page
+    }) => {
+      const testLabel = `product-list-1-item-${(0, _uuid.v4)()}`;
+      const singleItemTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">MacBook Pro M3</h2>
+            <div class="price-wrapper">
+              <span class="price">$2499</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Professional laptop with M3 Max chip</p>
+            </div>
+          </div>
+          <div class="additional-info">
+            <div class="shipping-notice">Free express shipping</div>
+            <div class="return-policy">30-day return policy</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      await page.setContent(singleItemTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("1 item result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(1);
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("title", "MacBook Pro M3");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("price", "$2499");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("description", "Professional laptop with M3 Max chip");
+    });
+    (0, _extendedTest.test)("should handle extraction with 2 items", async ({
+      page
+    }) => {
+      const testLabel = `product-list-2-items-${(0, _uuid.v4)()}`;
+      const twoItemsTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">iPad Pro</h2>
+            <div class="price-wrapper">
+              <span class="price">$1099</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Powerful tablet with M2 chip</p>
+            </div>
+          </div>
+          <div class="product-item">
+            <h2 class="product-title">Apple Watch Ultra</h2>
+            <div class="price-wrapper">
+              <span class="price">$799</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Rugged smartwatch for athletes</p>
+            </div>
+          </div>
+          <div class="additional-info">
+            <div class="shipping-notice">Free shipping on all orders</div>
+            <div class="return-policy">30-day return policy</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      await page.setContent(twoItemsTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("2 items result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(2);
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("title", "iPad Pro");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("price", "$1099");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("description", "Powerful tablet with M2 chip");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("title", "Apple Watch Ultra");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("price", "$799");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("description", "Rugged smartwatch for athletes");
+    });
+    (0, _extendedTest.test)("should cache and reuse results for 1 item correctly", async ({
+      page
+    }) => {
+      const testLabel = `product-list-1-item-cache-${(0, _uuid.v4)()}`;
+      const singleItemTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">Sony WH-1000XM5</h2>
+            <div class="price-wrapper">
+              <span class="price">$399</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Premium noise-canceling headphones</p>
+            </div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          }
+        }
+      };
+      const extractionOptions = {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      };
+      await page.setContent(singleItemTemplate);
+      const firstResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("First extraction (1 item):", firstResult);
+      (0, _extendedTest.expect)(firstResult).toHaveLength(1);
+      (0, _extendedTest.expect)(firstResult[0]).toHaveProperty("title", "Sony WH-1000XM5");
+      (0, _extendedTest.expect)(firstResult[0]).toHaveProperty("price", "$399");
+      await page.setContent(singleItemTemplate);
+      const secondResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("Second extraction (from cache, 1 item):", secondResult);
+      (0, _extendedTest.expect)(secondResult).toEqual(firstResult);
+      (0, _extendedTest.expect)(secondResult).toHaveLength(1);
+      (0, _extendedTest.expect)(secondResult[0]).toHaveProperty("title", "Sony WH-1000XM5");
+      (0, _extendedTest.expect)(secondResult[0]).toHaveProperty("price", "$399");
+      const modifiedTemplate = singleItemTemplate.replace("Sony WH-1000XM5", "Bose QuietComfort Ultra").replace("$399", "$429");
+      await page.setContent(modifiedTemplate);
+      const thirdResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("Third extraction (changed content, 1 item):", thirdResult);
+      (0, _extendedTest.expect)(thirdResult).not.toEqual(firstResult);
+      (0, _extendedTest.expect)(thirdResult).toHaveLength(1);
+      (0, _extendedTest.expect)(thirdResult[0]).toHaveProperty("title", "Bose QuietComfort Ultra");
+      (0, _extendedTest.expect)(thirdResult[0]).toHaveProperty("price", "$429");
+    });
   });
 });

package/dist/optimized-extractors/listExtractionHelpers/runAiExtraction.js

@@ -70,16 +70,63 @@ async function handleNewAiExtraction(params) {
     allData.value.forEach((v, i) => {
       _Logger.logger.debug(`ai extraction result for row ${i}: ${JSON.stringify(v)}`);
     });
-    const aiResults = allData.value.map((v, i) => ({
-      result: v,
-      rowIndex: i
-    }));
-    const resultValues = aiResults;
-    const matches = await (0, _getListMatches.getListMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, aiResults);
+    const resultValues = [];
+    for (let i = 0; i < allData.value.length; i++) {
+      const rowValues = allData.value[i];
+      const allValues = Object.entries(rowValues).map(([_, value]) => value);
+      const rowValuesMatches = await (0, _findDomMatches.getDomMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, allValues);
+      const rowValuesWithMatchesOnly = Object.entries(rowValues).reduce((acc, [key, value]) => {
+        const valueMatches = rowValuesMatches.get(value);
+        const bestMatch = (0, _utils.selectBestMatch)(value, valueMatches ?? []);
+        if (valueMatches && valueMatches.length > 0 && bestMatch) {
+          acc[key] = {
+            matchText: bestMatch.matchText,
+            matchXpath: bestMatch.matchXpath,
+            matchType: bestMatch.matchType
+          };
+        } else {
+          _Logger.logger.debug(`value "${value}" for key "${key}" in row ${i + 1} does not have any matches in the page html, dropped for hallucination protection`);
+        }
+        return acc;
+      }, {});
+      resultValues.push({
+        rowIndex: i,
+        result: rowValuesWithMatchesOnly
+      });
+    }
+    const matches = await (0, _getListMatches.getListMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, resultValues.map(v => ({
+      rowIndex: v.rowIndex,
+      result: Object.fromEntries(Object.entries(v.result).map(([key, value]) => [key, value.matchText]))
+    })));
+    let containerPath = null;
+    let fullContainerXpath = null;
+    if (resultValues.length > 0 && resultValues[0].result[primaryPropertyName]) {
+      const primaryXpath = resultValues[0].result[primaryPropertyName].matchXpath;
+      if (primaryXpath) {
+        const parentXpath = await pageAndSearchRegion.page.evaluate(xpath => {
+          var _window$__INTUNED__;
+          const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+          const element = result.singleNodeValue;
+          if (!element || !element.parentElement) return null;
+          if ((_window$__INTUNED__ = window.__INTUNED__) !== null && _window$__INTUNED__ !== void 0 && _window$__INTUNED__.getElementXPath) {
+            return window.__INTUNED__.getElementXPath(element.parentElement);
+          }
+          return null;
+        }, primaryXpath);
+        if (parentXpath) {
+          fullContainerXpath = parentXpath;
+          if (hasSearchRegionContainer) {
+            containerPath = await (0, _getRelativeContainerXpathSelector.getRelativeContainerXpathSelector)(pageAndSearchRegion.searchRegion, parentXpath);
+          } else {
+            containerPath = parentXpath;
+          }
+        }
+      }
+    }
     return (0, _neverthrow.ok)({
       resultValues,
-      containerPath: null,
-      fullContainerXpath: null,
+      containerPath,
+      fullContainerXpath,
       matches
     });
   }

package/generated-docs/ai/functions/extractStructuredData.mdx

@@ -34,7 +34,7 @@ await page.goto("https://books.toscrape.com/")
 const product = await extractStructuredData({
   source: page,
   strategy: "HTML",
-  model: "gpt-4o"
+  model: "gpt-4o",
   dataSchema: {
     type: "object",
     properties: {
@@ -47,8 +47,8 @@ const product = await extractStructuredData({
   },
   prompt: "Extract product details from this e page"
 });
-}
 console.log(`Found book: ${product.name} - ${product.price}`);
+}
 ```
 
 ```typescript Locator source
@@ -59,7 +59,7 @@ const articleContainer = page.locator("article").first()
 const article = await extractStructuredData({
   source: articleContainer,
   strategy: "MARKDOWN",
-  model: "claude-3",
+  model: "claude-3-5-sonnet-20240620",
   dataSchema: {
   type: "object",
   properties: {
@@ -72,8 +72,8 @@ const article = await extractStructuredData({
 },
   maxRetries: 5
 });
-}
 console.log(`Found book: ${article.title}`);
+}
 ```
 
 </CodeGroup>
@@ -138,7 +138,7 @@ export declare function extractStructuredData(options: {
   content: ContentItem[] | ContentItem;
   dataSchema: JsonSchema | z.ZodSchema;
   prompt?: string;
-  maxRetires?: number;
+  maxRetries?: number;
   enableCache?: boolean;
   model: SUPPORTED_MODELS;
   apiKey?: string;

package/generated-docs/ai/functions/isPageLoaded.mdx

@@ -51,6 +51,7 @@ while (attempts < 10) {
   await page.waitForTimeout(2000);
   attempts++;
 }
+}
 ```
 }
 

package/generated-docs/helpers/functions/clickButtonAndWait.mdx

@@ -0,0 +1,63 @@
+---
+title: clickButtonAndWait
+description: ""
+---
+
+```typescript
+export declare function clickButtonAndWait(input: {
+  page: Page;
+  buttonLocator: Locator;
+  clickDelay?: number;
+}): Promise<void>;
+```
+
+Click a button and wait briefly for content to load.
+
+This function clicks a button element and waits for a specified delay, allowing time for
+any triggered content to load. It automatically waits for network activity to settle.
+
+## Examples
+
+<CodeGroup>
+
+```typescript Basic Button Click
+import { clickButtonAndWait } from "@intuned/browser";
+export default async function handler(params, page, context){
+await page.goto("https://example.com/products");
+const loadMoreButton = page.locator("#load-more-button");
+await clickButtonAndWait({
+  page,
+  buttonLocator: loadMoreButton,
+  clickDelay: 1.0
+});
+}
+```
+
+</CodeGroup>
+
+## Arguments
+
+<ParamField path="input" type="Object" required
+>
+Configuration options
+
+<Expandable title="input">
+<ParamField path="input.page" type="Page">
+Playwright Page object
+</ParamField>
+
+<ParamField path="input.buttonLocator" type="Locator">
+Locator for the button element to click
+</ParamField>
+
+<ParamField path="input.clickDelay" type="number">
+Delay after clicking the button (in seconds)
+</ParamField>
+
+</Expandable>
+
+</ParamField>
+
+## Returns: `Promise<void>`
+
+Promise that resolves when the click and wait is complete