@intuned/browser-dev 0.1.7-dev.0 → 0.1.8-dev.0

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

@@ -1,121 +0,0 @@
----
-title: uploadFileToS3
-description: ""
----
-
-```typescript
-export declare function uploadFileToS3(input: {
-  file: FileType;
-  configs?: S3Configs;
-  fileNameOverride?: string;
-  contentType?: string;
-}): Promise<Attachment>;
-```
-
-<Note>
-**S3 Configuration Priority:**
-1. **Explicit configs**: Values provided in `input.configs.s3Configs`
-2. **Environment variables**: Standard AWS environment variables:
-   - `AWS_BUCKET`
-   - `AWS_REGION`
-   - `AWS_ACCESS_KEY_ID`
-   - `AWS_SECRET_ACCESS_KEY`
-   - `AWS_ENDPOINT_URL`
-3. **Default fallback**: Intuned's default S3 configuration
-</Note>
-
-Uploads files to AWS S3 storage with flexible configuration options.
-
-This function accepts various file types including Playwright Download objects, binary data,
-and file streams, making it versatile for different upload scenarios. It automatically
-handles file metadata and provides comprehensive S3 configuration options.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Upload Downloaded File
-import { downloadFile, uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Download and upload a file with custom S3 configuration
-await page.goto("https://sandbox.intuned.dev/pdfs")
-const download = await downloadFile({
-  page,
-  trigger: page.locator("xpath=//tbody/tr[1]//*[name()='svg']")
-});
-
-const uploadedFile = await uploadFileToS3({
-  file: download,
-  configs: {
-      bucket: 'my-documents',
-      region: 'us-west-2',
-      accessKeyId: 'accessKeyId',
-      secretAccessKey: 'SecretAccessKeyId'
-    },
-    fileNameOverride: 'reports/monthly-report.pdf'
-  }
-});
-
-console.log(`File uploaded: ${uploadedFile.suggestedFileName}`);
-console.log(`S3 URL: ${uploadedFile.getS3Key()}`);
-}
-```
-
-```typescript Upload Binary Data
-import { uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Upload binary data with minimal configuration
-const fileBuffer = Buffer.from('Hello World', 'utf8');
-const uploadedFile = await uploadFileToS3({
-  file: fileBuffer,
-  configs: {
-    bucket: 'my-documents',
-    region: 'us-west-2',
-    accessKeyId: 'accessKeyId',
-    secretAccessKey: 'SecretAccessKeyId'
-  },
-  fileNameOverride: 'data/text-file.txt',
-  contentType: 'text/plain'
-  }
-});
-
-// Generate a temporary download URL
-const downloadUrl = await uploadedFile.getSignedUrl(3600); // 1 hour
-}
-```
-
-</CodeGroup>
-
-## Arguments
-
-<ParamField path="input" type="Object" required
->
-Configuration object for the upload operation
-
-<Expandable title="input">
-<ParamField path="input.file" type="FileType">
-The file to upload. Accepts [FileType](../type-aliases/FileType) types including:
-  - Playwright Download objects (from `downloadFile`)
-  - Uint8Array or Buffer (binary data)
-  - ReadStream (file streams)
-</ParamField>
-
-<ParamField path="input.configs" type="S3Configs">
-Optional [S3Configs](../interfaces/S3Configs) for customizing the S3 upload. If not provided, uses environment variables or default configuration
-</ParamField>
-
-<ParamField path="input.fileNameOverride" type="string">
-Optional custom filename for the uploaded file. If not provided, uses the original filename
-</ParamField>
-
-<ParamField path="input.contentType" type="string">
-Optional MIME type for the uploaded file (e.g., "application/pdf", "image/png")
-</ParamField>
-
-</Expandable>
-
-</ParamField>
-
-## Returns: `Promise<Attachment>`
-
-Promise that resolves to an [Attachment](../interfaces/Attachment) object with file metadata and utility methods

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

@@ -1,90 +0,0 @@
----
-title: validateDataUsingSchema
-description: ""
----
-
-```typescript
-export declare function validateDataUsingSchema(input: {
-  data: Record<string, any>[] | Record<string, any>;
-  schema: Record<string, any>;
-}): void;
-```
-
-Validates data against a JSON schema using the AJV validator.
-This function can validate any given data against a given schema. It supports validating custom data types such as the [Attachment](../interfaces/Attachment) type.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Basic User Data Validation
-import { validateDataUsingSchema } from "@intuned/browser";
-export default async function handler(params, page, context){
-const userData = {
-  name: "John Doe",
-  email: "john@example.com",
-  age: 30
-};
-
-const userSchema = {
-  type: "object",
-  required: ["name", "email", "age"],
-  properties: {
-    name: { type: "string", minLength: 1 },
-    email: { type: "string", format: "email" },
-    age: { type: "number", minimum: 0 }
-  }
-};
-
-validateDataUsingSchema({ data: userData, schema: userSchema });
-// Validation passes, no error thrown
-}
-```
-
-```typescript Invalid Data Validation
-import { validateDataUsingSchema } from "@intuned/browser";
-export default async function handler(params, page, context){
-const userData = {
-  name: "John Doe",
-  email: "john@example.com",
-};
-
-const userSchema = {
-  type: "object",
-  required: ["name", "email", "age"],
-  properties: {
-    name: { type: "string", minLength: 1 },
-    email: { type: "string", format: "email" },
-    age: { type: "number", minimum: 0 }
-  }
-};
-
-validateDataUsingSchema({ data: userData, schema: userSchema });
-// Validation fails, throws ValidationError
-}
-```
-
-</CodeGroup>
-
-## Arguments
-
-<ParamField path="input" type="Object" required
->
-The input object containing data and schema
-
-<Expandable title="input">
-<ParamField path="input.data" type="Record<string, any> | Array<Record<string, any>>">
-The data to validate. Can be a single data object or an array of data objects
-</ParamField>
-
-<ParamField path="input.schema" type="Record<string, any>">
-JSON schema object defining validation rules
-</ParamField>
-
-</Expandable>
-
-</ParamField>
-
-## Returns: `void`
-
-Returns nothing if validation passes, throws ValidationError if it fails

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

@@ -1,91 +0,0 @@
----
-title: waitForDomSettled
-description: ""
----
-
-```typescript
-export declare function waitForDomSettled(options: {
-  source: Page | Locator;
-  settleDurationMs?: number;
-  timeoutInMs?: number;
-}): Promise<boolean>;
-```
-
-Waits for the DOM to stop changing before proceeding. Useful for dynamic content
-that loads progressively or elements that appear/update after initial page load.
-
-This function monitors DOM mutations and waits for a specified duration of stability
-before considering the DOM "settled". It can monitor either the entire page or a
-specific element within the page.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Wait for Page Content to Stabilize
-import { waitForDomSettled } from '@intuned/browser';
-export default async function handler(params, page, context){
-// Navigate to a dynamic page
-await page.goto('https://docs.intunedhq.com/docs-old/getting-started/introduction');
-
-// Wait for entire page content to stabilize
-const settled = await waitForDomSettled({
-  source: page,
-  settleDurationMs: 1000
-});
-
-if (settled) {
-  // Safe to scrape or interact with content
-  console.log(`Found stable items`);
-} else {
-  console.log("DOM never fully settled, proceeding anyway");
-}
-}
-```
-
-```typescript Monitor Specific Container
-import { waitForDomSettled } from '@intuned/browser';
-export default async function handler(params, page, context){
-await page.goto("https://docs.intunedhq.com/")
-// Wait for a specific feed container to stop updating
-const settled = await waitForDomSettled({
-  source: page.locator("xpath=//div[@id='sidebar-content']"),
-  settleDurationMs: 2000,
-  timeoutInMs: 15000,
-});
-
-if (settled) {
-  // Now the feed is stable, safe to extract articles
-  console.log(`Feed stabilized`);
-}
-}
-```
-
-</CodeGroup>
-
-## Arguments
-
-<ParamField path="options" type="Object" required
->
-Configuration object for DOM settlement monitoring
-
-<Expandable title="options">
-<ParamField path="options.source" type="Page | Locator">
-The Playwright Page or Locator to monitor for DOM changes. When a Page is provided, monitors the entire document for changes. When a Locator is provided, only monitors changes within that specific element
-</ParamField>
-
-<ParamField path="options.settleDurationMs" type="number">
-Milliseconds the DOM must remain unchanged to be considered settled. Defaults to 500
-</ParamField>
-
-<ParamField path="options.timeoutInMs" type="number">
-Maximum milliseconds to wait before giving up. Defaults to 30000
-</ParamField>
-
-</Expandable>
-
-</ParamField>
-
-## Returns: `Promise<boolean>`
-
-Promise that resolves to true if DOM settled within timeout, false if timeout or error occurred

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

@@ -1,76 +0,0 @@
----
-title: withNetworkSettledWait
-description: ""
----
-
-```typescript
-export declare function withNetworkSettledWait<T>(callback: (page: Page) => Promise<T>,
-  options?: {
-    page: Page;
-    timeoutInMs?: number;
-    maxInflightRequests?: number;
-  }): Promise<T>;
-```
-
-Executes a callback function and waits for network requests to settle before returning.
-
-This function monitors network activity and waits for all pending requests to complete
-(or reach the specified maximum) before resolving. Useful for ensuring dynamic content
-has fully loaded after performing actions that trigger network requests.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Navigation with Network Settlement
-import { withNetworkSettledWait } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Navigate and ensure all resources are loaded
-await withNetworkSettledWait(
-  async (page) => {
-    await page.goto('https://spa-app.com/dashboard');
-    // Return when navigation is complete and network is idle
-  },
-  {
-    page,
-    timeoutInMs: 20000,
-    maxInflightRequests: 0 // Wait for complete network silence
-  }
-);
-}
-```
-
-</CodeGroup>
-
-## Arguments
-
-<ParamField path="callback" type="Function" required
->
-The callback function to execute. Receives the page object as parameter
-
-</ParamField>
-
-<ParamField path="options" type="Object"
->
-Configuration options for network monitoring
-
-<Expandable title="options">
-<ParamField path="options.page" type="Page">
-The Playwright page object to monitor for network activity
-</ParamField>
-
-<ParamField path="options.timeoutInMs" type="number">
-Maximum time to wait in milliseconds before timing out. Defaults to 30000
-</ParamField>
-
-<ParamField path="options.maxInflightRequests" type="number">
-Maximum number of pending requests to consider as "settled". Defaults to 0 (waits for all requests to complete)
-</ParamField>
-
-</Expandable>
-
-</ParamField>
-
-## Returns: `Promise<T>`
-
-Promise that resolves to the callback's return value after network settles

package/generated-docs/helpers/interfaces/Attachment.mdx

@@ -1,56 +0,0 @@
----
-title: Attachment
-description: ""
----
-
-```typescript
-export interface Attachment {
-  fileName: string;
-  bucket: string;
-  region: string;
-  endpoint?: string;
-  suggestedFileName: string;
-  fileType?: AttachmentType;
-  toJSON(): Record<string,
-  string>;
-  toDict(): Record<string,
-  string>;
-  getS3Key(): string;
-  getFilePath(): string;
-  getSignedUrl(expiration?: number): Promise<string>;
-}
-```
-
-Represents an uploaded file stored in AWS S3 with metadata and utility methods.
-
-This interface provides a structured way to handle file information for files stored
-in S3, including methods for generating presigned URLs, serialization, and accessing
-file metadata.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Attachment Usage
-import { uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Typically returned from uploadFileToS3 or saveFileToS3
-
-const uploadedFile: Attachment = await uploadFileToS3({
-  file: myFile,
-  configs: s3Config
-});
-
-// Access file properties
-console.log(uploadedFile.fileName); // "documents/report.pdf"
-console.log(uploadedFile.suggestedFileName); // "Monthly Report.pdf"
-
-// Get a presigned URL for download
-const downloadUrl = await uploadedFile.getSignedUrl(3600); // 1 hour
-
-// Convert to dictionary for storage or API responses
-const fileDict = uploadedFile.toDict();
-}
-```
-
-</CodeGroup>

package/generated-docs/helpers/interfaces/S3Configs.mdx

@@ -1,52 +0,0 @@
----
-title: S3Configs
-description: ""
----
-
-```typescript
-export interface S3Configs {
-  bucket?: string;
-  region?: string;
-  accessKeyId?: string;
-  secretAccessKey?: string;
-  endpoint?: string;
-}
-```
-
-Configuration options for AWS S3 storage operations.
-
-This interface defines the authentication and configuration properties
-for connecting to and performing operations with AWS S3 storage. All properties
-are optional and will fall back to environment variables or default configuration.
-
-## Examples
-
-<CodeGroup>
-
-```typescript S3 Configuration
-import { uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Basic S3 configuration
-const s3Config: S3Configs = {
-  bucket: "my-app-uploads",
-  region: "us-east-1",
-  accessKeyId: "accessKeyId",
-  secretAccessKey: "SecretAccessKeyId"
-};
-
-// Use with file upload
-const attachment = await uploadFileToS3({
-  file: myFile,
-  configs: s3Config
-});
-
-// Use with download and upload operations
-const uploadedFile = await saveFileToS3({
-  page,
-  trigger: downloadUrl,
-  configs: s3Config
-});
-}
-```
-
-</CodeGroup>

package/generated-docs/helpers/interfaces/SanitizeHtmlOptions.mdx

@@ -1,22 +0,0 @@
----
-title: SanitizeHtmlOptions
-description: ""
----
-
-```typescript
-export interface SanitizeHtmlOptions {
-  html: string;
-  removeScripts?: boolean;
-  removeStyles?: boolean;
-  removeSvgs?: boolean;
-  removeComments?: boolean;
-  removeLongAttributes?: boolean;
-  maxAttributeLength?: number;
-  preserveAttributes?: string[];
-  removeEmptyTags?: boolean;
-  preserveEmptyTags?: string[];
-  minifyWhitespace?: boolean;
-}
-```
-
-Configuration options for sanitizing HTML content.

package/generated-docs/helpers/type-aliases/AttachmentType.mdx

@@ -1,10 +0,0 @@
----
-title: AttachmentType
-description: ""
----
-
-```typescript
-export type AttachmentType = "document";
-```
-
-Union type representing the supported attachment file types.

package/generated-docs/helpers/type-aliases/FileType.mdx

@@ -1,61 +0,0 @@
----
-title: FileType
-description: ""
----
-
-```typescript
-export type FileType = Download | Uint8Array | Buffer | ReadStream;
-```
-
-A union type representing different file formats that can be processed by the SDK.
-
-This type alias provides flexibility in how files can be passed to various functions,
-supporting multiple input formats for maximum convenience.
-
-## Examples
-
-<CodeGroup>
-
-```typescript Using Download Object
-import { downloadFile, uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// From a browser download
-const download = await downloadFile({
-  page,
-  trigger: "https://example.com/file.pdf"
-});
-const uploaded = await uploadFileToS3({
-  file: download,
-  configs: s3Config
-});
-}
-```
-
-```typescript Using Buffer
-import { uploadFileToS3 } from "@intuned/browser";
-export default async function handler(params, page, context){
-// From raw buffer
-const fileBuffer = Buffer.from("PDF content here...", "utf8");
-const uploaded = await uploadFileToS3({
-  file: fileBuffer,
-  fileNameOverride: "generated.pdf",
-  configs: s3Config
-});
-}
-```
-
-```typescript Using ReadStream
-import { uploadFileToS3 } from "@intuned/browser";
-import { createReadStream } from "fs";
-export default async function handler(params, page, context){
-// From a file stream
-const fileStream = createReadStream("/path/to/document.pdf");
-const uploaded = await uploadFileToS3({
-  file: fileStream,
-  fileNameOverride: "renamed.pdf",
-  configs: s3Config
-});
-}
-```
-
-</CodeGroup>

package/generated-docs/helpers/type-aliases/Trigger.mdx

@@ -1,62 +0,0 @@
----
-title: Trigger
-description: ""
----
-
-```typescript
-export type Trigger = string | Locator | ((page: Page) => Promise<void>);
-```
-
-<Note>
-All download functions in the helpers module accept Trigger for consistency.
-The trigger method determines how the download operation is initiated.
-</Note>
-
-A union type representing different methods to trigger file downloads in web automation.
-
-This type alias standardizes how download operations can be initiated, providing
-multiple approaches to suit different automation scenarios.
-
-## Examples
-
-<CodeGroup>
-
-```typescript URL String Trigger
-import { downloadFile } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Direct download from URL
-const download = await downloadFile({
-  page,
-  trigger: "https://example.com/report.pdf"
-});
-}
-```
-
-```typescript Locator Trigger
-import { downloadFile } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Click a download button/link
-const downloadButton = page.locator("#download-btn");
-const download = await downloadFile({
-  page,
-  trigger: downloadButton
-});
-}
-```
-
-```typescript Custom Function Trigger
-import { downloadFile } from "@intuned/browser";
-export default async function handler(params, page, context){
-// Complex download logic
-const download = await downloadFile({
-  page,
-  trigger: async (page) => {
-    await page.click(".menu-trigger");
-    await page.waitForSelector(".download-option");
-    await page.click(".download-option");
-  }
-});
-}
-```
-
-</CodeGroup>