@airtop/sdk 0.1.5 → 0.1.7

package/dist/serialization/types/VisualAnalysisConfigPartitionDirection.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualAnalysisConfigPartitionDirection = void 0;
+const core = __importStar(require("../../core"));
+exports.VisualAnalysisConfigPartitionDirection = core.serialization.enum_(["vertical", "horizontal", "bidirectional"]);

package/dist/serialization/types/VisualAnalysisConfigScope.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Airtop from "../../api/index";
+import * as core from "../../core";
+export declare const VisualAnalysisConfigScope: core.serialization.Schema<serializers.VisualAnalysisConfigScope.Raw, Airtop.VisualAnalysisConfigScope>;
+export declare namespace VisualAnalysisConfigScope {
+    type Raw = "viewport" | "page";
+}

package/dist/serialization/types/{EnvelopeStatusDefaultMetaStatus.js → VisualAnalysisConfigScope.js}

@@ -26,6 +26,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvelopeStatusDefaultMetaStatus = void 0;
+exports.VisualAnalysisConfigScope = void 0;
 const core = __importStar(require("../../core"));
-exports.EnvelopeStatusDefaultMetaStatus = core.serialization.enum_(["success", " failure", " timeout"]);
+exports.VisualAnalysisConfigScope = core.serialization.enum_(["viewport", "page"]);

package/dist/serialization/types/index.d.ts

@@ -1,11 +1,8 @@
 export * from "./AiPromptResponse";
 export * from "./AiResponseEnvelope";
+export * from "./ClickConfig";
 export * from "./ClientProvidedResponseMetadata";
-export * from "./EmptyResponse";
-export * from "./EmptyResponseJson";
 export * from "./EnvelopeDefaultMeta";
-export * from "./EnvelopeStatusDefaultMetaStatus";
-export * from "./EnvelopeStatusDefaultMeta";
 export * from "./ErrorDetail";
 export * from "./ErrorMessage";
 export * from "./ErrorModel";
@@ -16,6 +13,8 @@ export * from "./ExternalSessionAiResponseMetadataUsage";
 export * from "./ExternalSessionConfig";
 export * from "./ExternalSessionWithConnectionInfo";
 export * from "./Issue";
+export * from "./OperationOutcome";
+export * from "./OperationOutcomeResponse";
 export * from "./PageQueryConfig";
 export * from "./PageQueryExperimentalConfig";
 export * from "./Pagination";
@@ -37,6 +36,9 @@ export * from "./StatusMessageStatus";
 export * from "./StatusMessage";
 export * from "./SummaryConfig";
 export * from "./SummaryExperimentalConfig";
+export * from "./VisualAnalysisConfigPartitionDirection";
+export * from "./VisualAnalysisConfigScope";
+export * from "./VisualAnalysisConfig";
 export * from "./Window";
 export * from "./WindowId";
 export * from "./WindowIdResponse";

package/dist/serialization/types/index.js

@@ -16,12 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AiPromptResponse"), exports);
 __exportStar(require("./AiResponseEnvelope"), exports);
+__exportStar(require("./ClickConfig"), exports);
 __exportStar(require("./ClientProvidedResponseMetadata"), exports);
-__exportStar(require("./EmptyResponse"), exports);
-__exportStar(require("./EmptyResponseJson"), exports);
 __exportStar(require("./EnvelopeDefaultMeta"), exports);
-__exportStar(require("./EnvelopeStatusDefaultMetaStatus"), exports);
-__exportStar(require("./EnvelopeStatusDefaultMeta"), exports);
 __exportStar(require("./ErrorDetail"), exports);
 __exportStar(require("./ErrorMessage"), exports);
 __exportStar(require("./ErrorModel"), exports);
@@ -32,6 +29,8 @@ __exportStar(require("./ExternalSessionAiResponseMetadataUsage"), exports);
 __exportStar(require("./ExternalSessionConfig"), exports);
 __exportStar(require("./ExternalSessionWithConnectionInfo"), exports);
 __exportStar(require("./Issue"), exports);
+__exportStar(require("./OperationOutcome"), exports);
+__exportStar(require("./OperationOutcomeResponse"), exports);
 __exportStar(require("./PageQueryConfig"), exports);
 __exportStar(require("./PageQueryExperimentalConfig"), exports);
 __exportStar(require("./Pagination"), exports);
@@ -53,6 +52,9 @@ __exportStar(require("./StatusMessageStatus"), exports);
 __exportStar(require("./StatusMessage"), exports);
 __exportStar(require("./SummaryConfig"), exports);
 __exportStar(require("./SummaryExperimentalConfig"), exports);
+__exportStar(require("./VisualAnalysisConfigPartitionDirection"), exports);
+__exportStar(require("./VisualAnalysisConfigScope"), exports);
+__exportStar(require("./VisualAnalysisConfig"), exports);
 __exportStar(require("./Window"), exports);
 __exportStar(require("./WindowId"), exports);
 __exportStar(require("./WindowIdResponse"), exports);

package/dist/utils/batch-operate/SessionQueue.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import type { AirtopClient } from "wrapper/AirtopClient";
+import type { BatchOperationError, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from "./types";
+import type { EventEmitter } from "node:events";
+import type { AirtopSessionConfigV1 } from "wrapper/AirtopSessions";
+export declare class SessionQueue<T> {
+    private activePromises;
+    private activePromisesMutex;
+    private maxConcurrentSessions;
+    private runEmitter;
+    private maxWindowsPerSession;
+    private sessionConfig?;
+    private initialBatches;
+    private operation;
+    private onError?;
+    private isHalted;
+    private batchQueue;
+    private batchQueueMutex;
+    private latestProcessingPromise;
+    private processingPromisesCount;
+    private client;
+    private sessionPool;
+    private sessionPoolMutex;
+    private results;
+    constructor({ maxConcurrentSessions, runEmitter, maxWindowsPerSession, initialBatches, operation, client, sessionConfig, onError, }: {
+        maxConcurrentSessions: number;
+        runEmitter: EventEmitter;
+        maxWindowsPerSession: number;
+        initialBatches: BatchOperationUrl[][];
+        operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>;
+        client: AirtopClient;
+        sessionConfig?: AirtopSessionConfigV1;
+        onError?: (error: BatchOperationError) => Promise<void>;
+    });
+    handleHaltEvent(): void;
+    addUrlsToBatchQueue(newBatch: BatchOperationUrl[]): Promise<void>;
+    processInitialBatches(): Promise<void>;
+    waitForProcessingToComplete(): Promise<T[]>;
+    private terminateAllSessions;
+    private processPendingBatches;
+    private handleErrorWithCallback;
+    private logErrorForUrls;
+    private safelyTerminateSession;
+    private formatError;
+    private handleErrorAndWarningResponses;
+}

package/dist/utils/batch-operate/SessionQueue.js

@@ -0,0 +1,223 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionQueue = void 0;
+const helpers_1 = require("./helpers");
+const WindowQueue_1 = require("./WindowQueue");
+const async_mutex_1 = require("async-mutex");
+class SessionQueue {
+    constructor({ maxConcurrentSessions, runEmitter, maxWindowsPerSession, initialBatches, operation, client, sessionConfig, onError, }) {
+        this.activePromises = [];
+        this.activePromisesMutex = new async_mutex_1.Mutex();
+        this.initialBatches = [];
+        this.batchQueue = [];
+        this.batchQueueMutex = new async_mutex_1.Mutex();
+        this.latestProcessingPromise = null;
+        this.processingPromisesCount = 0;
+        this.sessionPool = [];
+        this.sessionPoolMutex = new async_mutex_1.Mutex();
+        if (!Number.isInteger(maxConcurrentSessions) ||
+            maxConcurrentSessions <= 0) {
+            throw new Error("maxConcurrentSessions must be a positive integer");
+        }
+        this.maxConcurrentSessions = maxConcurrentSessions;
+        this.runEmitter = runEmitter;
+        this.maxWindowsPerSession = maxWindowsPerSession;
+        this.sessionConfig = sessionConfig;
+        this.initialBatches = initialBatches;
+        this.operation = operation;
+        this.onError = onError;
+        this.latestProcessingPromise = null;
+        this.results = [];
+        this.client = client;
+        this.isHalted = false;
+    }
+    handleHaltEvent() {
+        this.client.log("Halt event received");
+        this.isHalted = true;
+    }
+    addUrlsToBatchQueue(newBatch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Distribute new URLs across batches
+            const newBatches = (0, helpers_1.distributeUrlsToBatches)(newBatch, this.maxConcurrentSessions);
+            this.client.log(`Adding new batches to queue: ${JSON.stringify(newBatches)}`);
+            // Add new batches to the queue
+            yield this.batchQueueMutex.runExclusive(() => {
+                this.batchQueue.push(...newBatches);
+            });
+            // Update existing processing promise
+            this.processingPromisesCount++;
+            this.latestProcessingPromise = this.processPendingBatches();
+        });
+    }
+    processInitialBatches() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.batchQueueMutex.runExclusive(() => {
+                this.batchQueue = [...this.initialBatches];
+            });
+            this.processingPromisesCount++;
+            this.runEmitter.on("halt", this.handleHaltEvent.bind(this));
+            this.latestProcessingPromise = this.processPendingBatches();
+            yield this.latestProcessingPromise;
+        });
+    }
+    waitForProcessingToComplete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.processingPromisesCount > 0) {
+                yield this.latestProcessingPromise;
+            }
+            yield this.terminateAllSessions();
+            this.runEmitter.removeListener("halt", this.handleHaltEvent);
+            return this.results;
+        });
+    }
+    terminateAllSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const sessionId of this.sessionPool) {
+                this.safelyTerminateSession(sessionId);
+            }
+        });
+    }
+    processPendingBatches() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                while (this.batchQueue.length > 0) {
+                    // Wait for any session to complete before starting a new one
+                    let shouldContinue = false;
+                    yield this.activePromisesMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.activePromises.length >= this.maxConcurrentSessions) {
+                            yield Promise.race(this.activePromises);
+                            shouldContinue = true;
+                        }
+                    }));
+                    if (shouldContinue)
+                        continue;
+                    let batch;
+                    yield this.batchQueueMutex.runExclusive(() => {
+                        batch = this.batchQueue.shift();
+                    });
+                    if (!batch || batch.length === 0)
+                        break;
+                    const promise = (() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.isHalted) {
+                            this.client.log("Halt event received, skipping batch");
+                            return;
+                        }
+                        let sessionId;
+                        try {
+                            // Check if there's an available session in the pool
+                            yield this.sessionPoolMutex.runExclusive(() => {
+                                if (this.sessionPool.length > 0) {
+                                    sessionId = this.sessionPool.pop();
+                                }
+                            });
+                            // Otherwise, create a new session
+                            if (!sessionId) {
+                                const { data: session, warnings, errors } = yield this.client.sessions.create({
+                                    configuration: this.sessionConfig,
+                                });
+                                sessionId = session.id;
+                                this.handleErrorAndWarningResponses({ warnings, errors, sessionId, batch });
+                            }
+                            const queue = new WindowQueue_1.WindowQueue(this.maxWindowsPerSession, this.runEmitter, sessionId, this.client, this.operation, this.onError, this.isHalted);
+                            const windowResults = yield queue.processInBatches(batch);
+                            this.results.push(...windowResults);
+                            // Return the session to the pool
+                            yield this.sessionPoolMutex.runExclusive(() => {
+                                if (!sessionId) {
+                                    throw new Error("Missing sessionId, cannot return to pool");
+                                }
+                                this.sessionPool.push(sessionId);
+                            });
+                        }
+                        catch (error) {
+                            if (this.onError) {
+                                yield this.handleErrorWithCallback({ originalError: error, batch, sessionId, callback: this.onError });
+                            }
+                            else {
+                                // By default, log the error and continue
+                                const urls = batch.map((url) => url.url);
+                                this.logErrorForUrls(urls, error);
+                            }
+                            // Clean up the session in case of error
+                            if (sessionId) {
+                                this.safelyTerminateSession(sessionId);
+                            }
+                        }
+                    }))();
+                    yield this.activePromisesMutex.runExclusive(() => {
+                        this.activePromises.push(promise);
+                    });
+                    // Remove the promise when it completes
+                    promise.finally(() => __awaiter(this, void 0, void 0, function* () {
+                        yield this.activePromisesMutex.runExclusive(() => {
+                            const index = this.activePromises.indexOf(promise);
+                            if (index > -1) {
+                                this.activePromises.splice(index, 1);
+                            }
+                        });
+                    }));
+                }
+                // Wait for all remaining sessions to complete
+                yield Promise.allSettled(this.activePromises);
+            }
+            finally {
+                this.processingPromisesCount--;
+            }
+        });
+    }
+    handleErrorWithCallback({ originalError, batch, sessionId, callback, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Catch any errors in the onError callback to avoid halting the entire process
+            try {
+                yield callback({
+                    error: this.formatError(originalError),
+                    operationUrls: batch,
+                    sessionId,
+                });
+            }
+            catch (newError) {
+                this.client.error(`Error in onError callback: ${this.formatError(newError)}. Original error: ${this.formatError(originalError)}`);
+            }
+        });
+    }
+    logErrorForUrls(urls, error) {
+        const message = `Error for URLs ${JSON.stringify(urls)}: ${this.formatError(error)}`;
+        this.client.error(message);
+    }
+    safelyTerminateSession(sessionId) {
+        // Do not await since we don't want to block the main thread
+        this.client.sessions.terminate(sessionId).catch((error) => {
+            this.client.error(`Error terminating session ${sessionId}: ${this.formatError(error)}`);
+        });
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    handleErrorAndWarningResponses({ warnings, errors, sessionId, batch }) {
+        if (!warnings && !errors)
+            return;
+        const details = {
+            sessionId,
+            urls: batch,
+        };
+        if (warnings) {
+            details.warnings = warnings;
+            this.client.warn(`Received warnings creating session: ${JSON.stringify(details)}`);
+        }
+        // Log an object with the errors and the URL
+        if (errors) {
+            details.errors = errors;
+            this.client.error(`Received errors creating session: ${JSON.stringify(details)}`);
+        }
+    }
+}
+exports.SessionQueue = SessionQueue;

package/dist/utils/batch-operate/WindowQueue.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { AirtopClient } from "wrapper/AirtopClient";
+import type { BatchOperationError, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from "./types";
+import type { EventEmitter } from "node:events";
+export declare class WindowQueue<T> {
+    private activePromises;
+    private urlQueue;
+    private activePromisesMutex;
+    private urlQueueMutex;
+    private maxWindowsPerSession;
+    private runEmitter;
+    private sessionId;
+    private client;
+    private operation;
+    private onError?;
+    private isHalted;
+    constructor(maxWindowsPerSession: number, runEmitter: EventEmitter, sessionId: string, client: AirtopClient, operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>, onError?: (error: BatchOperationError) => Promise<void>, isHalted?: boolean);
+    addUrlToQueue(url: BatchOperationUrl): Promise<void>;
+    private handleHaltEvent;
+    processInBatches(urls: BatchOperationUrl[]): Promise<T[]>;
+    private handleErrorWithCallback;
+    private safelyTerminateWindow;
+    private formatError;
+    private handleErrorAndWarningResponses;
+}

package/dist/utils/batch-operate/WindowQueue.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowQueue = void 0;
+const async_mutex_1 = require("async-mutex");
+class WindowQueue {
+    constructor(maxWindowsPerSession, runEmitter, sessionId, client, operation, onError, isHalted = false) {
+        this.activePromises = [];
+        this.urlQueue = [];
+        this.activePromisesMutex = new async_mutex_1.Mutex();
+        this.urlQueueMutex = new async_mutex_1.Mutex();
+        if (!Number.isInteger(maxWindowsPerSession) || maxWindowsPerSession <= 0) {
+            throw new Error("maxWindowsPerSession must be a positive integer");
+        }
+        this.maxWindowsPerSession = maxWindowsPerSession;
+        this.runEmitter = runEmitter;
+        this.sessionId = sessionId;
+        this.client = client;
+        this.operation = operation;
+        this.onError = onError;
+        this.isHalted = isHalted;
+    }
+    addUrlToQueue(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.urlQueueMutex.runExclusive(() => {
+                this.urlQueue.push(url);
+            });
+        });
+    }
+    handleHaltEvent() {
+        this.client.log("Halt event received");
+        this.isHalted = true;
+    }
+    processInBatches(urls) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            this.runEmitter.on("halt", this.handleHaltEvent.bind(this));
+            yield this.urlQueueMutex.runExclusive(() => {
+                this.urlQueue = [...urls];
+            });
+            this.client.log(`Processing batch: ${JSON.stringify(urls)} for session ${this.sessionId}`);
+            while (this.urlQueue.length > 0) {
+                // Wait for any window to complete before starting a new one
+                let shouldContinue = false;
+                yield this.activePromisesMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+                    if (this.activePromises.length >= this.maxWindowsPerSession) {
+                        yield Promise.race(this.activePromises);
+                        shouldContinue = true;
+                    }
+                }));
+                if (shouldContinue)
+                    continue;
+                let urlData;
+                yield this.urlQueueMutex.runExclusive(() => {
+                    urlData = this.urlQueue.shift(); // Take the next url from the queue
+                });
+                if (!urlData)
+                    break; // No more urls to process
+                // If we have less than the max concurrent operations, start a new one
+                const promise = (() => __awaiter(this, void 0, void 0, function* () {
+                    // Do not process any more urls if the processing has been halted
+                    if (this.isHalted) {
+                        this.client.log(`Processing halted, skipping window creation for ${urlData.url}`);
+                        return;
+                    }
+                    let windowId;
+                    let liveViewUrl;
+                    try {
+                        // Create a new window pointed to the url
+                        this.client.log(`Creating window for ${urlData.url} in session ${this.sessionId}`);
+                        const { data, errors, warnings } = yield this.client.windows.create(this.sessionId, {
+                            url: urlData.url,
+                        });
+                        windowId = data.windowId;
+                        this.handleErrorAndWarningResponses({ warnings, errors, sessionId: this.sessionId, url: urlData, operation: "window creation" });
+                        if (!windowId) {
+                            throw new Error(`WindowId not found, errors: ${JSON.stringify(errors)}`);
+                        }
+                        const { data: windowInfo, warnings: windowWarnings, errors: windowErrors } = yield this.client.windows.getWindowInfo(this.sessionId, windowId);
+                        liveViewUrl = windowInfo.liveViewUrl;
+                        this.handleErrorAndWarningResponses({ warnings: windowWarnings, errors: windowErrors, sessionId: this.sessionId, url: urlData, operation: "window info retrieval" });
+                        // Run the operation on the window
+                        const result = yield this.operation({
+                            windowId,
+                            sessionId: this.sessionId,
+                            liveViewUrl,
+                            operationUrl: urlData,
+                        });
+                        if (result) {
+                            const { shouldHaltBatch, additionalUrls, data } = result;
+                            if (data) {
+                                results.push(data);
+                            }
+                            if (shouldHaltBatch) {
+                                this.client.log("Emitting halt event");
+                                this.runEmitter.emit("halt");
+                            }
+                            if (additionalUrls && additionalUrls.length > 0) {
+                                this.client.log(`Emitting addUrls event with urls: ${JSON.stringify(additionalUrls)}`);
+                                this.runEmitter.emit("addUrls", additionalUrls);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (this.onError) {
+                            yield this.handleErrorWithCallback({
+                                originalError: error,
+                                url: urlData,
+                                callback: this.onError,
+                                windowId,
+                                liveViewUrl,
+                            });
+                        }
+                        else {
+                            // By default, log the error and continue
+                            const message = `Error for URL ${urlData.url}: ${this.formatError(error)}`;
+                            this.client.error(message);
+                        }
+                    }
+                    finally {
+                        if (windowId) {
+                            yield this.safelyTerminateWindow(windowId);
+                        }
+                    }
+                }))();
+                yield this.activePromisesMutex.runExclusive(() => {
+                    this.activePromises.push(promise);
+                });
+                // Remove the promise from the active list when it resolves
+                promise.finally(() => __awaiter(this, void 0, void 0, function* () {
+                    yield this.activePromisesMutex.runExclusive(() => {
+                        const index = this.activePromises.indexOf(promise);
+                        if (index > -1) {
+                            this.activePromises.splice(index, 1);
+                        }
+                    });
+                }));
+            }
+            // Wait for all processes to complete
+            yield Promise.allSettled(this.activePromises);
+            // Remove the halt listener
+            this.runEmitter.removeListener("halt", this.handleHaltEvent);
+            return results;
+        });
+    }
+    handleErrorWithCallback({ originalError, url, windowId, liveViewUrl, callback, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Catch any errors in the onError callback to avoid halting the entire process
+            try {
+                yield callback({
+                    error: this.formatError(originalError),
+                    operationUrls: [url],
+                    sessionId: this.sessionId,
+                    windowId,
+                    liveViewUrl,
+                });
+            }
+            catch (newError) {
+                this.client.error(`Error in onError callback: ${this.formatError(newError)}. Original error: ${this.formatError(originalError)}`);
+            }
+        });
+    }
+    safelyTerminateWindow(windowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.windows.close(this.sessionId, windowId);
+            }
+            catch (error) {
+                this.client.error(`Error closing window ${windowId}: ${this.formatError(error)}`);
+            }
+        });
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    handleErrorAndWarningResponses({ warnings, errors, sessionId, url, operation }) {
+        if (!warnings && !errors)
+            return;
+        const details = {
+            sessionId,
+            url,
+        };
+        if (warnings) {
+            details.warnings = warnings;
+            this.client.warn(`Received warnings for ${operation}: ${JSON.stringify(details)}`);
+        }
+        if (errors) {
+            details.errors = errors;
+            this.client.error(`Received errors for ${operation}: ${JSON.stringify(details)}`);
+        }
+    }
+}
+exports.WindowQueue = WindowQueue;

package/dist/utils/batch-operate/batch-util.d.ts

@@ -0,0 +1,3 @@
+import type { AirtopClient } from "wrapper/AirtopClient";
+import type { BatchOperateConfig, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from "./types";
+export declare const batchOperate: <T>(urls: BatchOperationUrl[], operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>, client: AirtopClient, config?: BatchOperateConfig | undefined) => Promise<T[]>;