npm - @intuned/browser-dev - Versions diffs - 0.1.9-dev.0 → 0.1.12-dev.0 - Mend

@intuned/browser-dev 0.1.9-dev.0 → 0.1.12-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 (37) hide show

package/dist/ai/extractStructuredData.js +21 -27
package/dist/ai/tests/testCreateMatchesMapping.spec.js +216 -0
package/dist/ai/tests/testExtractStructuredData.spec.js +346 -0
package/dist/ai/tests/testExtractStructuredDataDomMatchingIframes.spec.js +459 -0
package/dist/ai/tests/testExtractStructuredDataUnit.spec.js +375 -0
package/dist/ai/tests/testMatching.spec.js +342 -0
package/dist/ai/tests/testValidateMatchesMapping.spec.js +265 -0
package/dist/common/extendedTest.js +38 -30
package/dist/common/frame_utils/frameTree.js +116 -0
package/dist/common/frame_utils/getContentWithNestedIframes.js +13 -0
package/dist/common/frame_utils/index.js +95 -0
package/dist/common/frame_utils/stitchIframe.js +105 -0
package/dist/{helpers → common}/frame_utils/tests/testFindAllIframes.spec.js +24 -15
package/dist/common/frame_utils/tests/testGetContentWithNestedIframes.spec.js +241 -0
package/dist/common/frame_utils/utils.js +91 -0
package/dist/common/getSimplifiedHtml.js +20 -20
package/dist/common/matching/matching.js +91 -16
package/dist/common/tests/matching.test.js +225 -0
package/dist/common/tests/testGetSimplifiedHtml.spec.js +324 -0
package/dist/helpers/export.d.ts +5 -12
package/dist/helpers/extractMarkdown.js +16 -7
package/dist/helpers/index.d.ts +5 -12
package/dist/helpers/tests/testDownloadFile.spec.js +41 -0
package/dist/helpers/tests/testExtractMarkdown.spec.js +29 -0
package/dist/helpers/tests/testInjectAttachmentType.spec.js +16 -9
package/dist/helpers/tests/testValidateDataUsingSchema.spec.js +111 -0
package/dist/helpers/types/Attachment.js +23 -22
package/dist/helpers/types/__tests__/Attachment.test.js +130 -0
package/dist/helpers/validateDataUsingSchema.js +6 -2
package/dist/helpers/waitForDomSettled.js +4 -4
package/dist/types/intuned-runtime.d.ts +6 -32
package/package.json +1 -1
package/dist/helpers/frame_utils/constants.js +0 -8
package/dist/helpers/frame_utils/findAllIframes.js +0 -82
package/dist/helpers/frame_utils/index.js +0 -44
/package/dist/{helpers → common}/frame_utils/checkFrameAllowsAsyncScripts.js +0 -0
/package/dist/{helpers → common}/frame_utils/getContainerFrame.js +0 -0

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

@@ -224,6 +224,47 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(uploadedFile.bucket).toBe("testing_bucket");
     (0, _extendedTest.expect)(uploadedFile.region).toBe("testing_region");
   });
+  (0, _extendedTest.test)("should upload Buffer to s3 in generate mode", async () => {
+    const buffer = Buffer.from("hello world");
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: buffer,
+      fileNameOverride: "test-file.txt"
+    });
+    (0, _extendedTest.expect)(uploadedFile).toBeDefined();
+    (0, _extendedTest.expect)(uploadedFile.suggestedFileName).toBeDefined();
+    (0, _extendedTest.expect)(uploadedFile.bucket).toBe("testing_bucket");
+    (0, _extendedTest.expect)(uploadedFile.region).toBe("testing_region");
+  });
+  (0, _extendedTest.test)("uploaded attachment toDict has no null fields", async () => {
+    await page.setContent(content);
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: "https://intuned-docs-public-images.s3.amazonaws.com/32UP83A_ENG_US.pdf"
+    });
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: download
+    });
+    const dict = uploadedFile.toDict();
+    for (const [key, value] of Object.entries(dict)) {
+      (0, _extendedTest.expect)(value).not.toBeNull();
+      (0, _extendedTest.expect)(value).not.toBeUndefined();
+    }
+    (0, _extendedTest.expect)(dict.fileName).toBeDefined();
+    (0, _extendedTest.expect)(dict.key).toBeDefined();
+    (0, _extendedTest.expect)(dict.suggestedFileName).toBeDefined();
+  });
+  (0, _extendedTest.test)("getSignedUrl returns mock URL in generate_code mode", async () => {
+    await page.setContent(content);
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: "https://intuned-docs-public-images.s3.amazonaws.com/32UP83A_ENG_US.pdf"
+    });
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: download
+    });
+    const signedUrl = await uploadedFile.getSignedUrl();
+    (0, _extendedTest.expect)(signedUrl).toBe("https://not.real.com");
+  });
   (0, _extendedTest.test)("should download from print dialog", async () => {
     await page.setContent(content);
     const printButton = page.locator("#print-button");

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

@@ -287,4 +287,33 @@ var _ = require("..");
     (0, _extendedTest.expect)(result).toContain("> Important quote here.");
     (0, _extendedTest.expect)(result).toContain("`inline code`");
   });
+  (0, _extendedTest.test)("extract markdown from locator with iframe", async ({
+    page
+  }) => {
+    await page.setContent(`
+      <html>
+        <body>
+          <div id="outside">
+            <h1>Outside Content</h1>
+          </div>
+          <div id="container">
+            <h2>Container Header</h2>
+            <iframe id="nested-iframe" srcdoc="<html><body><h3>Nested Iframe</h3><p>Nested content</p></body></html>"></iframe>
+            <p>After iframe</p>
+          </div>
+        </body>
+      </html>
+    `);
+    await page.waitForSelector("#nested-iframe");
+    await page.frameLocator("#nested-iframe").locator("body").waitFor();
+    const locator = page.locator("#container");
+    const result = await (0, _.extractMarkdown)({
+      source: locator
+    });
+    (0, _extendedTest.expect)(result).toContain("## Container Header");
+    (0, _extendedTest.expect)(result).toContain("### Nested Iframe");
+    (0, _extendedTest.expect)(result).toContain("Nested content");
+    (0, _extendedTest.expect)(result).toContain("After iframe");
+    (0, _extendedTest.expect)(result).not.toContain("Outside Content");
+  });
 });

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

@@ -19,7 +19,8 @@ var _validateDataUsingSchema = require("../validateDataUsingSchema");
       const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
       (0, _extendedTest.expect)(result.$defs).toBeDefined();
       (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf.length).toBe(2);
       (0, _extendedTest.expect)(result.properties.file).toEqual({
         $ref: "#/$defs/attachment"
       });
@@ -463,20 +464,26 @@ var _validateDataUsingSchema = require("../validateDataUsingSchema");
       };
       const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
       (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
-      const attachmentProps = result.$defs.attachment.properties;
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf.length).toBe(2);
+      const baseSchema = result.$defs.attachment.anyOf[1];
+      (0, _extendedTest.expect)(baseSchema.type).toBe("object");
+      const attachmentProps = baseSchema.properties;
       (0, _extendedTest.expect)(attachmentProps).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.fileName).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.bucket).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.region).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.key).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.suggestedFileName).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("fileName");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("bucket");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("region");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("key");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("suggestedFileName");
+      (0, _extendedTest.expect)(baseSchema.required).toBeDefined();
+      (0, _extendedTest.expect)(baseSchema.required).toContain("fileName");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("bucket");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("region");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("key");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("suggestedFileName");
+      const signedUrlSchema = result.$defs.attachment.anyOf[0];
+      (0, _extendedTest.expect)(signedUrlSchema.type).toBe("object");
+      (0, _extendedTest.expect)(signedUrlSchema.properties.downloadSignedUrl).toBeDefined();
     });
   });
 });

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

@@ -1297,6 +1297,117 @@ var _extendedTest = require("../../common/extendedTest");
         schema
       })).not.toThrow();
     });
+    (0, _extendedTest.test)("should validate SignedUrlAttachment instance", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "Attachment"
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const signed = new _Attachment.SignedUrlAttachment("report.pdf", "https://my-bucket.s3.us-east-1.amazonaws.com/files/report.pdf?X-Amz-Signature=abc123", "Monthly Report.pdf");
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: signed,
+          name: "Signed URL file"
+        },
+        schema
+      })).not.toThrow();
+      const dict = signed.toDict();
+      (0, _extendedTest.expect)(dict).toHaveProperty("signedUrl");
+      (0, _extendedTest.expect)(dict.signedUrl).toBe("https://my-bucket.s3.us-east-1.amazonaws.com/files/report.pdf?X-Amz-Signature=abc123");
+      (0, _extendedTest.expect)(dict.bucket).toBeUndefined();
+      (0, _extendedTest.expect)(dict.region).toBeUndefined();
+    });
+    (0, _extendedTest.test)("should validate array of SignedUrlAttachment instances", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          title: {
+            type: "string"
+          },
+          documents: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          }
+        },
+        required: ["title", "documents"]
+      };
+      const data = {
+        title: "Project Files",
+        documents: [new _Attachment.SignedUrlAttachment("doc1.pdf", "https://bucket.r2.cloudflarestorage.com/doc1.pdf?sig=aaa", "Document 1.pdf"), new _Attachment.SignedUrlAttachment("doc2.pdf", "https://bucket.r2.cloudflarestorage.com/doc2.pdf?sig=bbb", "Document 2.pdf")]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate mixed Attachment and SignedUrlAttachment instances", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          s3File: {
+            type: "Attachment"
+          },
+          intunedFile: {
+            type: "Attachment"
+          },
+          optionalFile: {
+            type: ["Attachment", "null"]
+          }
+        },
+        required: ["name", "s3File", "intunedFile", "optionalFile"]
+      };
+      const data = {
+        name: "Mixed storage",
+        s3File: new _Attachment.Attachment("report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf", null, "document"),
+        intunedFile: new _Attachment.SignedUrlAttachment("invoice.pdf", "https://bucket.r2.cloudflarestorage.com/invoice.pdf?sig=xyz", "Invoice.pdf"),
+        optionalFile: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate nullable SignedUrlAttachment", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: ["Attachment", "null"]
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const signed = new _Attachment.SignedUrlAttachment("report.pdf", "https://bucket.r2.cloudflarestorage.com/report.pdf?sig=abc", "Report.pdf");
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: signed,
+          name: "With file"
+        },
+        schema
+      })).not.toThrow();
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: null,
+          name: "Without file"
+        },
+        schema
+      })).not.toThrow();
+    });
     (0, _extendedTest.test)("should format error messages with multiple errors correctly", async () => {
       const schema = {
         type: "object",

package/dist/helpers/types/Attachment.js CHANGED Viewed

@@ -13,8 +13,8 @@ const AttachmentTypeSchema = exports.AttachmentTypeSchema = _zod.z.literal("docu
 const AttachmentSchema = exports.AttachmentSchema = _zod.z.object({
   fileName: _zod.z.string(),
   key: _zod.z.string(),
-  bucket: _zod.z.string(),
-  region: _zod.z.string(),
+  bucket: _zod.z.string().optional(),
+  region: _zod.z.string().optional(),
   suggestedFileName: _zod.z.string(),
   endpoint: _zod.z.string().nullable().optional(),
   fileType: AttachmentTypeSchema.optional().nullable()
@@ -34,7 +34,6 @@ class Attachment {
     this.key = validatedData.key;
     this.bucket = validatedData.bucket;
     this.region = validatedData.region;
-    this.key = validatedData.key;
     this.suggestedFileName = validatedData.suggestedFileName;
     this.endpoint = validatedData.endpoint;
     this.fileType = validatedData.fileType;
@@ -46,9 +45,13 @@ class Attachment {
     return {
       fileName: this.fileName,
       key: this.key,
-      bucket: this.bucket,
-      region: this.region,
       suggestedFileName: this.suggestedFileName,
+      ...(this.bucket ? {
+        bucket: this.bucket
+      } : {}),
+      ...(this.region ? {
+        region: this.region
+      } : {}),
       ...(this.endpoint ? {
         endpoint: this.endpoint
       } : {}),
@@ -65,6 +68,9 @@ class Attachment {
     if ((0, _utils.isGenerateCodeMode)()) {
       return "https://not.real.com";
     }
+    if (!this.bucket || !this.region) {
+      throw new Error("bucket and region are required to generate a signed URL");
+    }
     const s3Client = (0, _getS3Client.getS3Client)(this.endpoint ?? undefined, this.region);
     try {
       const response = await (0, _s3RequestPresigner.getSignedUrl)(s3Client, new _clientS.GetObjectCommand({
@@ -80,41 +86,36 @@ class Attachment {
     }
   }
   getS3Key() {
+    if (!this.bucket || !this.region) {
+      throw new Error("bucket and region are required to get the S3 key");
+    }
     return `https://${this.bucket}.s3.${this.region}.amazonaws.com/${this.fileName}`;
   }
-  getFilePath() {
-    return this.fileName;
-  }
   getFileType() {
     return this.fileType || "";
   }
 }
 exports.Attachment = Attachment;
 const SignedUrlAttachmentSchema = exports.SignedUrlAttachmentSchema = AttachmentSchema.extend({
-  downloadSignedUrl: _zod.z.string().url()
+  signedUrl: _zod.z.string().url()
 });
 class SignedUrlAttachment extends Attachment {
-  constructor(fileName, downloadSignedUrl, suggestedFileName) {
-    const url = new URL(downloadSignedUrl);
-    const bucket = url.hostname.split(".")[0];
-    const key = url.pathname.substring(1);
-    const validatedUrl = _zod.z.string().url().parse(downloadSignedUrl);
-    super(fileName, key, bucket, "", suggestedFileName ?? fileName);
-    this.downloadSignedUrl = validatedUrl;
-  }
-  async getSignedUrl() {
-    return this.downloadSignedUrl;
+  constructor(fileName, signedUrl, suggestedFileName) {
+    super(fileName, fileName, undefined, undefined, suggestedFileName ?? fileName);
+    this.signedUrl = _zod.z.string().url().parse(signedUrl);
   }
   toDict() {
     return {
       ...super.toDict(),
-      downloadSignedUrl: this.downloadSignedUrl
+      signedUrl: this.signedUrl
     };
   }
+  async getSignedUrl() {
+    return this.signedUrl;
+  }
   static fromDict(data) {
     const validatedData = SignedUrlAttachmentSchema.parse(data);
-    const attachment = new SignedUrlAttachment(validatedData.fileName, validatedData.downloadSignedUrl, validatedData.suggestedFileName);
-    return attachment;
+    return new SignedUrlAttachment(validatedData.fileName, validatedData.signedUrl, validatedData.suggestedFileName);
   }
 }
 exports.SignedUrlAttachment = SignedUrlAttachment;

package/dist/helpers/types/__tests__/Attachment.test.js ADDED Viewed

@@ -0,0 +1,130 @@
+"use strict";
+var _vitest = require("vitest");
+var _Attachment = require("../Attachment");
+const SIGNED_URL = "https://bucket.r2.cloudflarestorage.com/file.pdf?X-Amz-Signature=abc";
+(0, _vitest.describe)("Attachment", () => {
+  (0, _vitest.test)("stores required fields", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    (0, _vitest.expect)(a.fileName).toBe("files/report.pdf");
+    (0, _vitest.expect)(a.key).toBe("files/report.pdf");
+    (0, _vitest.expect)(a.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(a.region).toBe("us-east-1");
+    (0, _vitest.expect)(a.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("endpoint defaults to undefined", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("toDict includes s3 fields", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(d.region).toBe("us-east-1");
+    (0, _vitest.expect)(d.fileName).toBe("files/report.pdf");
+    (0, _vitest.expect)(d.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("toDict omits endpoint when not set", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.toDict().endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("toDict includes endpoint when set", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s", "https://custom.s3.com");
+    (0, _vitest.expect)(a.toDict().endpoint).toBe("https://custom.s3.com");
+  });
+  (0, _vitest.test)("toJSON matches toDict", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.toJSON()).toEqual(a.toDict());
+  });
+  (0, _vitest.test)("fromDict round-trips", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    const restored = _Attachment.Attachment.fromDict(a.toDict());
+    (0, _vitest.expect)(restored.bucket).toBe(a.bucket);
+    (0, _vitest.expect)(restored.region).toBe(a.region);
+    (0, _vitest.expect)(restored.fileName).toBe(a.fileName);
+  });
+  (0, _vitest.test)("getS3Key builds correct URL", () => {
+    const a = new _Attachment.Attachment("x.pdf", "x.pdf", "my-bucket", "us-east-1", "x.pdf");
+    (0, _vitest.expect)(a.getS3Key()).toBe("https://my-bucket.s3.us-east-1.amazonaws.com/x.pdf");
+  });
+  (0, _vitest.test)("getS3Key throws when bucket or region missing", () => {
+    const a = new _Attachment.Attachment("f", "f", undefined, undefined, "s");
+    (0, _vitest.expect)(() => a.getS3Key()).toThrow();
+  });
+  (0, _vitest.test)("does not have signedUrl field", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.signedUrl).toBeUndefined();
+  });
+});
+(0, _vitest.describe)("SignedUrlAttachment", () => {
+  (0, _vitest.test)("stores fields correctly", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.fileName).toBe("report.pdf");
+    (0, _vitest.expect)(s.suggestedFileName).toBe("Report.pdf");
+    (0, _vitest.expect)(s.signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("suggestedFileName falls back to fileName", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL);
+    (0, _vitest.expect)(s.suggestedFileName).toBe("report.pdf");
+  });
+  (0, _vitest.test)("toDict exposes signedUrl", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.toDict().signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("toDict does not include bucket or region", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    const d = s.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+  });
+  (0, _vitest.test)("toJSON matches toDict", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.toJSON()).toEqual(s.toDict());
+  });
+  (0, _vitest.test)("getSignedUrl returns the signed URL", async () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(await s.getSignedUrl()).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("fromDict round-trips", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    const restored = _Attachment.SignedUrlAttachment.fromDict(s.toDict());
+    (0, _vitest.expect)(restored.signedUrl).toBe(SIGNED_URL);
+    (0, _vitest.expect)(restored.fileName).toBe("report.pdf");
+    (0, _vitest.expect)(restored.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("is instance of Attachment", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL);
+    (0, _vitest.expect)(s instanceof _Attachment.Attachment).toBe(true);
+  });
+  (0, _vitest.test)("rejects invalid signed URL", () => {
+    (0, _vitest.expect)(() => new _Attachment.SignedUrlAttachment("f", "not-a-url")).toThrow();
+  });
+});
+(0, _vitest.describe)("toDict null/undefined exclusion", () => {
+  (0, _vitest.test)("Attachment with S3 fields includes bucket and region", () => {
+    const a = new _Attachment.Attachment("f.pdf", "f.pdf", "my-bucket", "us-east-1", "f.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(d.region).toBe("us-east-1");
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("Attachment without S3 fields omits bucket and region", () => {
+    const a = new _Attachment.Attachment("f.pdf", "f.pdf", undefined, undefined, "f.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("SignedUrlAttachment omits bucket and region, exposes signedUrl", () => {
+    const s = new _Attachment.SignedUrlAttachment("f.pdf", SIGNED_URL, "f.pdf");
+    const d = s.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+    (0, _vitest.expect)(d.signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("toJSON matches toDict for SignedUrlAttachment", () => {
+    const s = new _Attachment.SignedUrlAttachment("f.pdf", SIGNED_URL, "f.pdf");
+    (0, _vitest.expect)(s.toJSON()).toEqual(s.toDict());
+  });
+});

package/dist/helpers/validateDataUsingSchema.js CHANGED Viewed

@@ -21,11 +21,15 @@ function injectAttachmentType(schema) {
   const attachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.AttachmentSchema, {
     $refStrategy: "none"
   });
-  const attachmentDefinition = typeof attachmentJsonSchema === "object" && attachmentJsonSchema !== null ? attachmentJsonSchema : {};
+  const signedUrlAttachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.SignedUrlAttachmentSchema, {
+    $refStrategy: "none"
+  });
   if (!schemaCopy.$defs) {
     schemaCopy.$defs = {};
   }
-  schemaCopy.$defs.attachment = attachmentDefinition;
+  schemaCopy.$defs.attachment = {
+    anyOf: [signedUrlAttachmentJsonSchema, attachmentJsonSchema]
+  };
   function replaceAttachmentType(node) {
     if (typeof node !== "object" || node === null) {
       return node;

package/dist/helpers/waitForDomSettled.js CHANGED Viewed

@@ -6,8 +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");
+var _frameTree = require("../common/frame_utils/frameTree");
+var _getContainerFrame = require("../common/frame_utils/getContainerFrame");
 const waitForDomSettled = async options => {
   const {
     source,
@@ -82,9 +82,9 @@ const waitForDomSettled = async options => {
     if (!result) {
       return false;
     }
-    const allIframes = await (0, _findAllIframes.findAllIframesList)(frame);
+    const iframeTree = await _frameTree.FrameTree.fromRoot(frame, 10.0, true);
     let hasRestrictedIframes = false;
-    for (const iframeNode of allIframes) {
+    for (const iframeNode of iframeTree.nodes()) {
       if (iframeNode.allowsAsyncScripts) {
         const iframeElementHandle = await iframeNode.frame.evaluateHandle("document.documentElement");
         const iframeResult = await iframeElementHandle.evaluate(jsCode, {

package/dist/types/intuned-runtime.d.ts CHANGED Viewed

@@ -9,41 +9,15 @@ declare module "@intuned/runtime" {
     password: string;
   }
-  export type WithPlaywrightContextWrappedFunction<R> = (
-    context: BrowserContext,
-    page: Page
-  ) => Promise<any>;
   export function getExecutionContext(): any;
   export function extendTimeout(): void;
-  export function runWithContext<T>(
-    context: any,
-    fn: () => T | Promise<T>
-  ): Promise<T>;
+  export function runWithContext<R, TArgs extends any[]>(
+    contextData: any,
+    callback: (...args: TArgs) => R,
+    ...args: TArgs
+  ): R;
   export function getDownloadDirectoryPath(): string;
-  export function withPlaywrightContext<R>(
-    options: {
-      proxy?: Proxy;
-      headless: boolean;
-      downloadsPath: string;
-      importFunction?: any;
-      apiName?: string;
-      apiParameters?: any;
-    },
-    fn: WithPlaywrightContextWrappedFunction<R>
-  ): Promise<any>;
-  export function withPlaywrightContext<R>(
-    options: {
-      cdpAddress: string;
-      importFunction?: any;
-      apiName?: string;
-      apiParameters?: any;
-    },
-    fn: WithPlaywrightContextWrappedFunction<R>
-  ): Promise<any>;
   // Add other exports from @intuned/runtime if needed
 }
@@ -59,6 +33,6 @@ declare module "@intuned/runtime/dist/common/jwtTokenManager" {
   export function callBackendFunctionWithToken<T = any>(
     functionName: string,
-    params?: any
+    params?: any,
   ): Promise<T>;
 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/browser-dev",
-  "version": "0.1.9-dev.0",
+  "version": "0.1.12-dev.0",
   "description": "runner package for intuned functions",
   "types": "./dist/index.d.ts",
   "typesVersions": {

package/dist/helpers/frame_utils/constants.js DELETED Viewed

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.IFRAME_TAGS = exports.ALL_IFRAMES_CSS_SELECTOR = void 0;
-const IFRAME_TAGS = exports.IFRAME_TAGS = ["iframe", "frame"];
-const ALL_IFRAMES_CSS_SELECTOR = exports.ALL_IFRAMES_CSS_SELECTOR = IFRAME_TAGS.join(", ");