@airtop/sdk 0.1.36 → 1.0.0-alpha2.1

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

@@ -1,222 +0,0 @@
-"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 async_mutex_1 = require("async-mutex");
-const WindowQueue_1 = require("./WindowQueue");
-const helpers_1 = require("./helpers");
-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(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ originalError, batch, sessionId, callback, }) {
-            // 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

@@ -1,24 +0,0 @@
-import type { EventEmitter } from 'eventemitter3';
-import type { AirtopClient } from '../../wrapper/AirtopClient';
-import type { BatchOperationError, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from './types';
-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

@@ -1,213 +0,0 @@
-"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(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ originalError, url, windowId, liveViewUrl, callback, }) {
-            // 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

@@ -1,3 +0,0 @@
-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) => Promise<T[]>;

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

@@ -1,49 +0,0 @@
-"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.batchOperate = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const SessionQueue_1 = require("./SessionQueue");
-const helpers_1 = require("./helpers");
-const DEFAULT_MAX_WINDOWS_PER_SESSION = 1;
-const DEFAULT_MAX_CONCURRENT_SESSIONS = 30;
-const batchOperate = (urls, operation, // operation to invoke on each url
-client, config) => __awaiter(void 0, void 0, void 0, function* () {
-    // Validate the urls before proceeding
-    if (!Array.isArray(urls)) {
-        throw new Error('Please provide a valid list of urls');
-    }
-    for (const url of urls) {
-        if (!url || typeof url !== 'object' || !('url' in url)) {
-            throw new Error('Please provide a valid list of urls');
-        }
-    }
-    const runEmitter = new eventemitter3_1.EventEmitter();
-    const { maxConcurrentSessions = DEFAULT_MAX_CONCURRENT_SESSIONS, maxWindowsPerSession = DEFAULT_MAX_WINDOWS_PER_SESSION, sessionConfig, onError, } = config !== null && config !== void 0 ? config : {};
-    // Split the urls into batches
-    const initialBatches = (0, helpers_1.distributeUrlsToBatches)(urls, maxConcurrentSessions);
-    const sessionQueue = new SessionQueue_1.SessionQueue({
-        maxConcurrentSessions,
-        runEmitter,
-        maxWindowsPerSession,
-        initialBatches,
-        operation,
-        client,
-        sessionConfig,
-        onError,
-    });
-    runEmitter.on('addUrls', (additionalUrls) => {
-        sessionQueue.addUrlsToBatchQueue(additionalUrls);
-    });
-    yield sessionQueue.processInitialBatches();
-    return yield sessionQueue.waitForProcessingToComplete();
-});
-exports.batchOperate = batchOperate;

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

@@ -1,2 +0,0 @@
-import type { BatchOperationUrl } from './types';
-export declare const distributeUrlsToBatches: (urls: BatchOperationUrl[], maxConcurrentSessions: number) => BatchOperationUrl[][];

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.distributeUrlsToBatches = void 0;
-const distributeUrlsToBatches = (urls, maxConcurrentSessions) => {
-    if (urls.length === 0)
-        return [];
-    // Calculate optimal number of batches
-    const batchCount = Math.min(maxConcurrentSessions, urls.length);
-    const batches = Array.from({ length: batchCount }, () => []);
-    urls.forEach((url, index) => {
-        const batchIndex = index % batchCount;
-        if (!batches[batchIndex]) {
-            batches[batchIndex] = [];
-        }
-        batches[batchIndex].push(url);
-    });
-    return batches;
-};
-exports.distributeUrlsToBatches = distributeUrlsToBatches;

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

@@ -1,29 +0,0 @@
-import type { AirtopSessionConfigV1 } from '../../wrapper/AirtopSessions';
-export type BatchOperateConfig = {
-    maxConcurrentSessions?: number;
-    maxWindowsPerSession?: number;
-    sessionConfig?: AirtopSessionConfigV1;
-    onError?: (error: BatchOperationError) => Promise<void>;
-};
-export type BatchOperationUrl = {
-    url: string;
-    context?: Record<string, unknown>;
-};
-export type BatchOperationInput = {
-    windowId: string;
-    sessionId: string;
-    liveViewUrl: string;
-    operationUrl: BatchOperationUrl;
-};
-export type BatchOperationResponse<T> = {
-    shouldHaltBatch?: boolean;
-    additionalUrls?: BatchOperationUrl[];
-    data?: T;
-};
-export type BatchOperationError = {
-    error: Error | string;
-    operationUrls: BatchOperationUrl[];
-    sessionId?: string;
-    windowId?: string;
-    liveViewUrl?: string;
-};

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from './batch-operate/batch-util';
-export * from './batch-operate/types';
-export * from './process-screenshots';

package/dist/utils/index.js

@@ -1,19 +0,0 @@
-"use strict";
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./batch-operate/batch-util"), exports);
-__exportStar(require("./batch-operate/types"), exports);
-__exportStar(require("./process-screenshots"), exports);

package/dist/utils/process-screenshots.d.ts

@@ -1,9 +0,0 @@
-import type { AiPromptResponse } from '../api';
-export type ProcessScreenshotsResponse = {
-    index: number;
-    success: boolean;
-    binaryData?: Buffer;
-    mimeType?: string;
-    error?: Error;
-};
-export declare function processScreenshots(response: AiPromptResponse): Promise<ProcessScreenshotsResponse[]>;

package/dist/utils/process-screenshots.js

@@ -1,58 +0,0 @@
-"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.processScreenshots = processScreenshots;
-function extractMimeAndBase64(dataUrl) {
-    const match = dataUrl.match(/^data:(image\/\w+);base64,(.+)$/);
-    if (match) {
-        return { mimeType: match[1], base64Data: match[2] };
-    }
-    return {
-        mimeType: 'image/jpeg',
-        base64Data: dataUrl.replace(/^data:image\/jpeg;base64,/, ''),
-    };
-}
-function processScreenshots(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const screenshots = response.meta.screenshots;
-        if (!screenshots) {
-            return [];
-        }
-        const processedScreenshots = screenshots.map((screenshot, index) => {
-            if (!screenshot.dataUrl) {
-                return {
-                    index,
-                    error: new Error('Screenshot data URL not found'),
-                    success: false,
-                };
-            }
-            try {
-                const { mimeType, base64Data } = extractMimeAndBase64(screenshot.dataUrl);
-                const binaryData = Buffer.from(base64Data, 'base64');
-                return {
-                    index,
-                    binaryData,
-                    mimeType,
-                    success: true,
-                };
-            }
-            catch (err) {
-                console.error(`Error processing screenshot ${index}:`, err);
-                return {
-                    index,
-                    error: err instanceof Error ? err : new Error(String(err)),
-                    success: false,
-                };
-            }
-        });
-        return processedScreenshots;
-    });
-}

package/dist/version.d.ts

@@ -1 +0,0 @@
-export declare const SDK_VERSION = "0.1.36";