npm - @intuned/browser-dev - Versions diffs - 0.1.5-dev.0 → 0.1.6-dev.0 - Mend

@intuned/browser-dev 0.1.5-dev.0 → 0.1.6-dev.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

package/dist/helpers/tests/testWithDomSettledWait.spec.js CHANGED Viewed

@@ -161,4 +161,146 @@ var _waitForDomSettled = require("../waitForDomSettled");
     const content = await page.textContent("#target");
     (0, _extendedTest.expect)(content).toContain("Locator source content");
   });
+  (0, _extendedTest.test)("should wait for DOM to settle with iframe dynamic content", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <iframe id="test-iframe"
+                  src="data:text/html,<html><body><div id='iframe-content'>Initial content</div></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(500);
+    const iframeElement = await page.locator("#test-iframe").elementHandle();
+    const iframeFrame = await (iframeElement === null || iframeElement === void 0 ? void 0 : iframeElement.contentFrame());
+    if (!iframeFrame) {
+      throw new Error("Could not get iframe frame");
+    }
+    await iframeFrame.evaluate(() => {
+      let counter = 0;
+      const intervalId = setInterval(() => {
+        counter++;
+        const div = document.createElement("div");
+        div.textContent = `Dynamic content ${counter}`;
+        div.className = "dynamic-item";
+        document.body.appendChild(div);
+        if (counter >= 3) {
+          clearInterval(intervalId);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const dynamicItems = await iframeFrame.locator(".dynamic-item").count();
+    (0, _extendedTest.expect)(dynamicItems).toBe(3);
+    for (let i = 0; i < 3; i++) {
+      const content = await iframeFrame.locator(".dynamic-item").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Dynamic content ${i + 1}`);
+    }
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle with nested iframes", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <div id="main-content">Main content</div>
+          <iframe id="outer-iframe"
+                  src="data:text/html,<html><body><h2>Outer iframe</h2><div id='outer-content'>Outer initial</div><iframe id='inner-iframe' src='data:text/html,<html><body><h3>Inner iframe</h3><div id=inner-content>Inner initial</div></body></html>'></iframe></body></html>"
+                  width="500"
+                  height="400">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const outerIframeElement = await page.locator("#outer-iframe").elementHandle();
+    const outerFrame = await (outerIframeElement === null || outerIframeElement === void 0 ? void 0 : outerIframeElement.contentFrame());
+    if (!outerFrame) {
+      throw new Error("Could not get outer frame");
+    }
+    const innerIframeElement = await outerFrame.locator("#inner-iframe").elementHandle();
+    const innerFrame = await (innerIframeElement === null || innerIframeElement === void 0 ? void 0 : innerIframeElement.contentFrame());
+    if (!innerFrame) {
+      throw new Error("Could not get inner frame");
+    }
+    await outerFrame.evaluate(() => {
+      let outerCounter = 0;
+      const outerInterval = setInterval(() => {
+        outerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Outer dynamic ${outerCounter}`;
+        div.className = "outer-dynamic";
+        const outerContent = document.getElementById("outer-content");
+        outerContent === null || outerContent === void 0 || outerContent.appendChild(div);
+        if (outerCounter >= 2) {
+          clearInterval(outerInterval);
+        }
+      }, 150);
+    });
+    await innerFrame.evaluate(() => {
+      let innerCounter = 0;
+      const innerInterval = setInterval(() => {
+        innerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Inner dynamic ${innerCounter}`;
+        div.className = "inner-dynamic";
+        const innerContent = document.getElementById("inner-content");
+        innerContent === null || innerContent === void 0 || innerContent.appendChild(div);
+        if (innerCounter >= 2) {
+          clearInterval(innerInterval);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 15000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const outerDynamicItems = await outerFrame.locator(".outer-dynamic").count();
+    (0, _extendedTest.expect)(outerDynamicItems).toBe(2);
+    const innerDynamicItems = await innerFrame.locator(".inner-dynamic").count();
+    (0, _extendedTest.expect)(innerDynamicItems).toBe(2);
+    for (let i = 0; i < 2; i++) {
+      const content = await outerFrame.locator(".outer-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Outer dynamic ${i + 1}`);
+    }
+    for (let i = 0; i < 2; i++) {
+      const content = await innerFrame.locator(".inner-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Inner dynamic ${i + 1}`);
+    }
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle with sandboxed iframe", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <iframe id="sandboxed-iframe"
+                  sandbox="allow-same-origin"
+                  srcdoc="<html><body><h2>Sandboxed Iframe</h2><div id='content'>Initial content</div></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(500);
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 500,
+      timeoutInMs: 5000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
 });

package/dist/helpers/tests/testWithNetworkIdleWait.spec.js CHANGED Viewed

@@ -103,7 +103,7 @@ _extendedTest.describe.skip("TestWaitForNetworkIdle", () => {
       await page.goto("data:text/html,<html><body><h1>Direct Call</h1></body></html>");
       return "direct call complete";
     }, {
-      page: page,
+      page,
       timeoutInMs: 10000,
       maxInflightRequests: 0
     });

package/dist/helpers/uploadFileToS3.js CHANGED Viewed

@@ -42,6 +42,9 @@ const uploadFileToS3 = async input => {
     fileNameOverride,
     contentType
   } = input;
+  if (!(0, _utils.isDownload)(file) && !Buffer.isBuffer(file)) {
+    throw new Error("Invalid file type, Supported types are Download and Buffer");
+  }
   const bucketName = (configs === null || configs === void 0 ? void 0 : configs.bucket) ?? process.env.AWS_BUCKET ?? process.env.INTUNED_S3_BUCKET ?? undefined;
   const region = (configs === null || configs === void 0 ? void 0 : configs.region) ?? process.env.AWS_REGION ?? process.env.INTUNED_S3_REGION ?? undefined;
   const endpoint = (configs === null || configs === void 0 ? void 0 : configs.endpoint) ?? process.env.AWS_ENDPOINT_URL ?? process.env.INTUNED_S3_ENDPOINT_URL;
@@ -52,6 +55,9 @@ const uploadFileToS3 = async input => {
     console.log("Uploaded file successfully");
     if (isDownloadedFile) {
       return new _Attachment.Attachment(`${(0, _uuid.v4)()}/${file.suggestedFilename()}`, `${(0, _uuid.v4)()}/${file.suggestedFilename()}`, "testing_bucket", "testing_region", file.suggestedFilename() || "downloaded_file", endpoint, "document");
+    } else {
+      const suggestedFileName = (0, _uuid.v4)();
+      return new _Attachment.Attachment(suggestedFileName, suggestedFileName, "testing_bucket", "testing_region", suggestedFileName, endpoint, "document");
     }
   }
   let suggestedFileName;

package/dist/helpers/utils/getS3Client.js CHANGED Viewed

@@ -12,8 +12,8 @@ function getS3Client(endpoint, region) {
     s3ClientInstance = new _clientS.S3Client({
       region: resolvedRegion,
       credentials: {
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || ""
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID || process.env.INTUNED_S3_ACCESS_KEY_ID || "",
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || process.env.INTUNED_S3_SECRET_ACCESS_KEY || ""
       },
       endpoint: endpoint || undefined
     });

package/dist/helpers/validateDataUsingSchema.js CHANGED Viewed

@@ -12,7 +12,9 @@ var _Attachment = require("./types/Attachment");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const ajv = new _ajv.default({
   strict: false,
-  removeAdditional: false
+  removeAdditional: false,
+  allErrors: true,
+  verbose: true
 });
 function injectAttachmentType(schema) {
   const schemaCopy = JSON.parse(JSON.stringify(schema));
@@ -32,10 +34,35 @@ function injectAttachmentType(schema) {
       return node.map(item => replaceAttachmentType(item));
     }
     const result = {};
-    if (node.type === "attachment") {
+    const nodeType = node.type;
+    if (typeof nodeType === "string" && nodeType.toLowerCase() === "attachment") {
       return {
         $ref: "#/$defs/attachment"
       };
+    } else if (Array.isArray(nodeType)) {
+      const hasAttachment = nodeType.some(t => typeof t === "string" && t.toLowerCase() === "attachment");
+      if (hasAttachment) {
+        const oneOfSchemas = [];
+        for (const typeItem of nodeType) {
+          if (typeof typeItem === "string" && typeItem.toLowerCase() === "attachment") {
+            oneOfSchemas.push({
+              $ref: "#/$defs/attachment"
+            });
+          } else {
+            oneOfSchemas.push({
+              type: typeItem
+            });
+          }
+        }
+        const newNode = {};
+        for (const key in node) {
+          if (key !== "type") {
+            newNode[key] = replaceAttachmentType(node[key]);
+          }
+        }
+        newNode.oneOf = oneOfSchemas;
+        return newNode;
+      }
     }
     for (const key in node) {
       result[key] = replaceAttachmentType(node[key]);
@@ -44,19 +71,78 @@ function injectAttachmentType(schema) {
   }
   return replaceAttachmentType(schemaCopy);
 }
+function resolveSchema(schema, rootSchema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if ("$ref" in schema) {
+    const refPath = schema.$ref;
+    if (refPath.startsWith("#/definitions/")) {
+      const defName = refPath.split("/").pop();
+      const definitions = rootSchema.definitions || {};
+      return definitions[defName] || schema;
+    } else if (refPath.startsWith("#/$defs/")) {
+      const defName = refPath.split("/").pop();
+      const defs = rootSchema.$defs || {};
+      return defs[defName] || schema;
+    }
+  }
+  for (const combinator of ["oneOf", "anyOf"]) {
+    if (combinator in schema) {
+      for (const option of schema[combinator]) {
+        const resolved = resolveSchema(option, rootSchema);
+        if ((resolved === null || resolved === void 0 ? void 0 : resolved.type) === "object") {
+          return resolved;
+        }
+      }
+    }
+  }
+  return schema;
+}
+function removeNoneFromOptionalFields(data, schema, rootSchema) {
+  if (typeof data === "object" && data !== null && !Array.isArray(data) && typeof schema === "object" && schema !== null) {
+    const resolvedSchema = resolveSchema(schema, rootSchema);
+    const requiredFields = new Set(resolvedSchema.required || []);
+    const properties = resolvedSchema.properties || {};
+    const cleaned = {};
+    for (const key in data) {
+      const value = data[key];
+      const fieldSchema = properties[key] || {};
+      if (requiredFields.has(key)) {
+        cleaned[key] = removeNoneFromOptionalFields(value, fieldSchema, rootSchema);
+      } else if (value !== null && value !== undefined) {
+        cleaned[key] = removeNoneFromOptionalFields(value, fieldSchema, rootSchema);
+      }
+    }
+    return cleaned;
+  } else if (Array.isArray(data)) {
+    const itemsSchema = (schema === null || schema === void 0 ? void 0 : schema.items) || {};
+    return data.filter(item => item !== null && item !== undefined).map(item => removeNoneFromOptionalFields(item, itemsSchema, rootSchema));
+  } else {
+    return data;
+  }
+}
 const validateDataUsingSchema = input => {
   const {
     data,
     schema
   } = input;
   const processedSchema = injectAttachmentType(schema);
+  const cleanedData = removeNoneFromOptionalFields(data, processedSchema, processedSchema);
   const validate = ajv.compile(processedSchema);
-  const valid = validate(data);
+  const valid = validate(cleanedData);
   if (!valid) {
-    var _validate$errors;
-    const errors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`)) || [];
-    const errorMessage = errors.join(", ") || "Unknown validation error";
-    throw new _types.ValidationError(`Data validation failed: ${errorMessage}`, data);
+    const errors = validate.errors || [];
+    if (errors.length > 0) {
+      const errorMessages = [];
+      for (const err of errors) {
+        errorMessages.push(`  - ${err.instancePath || "root"}: ${err.message}`);
+      }
+      const fullMessage = `Validation failed with ${errors.length} error(s):\n${errorMessages.join("\n")}`;
+      throw new _types.ValidationError(fullMessage, data);
+    } else {
+      throw new _types.ValidationError("Validation failed: Unknown validation error", data);
+    }
   }
 };
 exports.validateDataUsingSchema = validateDataUsingSchema;

package/dist/helpers/waitForDomSettled.js CHANGED Viewed

@@ -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,56 @@ 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);
+    let hasRestrictedIframes = false;
+    for (const iframeNode of allIframes) {
+      if (iframeNode.allowsAsyncScripts) {
+        const iframeElementHandle = await iframeNode.frame.evaluateHandle("document.documentElement");
+        const iframeResult = await iframeElementHandle.evaluate(jsCode, {
+          settleDurationMsFloored,
+          timeoutMs
+        });
+        await iframeElementHandle.dispose();
+        if (!iframeResult) {
+          return false;
+        }
+      } else {
+        hasRestrictedIframes = true;
+      }
+    }
+    if (hasRestrictedIframes) {
+      _Logger.logger.debug(`Waiting ${2 * settleDurationMs}ms for iframe(s) that do not allow async scripts to settle`);
+      await new Promise(resolve => setTimeout(resolve, 2 * settleDurationMs));
+    }
+    return true;
   } catch (error) {
     _Logger.logger.warn(`DOM settlement detection failed: ${error}`);
     return false;

package/dist/optimized-extractors/listExtractionHelpers/__tests__/testArrayExtractorFromLocator.spec.js CHANGED Viewed

@@ -72,7 +72,7 @@ _extendedTest.describe.skip("Array Extractor Caching Tests", () => {
           model: "claude-3-5-sonnet-20240620",
           type: "HTML"
         },
-        variantKey: variantKey,
+        variantKey,
         apiKey: process.env.ANTHROPIC_API_KEY
       };
       await page.setContent(productListTemplate);